剑指offer 5.3 时间与空间效率平衡 -丑数

面试题34：丑数

我们把只包含因子2、3和5的数称作丑数（Ugly Number）。

例如6、8都是丑数，但14不是，因为它包含因子7。习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第1500个丑数。

分析：这是一道在网络上广为流传的面试题，据说google曾经采用过这道题。

所谓一个数m是另一个数n的因子，是指n能被m整除，也就是n % m == 0。根据丑数的定义，丑数只能被2、3和5整除。也就是说如果一个数如果它能被2整除，我们把它连续除以2；如果能被3整除，就连续除以3；如果能被5整除，就除以连续5。如果最后我们得到的是1，那么这个数就是丑数，否则不是。

解法一：逐个判断每个整数是不是丑数，直观但不高效

// 判断某个数是不是丑数
bool IsUgly(int number)
{
    while(number % 2 == 0)
        number /= 2;
    while(number % 3 == 0)
        number /= 3;
    while(number % 5 == 0)
        number /= 5;
 
    return (number == 1) ? true : false;
}
// 接下来，我们只需要按顺序判断每一个整数是不是丑数，即：
int GetUglyNumber_Solution1(int index)
{
    if(index <= 0)
        return 0;
 
    int number = 0; //从０开始寻找
    int uglyFound = 0;　// 第uglyFound个丑数
    while(uglyFound < index)
    {
        ++number;
 
        if(IsUgly(number))
        {
            ++uglyFound;
        }
    }
 
    return number;
}

问题是：每个整数都需要计算，即使一个数字不是丑数，我们也要对其进行求余计和

除法计算，效率不是很高。

解法二：

    根据丑数的定义，丑数应该是另一个丑数乘以2、3或者5的结果（1除外）。

    因此我们可以创建一个数组，里面的数字是排好序的丑数。里面的每一个丑数是前面的丑数乘以2、3或者5得到的。

    思路的关键：怎样确保数组中的丑数是排好序的。

    假设数组中已经有若干个丑数，排好序后存放在数组中。现有的最大的丑数记作M.

    现在，开始生成下一个丑数，该丑数是前面某一个丑数乘以2、3或5的结果。

    首先考虑把已有的每个丑数乘以2，在乘以2的时候，能得到若干个结果小于或等于M的。由于是按照顺序生成的，小于或者等于M的数肯定已经在数组中了，不需要再次考虑；而得到的若干个大于M的结果，只需要第一个大于M的结果，记为M2；

    按照同样的方法，把已有的丑数成以3和5，得到第一个大于M的结果M3和M5；

    那么下一个丑数可定时M2\M3\M5中最小的。

    根据前面的分析，把已有的每个丑数乘以2、3、5，事实上是不必要的，因为已有的丑数是按顺序在数组中的。对乘以2而言，肯定存在某一个丑数T2,排在T2之前的每一个丑数乘以2得到的结果都会小于已有的最大的丑数，在T2之后的每个丑数乘以2得到的结果都会大于已有的最大丑数。

只需要记下这个丑数T2的位置，同时每次生成新丑数的时候，去更新这个T2,对3和5而言，同样存在这T3和T5.

   

//获取第k个丑数，假定1为第一个丑数
int findIndexthUglyNumber2(int index)
{
    //如果index<=0表明输入有误，直接返回0
    if(index<=0)
        return 0;
    //定义丑数数组，用于记录排序的丑数
    int *pUglyNumbers=new int[index];
    //第一个丑数为1
    pUglyNumbers[0]=1;
    //第一个丑数的坐标是0，下一个丑数的坐标从1开始
    int nextUglyIndex=1;
    //定义三个指向丑数数组的指针，用它们来标识从数组中的哪一个数开始计算M2，M3和M5，开始都是丑数数组的首地址。
    int *T2=pUglyNumbers;
    int *T3=pUglyNumbers;
    int *T5=pUglyNumbers;
    while(nextUglyIndex<index)//
    {
        int min=Min(*T2 * 2,*T3 * 3,*T5 * 5);//M2=*T2 * 2, M3=*T3 * 3, M5=*T5 * 5
        pUglyNumbers[nextUglyIndex]=min;//求M2，M3，M5的最小值作为新的丑数放入丑数数组
        //每次生成新的丑数的时候，去更新T2，T3和T5.
        while(*T2 * 2<=pUglyNumbers[nextUglyIndex])
            ++T2;
        while(*T3 * 3<=pUglyNumbers[nextUglyIndex])
            ++T3;
        while(*T5 * 5<=pUglyNumbers[nextUglyIndex])
            ++T5;
        nextUglyIndex++;
    }
    int ugly=pUglyNumbers[index-1];//因为丑数有序排列，所以丑数数组中的最后一个丑数就是我们所求的第index个丑数。
    delete[] pUglyNumbers;
    return ugly;
}

和第一种思路相比，这种算法不需要在非丑数的整数上做任何计算，因此时间复杂度要低很多。

当然我们也要指出，第二种算法由于要保存已经生成的丑数，因此需要一个数组，从而需要额外的内存。第一种算法是没有这样的内存开销的。