丑数

只包含因子2,3,5的数称作丑数。要求按从小到大的顺序输出指定数量的丑数。

有2中方法：

第一种：用穷举法，从最小的1开始判断穷举，是丑数就输出，否则继续循环判断。判断的方法是：如果一个数能被2整除，我们把他连续除以2；如果能被3整除，我们把他连续除以3；如果能被5整除，我们把他连续除以5。如果最后得到的值为1，那么这个数就是丑数。具体代码如下：

////////////丑数///////////////////////

bool isUgly(int number)
{
    assert(number > 0);
    while (number % 2 == 0)
    {
        number /= 2 ;
    }
    while (number % 3 == 0)
    {
        number /= 3 ;
    }
    while (number % 5 == 0)
    {
        number /= 5 ;
    }

    return (number == 1) ? true : false ;
}
void GetUgly1(int index)
{
    if (index <= 0)
    {
        return;
    }
    int number = 0 ;
    int count = 0 ;
    while (count < index)
    {
        ++number;
        if (isUgly(number))
        {
            count++ ;
            cout<<number<<endl;
        }
    }
}

int main()
{
    unsigned long  start_time = GetTickCount(); 
    GetUgly1(1000);
    unsigned long  end_time = GetTickCount(); 
    cout<<"The run time is: "<<(end_time-start_time)<<"ms!"<<endl;//输出运行时间
    getchar();
    return 0;
}

输出1000个丑数的结果如下图：

第二种：

用空间换时间，创建一个数组，里面的数字是排好序的丑数，下一个丑数是前面丑数乘以2、3、5得到的大于当前最大丑数的最小一个数。和第一种思路相比，第二种思路不需要在非丑数上做任何计算，因此时间效率会明显提升，但增加了空间消耗。具体代码如下：

int Min(int num1 , int num2 , int num3)
{
    int min = (num1 < num2) ? num1 : num2 ;
    return (min < num3) ? min : num3 ;
}


void GetUgly2(int index)
{
    if (index <= 0)
    {
        return ;
    }
    int* pUglyNumbers = new int[index];
    pUglyNumbers[0] = 1 ;
    int* pUglyNumbers2 = pUglyNumbers ;//指向丑数乘以因数2后得到的最大丑数的位置，起始位置为pUglyNumbers[0]
    int* pUglyNumbers3 = pUglyNumbers ;//指向丑数乘以因数3后得到的最大丑数的位置，起始位置为pUglyNumbers[0]
    int* pUglyNumbers5 = pUglyNumbers ;//指向丑数乘以因数5后得到的最大丑数的位置，起始位置为pUglyNumbers[0]
    int NextUgly = 1 ; //下一个丑数存储的位置
    while ( NextUgly < index )
    {
        int min = Min((*pUglyNumbers2) * 2 , (*pUglyNumbers3) * 3 , (*pUglyNumbers5) * 5) ;//取最小的值作为下一个丑数
        pUglyNumbers[NextUgly] = min ;

        while ((*pUglyNumbers2) * 2 <= min) //改变pUglyNumbers2的位置，使其指向后续所有丑数乘以因数2后得到的最大丑数
        {
            pUglyNumbers2++ ;
        }
        while ((*pUglyNumbers3) * 3 <= min) //改变pUglyNumbers3的位置，使其指向后续所有丑数乘以因数3后得到的最大丑数
        {
            pUglyNumbers3++ ;
        }
        while ((*pUglyNumbers5) * 5 <= min) //改变pUglyNumbers5的位置，使其指向后续所有丑数乘以因数5后得到的最大丑数
        {
            pUglyNumbers5++ ;
        }

        NextUgly++ ;

    }

    for (int i = 0 ; i < index ; i++)
    {
        cout<<pUglyNumbers[i]<<endl;
    }

    delete[] pUglyNumbers ;

}

int main()
{
    unsigned long  start_time = GetTickCount(); 
    GetUgly2(1000);
    unsigned long  end_time = GetTickCount(); 
    cout<<"The run time is: "<<(end_time-start_time)<<"ms!"<<endl;//输出运行时间
    getchar();
    return 0;
}

输出1000个丑数的结果如下图：

可以看见第二种方法时间效率提高了10多倍！！