每天一道算法题19 寻找丑数

最新推荐文章于 2022-12-17 22:31:10 发布

君记否

最新推荐文章于 2022-12-17 22:31:10 发布

阅读量464

点赞数

分类专栏：面试 algorithm 文章标签：算法 delete google 面试网络

面试同时被 2 个专栏收录

35 篇文章 0 订阅

订阅专栏

algorithm

26 篇文章 0 订阅

订阅专栏

题目：我们把只包含因子

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;

while (uglyFound < index)

{

++number;

if (IsUgly(number))

{

++uglyFound;

}

return number;

}

我们只需要在函数GetUglyNumber_Solution1 中传入参数 1500 ，就能得到第 1500 个丑数。该算法非常直观，代码也非常简洁，但最大的问题我们每个整数都需要计算。即使一个数字不是丑数，我们还是需要对它做求余数和除法操作。因此该算法的时间效率不是很高。

接下来我们换一种思路来分析这个问题，试图只计算丑数，而不在非丑数的整数上花费时间。根据丑数的定义，丑数应该是另一个丑数乘以2 、 3 或者 5 的结果（ 1 除外）。因此我们可以创建一个数组，里面的数字是排好序的丑数。里面的每一个丑数是前面的丑数乘以 2 、 3 或者 5 得到的。

这种思路的关键在于怎样确保数组里面的丑数是排好序的。我们假设数组中已经有若干个丑数，排好序后存在数组中。我们把现有的最大丑数记做M 。现在我们来生成下一个丑数，该丑数肯定是前面某一个丑数乘以 2 、 3 或者 5 的结果。我们首先考虑把已有的每个丑数乘以 2 。在乘以 2 的时候，能得到若干个结果小于或等于 M 的。由于我们是按照顺序生成的，小于或者等于 M 肯定已经在数组中了，我们不需再次考虑；我们还会得到若干个大于 M 的结果，但我们只需要第一个大于 M 的结果，因为我们希望丑数是按从小到大顺序生成的，其他更大的结果我们以后再说。我们把得到的第一个乘以 2 后大于 M 的结果，记为 M₂ 。同样我们把已有的每一个丑数乘以 3 和 5 ，能得到第一个大于 M 的结果 M₃ 和 M₅ 。那么下一个丑数应该是 M₂ 、 M₃ 和 M₅ 三个数的最小者。

前面我们分析的时候，提到把已有的每个丑数分别都乘以2 、 3 和 5 ，事实上是不需要的，因为已有的丑数是按顺序存在数组中的。对乘以 2 而言，肯定存在某一个丑数 T₂ ，排在它之前的每一个丑数乘以 2 得到的结果都会小于已有最大的丑数，在它之后的每一个丑数乘以 2 得到的结果都会太大。我们只需要记下这个丑数的位置，同时每次生成新的丑数的时候，去更新这个 T₂ 。对乘以 3 和 5 而言，存在着同样的 T₃ 和 T₅ 。

有了这些分析，我们不难写出如下的代码：

int GetUglyNumber_Solution2(int index)

{

if (index <= 0)

return 0;

int *pUglyNumbers = new int [index];

pUglyNumbers[0] = 1;

int nextUglyIndex = 1;

int *pMultiply2 = pUglyNumbers;

int *pMultiply3 = pUglyNumbers;

int *pMultiply5 = pUglyNumbers;

while (nextUglyIndex < index)

{

int min = Min(*pMultiply2 * 2, *pMultiply3 * 3, *pMultiply5 * 5);

pUglyNumbers[nextUglyIndex] = min;

while (*pMultiply2 * 2 <= pUglyNumbers[nextUglyIndex])

++pMultiply2;

while (*pMultiply3 * 3 <= pUglyNumbers[nextUglyIndex])

++pMultiply3;

while (*pMultiply5 * 5 <= pUglyNumbers[nextUglyIndex])

++pMultiply5;

++nextUglyIndex;

}

int ugly = pUglyNumbers[nextUglyIndex - 1];

delete [] pUglyNumbers;

return ugly;

}

int Min(int number1, int number2, int number3)

{

int min = (number1 < number2) ? number1 : number2;

min = (min < number3) ? min : number3;

return min;

}

和第一种思路相比，这种算法不需要在非丑数的整数上做任何计算，因此时间复杂度要低很多。感兴趣的读者可以分别统计两个函数 GetUglyNumber_Solution1(1500) 和 GetUglyNumber_Solution2(1500) 的运行时间。当然我们也要指出，第二种算法由于要保存已经生成的丑数，因此需要一个数组，从而需要额外的内存。第一种算法是没有这样的内存开销的。

http://www.cnblogs.com/mingzi/archive/2009/08/04/1538491.html