输出1到最大的N位数

题目：输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，则输出1、2、3一直到最大的3位数即999。

分析：这是一道很有意思的题目。看起来很简单，其实里面却有不少的玄机。

应聘者在解决这个问题的时候，最容易想到的方法是先求出最大的n位数是什么，然后用一个循环从1开始逐个输出。很快，我们就能写出如下代码：

 

// Print numbers from 1 to the maximum number with n digits, in order
void Print1ToMaxOfNDigits_1(int n)
{
    // calculate 10^n
    int number = 1;
    int i = 0;
    while(i++ < n)
        number *= 10;
 
    // print from 1 to (10^n - 1)
    for(i = 1; i < number; ++i)
        printf("%d\t", i);
}

 

初看之下，好像没有问题。但如果我们仔细分析这个问题，就能注意到这里没有规定n的范围，当我们求最大的n位数的时候，是不是有可能用整型甚至长整型都会溢出？

分析到这里，我们很自然的就想到我们需要表达一个大数。最常用的也是最容易实现的表达大数的方法是用字符串或者整型数组（当然不一定是最有效的）。

用字符串表达数字的时候，最直观的方法就是字符串里每个字符都是’0’到’9’之间的某一个字符，表示数字中的某一位。因为数字最大是n位的，因此我们需要一个n+1位字符串（最后一位为结束符号’\0’）。当实际数字不够n位的时候，在字符串的前半部分补零。这样，数字的个位永远都在字符串的末尾（除去结尾符号）。

首先我们把字符串中每一位数字都初始化为’0’。然后每一次对字符串表达的数字加1，再输出。因此我们只需要做两件事：一是在字符串表达的数字上模拟加法。另外我们要把字符串表达的数字输出。值得注意的是，当数字不够n位的时候，我们在数字的前面补零。输出的时候这些补位的0不应该输出。比如输入3的时候，那么数字98以098的形式输出，就不符合我们的习惯了。

基于上述分析，我们可以写出如下代码：

// Print numbers from 1 to the maximum number with n digits, in order
void Print1ToMaxOfNDigits_2(int n)
{
    // 0 or minus numbers are invalid input
    if(n <= 0)
        return;
 
    // number is initialized as 0
    char *number = new char[n + 1];
    memset(number, '0', n);
    number[n] = '\0';
 
    while(!Increment(number))
    {
        PrintNumber(number);
    }
 
    delete []number;
}
 
// Increment a number. When overflow, return true; otherwise return false
bool Increment(char* number)
{
    bool isOverflow = false;
    int nTakeOver = 0;
    int nLength = strlen(number);
 
    // Increment (Add 1) operation begins from the end of number
    for(int i = nLength - 1; i >= 0; i --)
    {
        int nSum = number[i] - '0' + nTakeOver;
        if(i == nLength - 1)
            nSum ++;
 
        if(nSum >= 10)
        {
            if(i == 0)
                isOverflow = true;
            else
            {
                nSum -= 10;
                nTakeOver = 1;
                number[i] = '0' + nSum;
            }
        }
        else
        {
            number[i] = '0' + nSum;
            break;
        }
    }
 
    return isOverflow;
}
 
// Print number stored in string, ignore 0 at its beginning
// For example, print "0098" as "98"
void PrintNumber(char* number)
{
    bool isBeginning0 = true;
    int nLength = strlen(number);
 
    for(int i = 0; i < nLength; ++ i)
    {
        if(isBeginning0 && number[i] != '0')
            isBeginning0 = false;
 
        if(!isBeginning0)
        {
            printf("%c", number[i]);
        }
    }
 
    printf("\t");
}

 第二种思路基本上和第一种思路相对应，只是把一个整型数值换成了字符串的表示形式。同时，值得提出的是，判断打印是否应该结束时，我没有调用函数strcmp比较字符串number和”99…999”（n个9）。这是因为strcmp的时间复杂度是O(n)，而判断是否溢出的平均时间复杂度是O(1)。

         第二种思路虽然比较直观，但由于模拟了整数的加法，代码有点长。要在面试短短几十分钟时间里完整正确写出这么长代码，不是件容易的事情。接下来我们换一种思路来考虑这个问题。如果我们在数字前面补0的话，就会发现n位所有10进制数其实就是n个从0到9的全排列。也就是说，我们把数字的每一位都从0到9排列一遍，就得到了所有的10进制数。只是我们在输出的时候，数字排在前面的0我们不输出罢了。

         全排列用递归很容易表达，数字的每一位都可能是0到9中的一个数，然后设置下一位。递归结束的条件是我们已经设置了数字的最后一位。

 

// Print numbers from 1 to the maximum number with n digits, in order
void Print1ToMaxOfNDigits_3(int n)
{
    // 0 or minus numbers are invalid input
    if(n <= 0)
        return;
 
    char* number = new char[n + 1];
    number[n] = '\0';
 
    for(int i = 0; i < 10; ++i)
    {
        // first digit can be 0 to 9
        number[0] = i + '0';
 
        Print1ToMaxOfNDigitsRecursively(number, n, 0);
    }
 
    delete[] number;
}
 
// length: length of number
// index: current index of digit in number for this round
void Print1ToMaxOfNDigitsRecursively(char* number, int length, int index)
{
    // we have reached the end of number, print it
    if(index == length - 1)
    {
        PrintNumber(number);
        return;
    }
 
    for(int i = 0; i < 10; ++i)
    {
        // next digit can be 0 to 9
        number[index + 1] = i + '0';
 
        // go to the next digit
        Print1ToMaxOfNDigitsRecursively(number, length, index + 1);
    }
}

 

函数PrintNumber和前面第二种思路中的一样，这里就不重复了。对比这两种思路，我们可以发现，递归能够用很简洁的代码来解决问题。

 

以上摘自何海涛博客