输入数字n，按顺序打印出1到最大的n位十进制数。比如输入3，则打印出1、2、3一直到最大的3位数即999。

    输入数字n，按顺序打印出1到最大的n位十进制数。比如输入3，则打印出1、2、3一直到最大的3位数即999。

陷阱：考虑大数问题，就是输入的数字非常大的情况，如100，怎么表示100位的数呢，可以用字符串保存。

 

细节问题：

1.字符串递增的溢出判断

2.打印时过滤0

 

方法一：

      使用字符串数组表示大数，最直观的方法是字符串里每个字符都是’0’到’9’之间的某一个字符，用来表示数字中的一位。因为数字最大是n位的，因此我们需要一个长度为n+l的字符串（字符串中最后一个是结束号’\0’）。当实际数字不够n位的时候，在字符串的前半部分补0。

      首先把字符串中的每一个数字都初始化为’0’，然后每一次为字符串表示的数字加1，再打印出来。因此只需要做两件事：一是在字符串表达的数字上模拟加法，二是把字符串表达的数字打印出来。

      在这里定义了函数PrintNumber，在这个函数里，只有在碰到第一个非0的字符之后才开始打印，直至字符串的结尾。

 

[cpp]  view plain  copy

1. // ====================方法一====================  
2. void Print1ToMaxOfNDigits_1(int n)  
3. {  
4.     if (n <= 0)  
5.     {  
6.         printf("n必须为正整数，参数错误！");  
7.         return;  
8.     }  
9.   
10.     char* number = new char[n + 1];  
11.     memset(number, '0', n);  
12.     number[n] = '\0';  
13.   
14.     while (!Increment(number))  
15.     {  
16.         PrintNumber(number);  
17.     }  
18.   
19.     delete[] number;  
20. }  
21.   
22.   
23. // 字符串number表示一个数字，在 number上增加1,如果做加法溢出，则返回true；否则为false  
24. bool Increment(char* number)  
25. {  
26.     bool isOverflow = false;  
27.     int nTakeOver = 0;  
28.     int nLength = strlen(number);  
29.   
30.     for (int i = nLength - 1; i >= 0; i--)  
31.     {  
32.         //将字符串number变为整数，后面才可以自++运算  
33.         int nSum = number[i] - '0' + nTakeOver;  
34.   
35.         if (i == nLength - 1)  
36.         {  
37.             nSum++;  
38.         }  
39.   
40.         if (nSum >= 10)  
41.         {  
42.             if (i == 0)//由9变为10，这里用0代替，加法溢出了  
43.             {  
44.                 isOverflow = true;  
45.             }  
46.             else  
47.             {  
48.                 nSum -= 10;  
49.                 nTakeOver = 1;  
50.                 number[i] = '0' + nSum;//将整数number变为字符串，方便后面进行打印  
51.             }  
52.         }  
53.         else  
54.         {  
55.             number[i] = '0' + nSum;  
56.             break;  
57.         }  
58.     }  
59.   
60.     return isOverflow;  
61. }  

方法二：

思路：将n位数看做排列组合问题，以3位数为例，有3个位置，每个位上从0到9中选一个数字放进去，求所有的排列情况。三个位置是依次放进去数字的，这可以用递归。每个位置上0到9的十种情况可以用for循环来遍历。另外，记得函数最开始进入时要检查边界条件。

 

[cpp]  view plain  copy

1. // ====================方法二====================  
2. void Print1ToMaxOfNDigits_2(int n)  
3. {  
4.     if (n <= 0)  
5.     {  
6.         printf("n必须为正整数，参数错误！");  
7.         return;  
8.     }  
9.   
10.     char* number = new char[n + 1];  
11.     number[n] = '\0';  
12.   
13.     for (int i = 0; i < 10; i++)  
14.     {  
15.         number[0] = i + '0';//整数转为字符串  
16.   
17.         Print1ToMaxOfNDigitsRecursively(number, n, 0);  
18.     }  
19.   
20.     delete[] number;  
21. }  
22.   
23. //数字全排列递归法  
24. void Print1ToMaxOfNDigitsRecursively(char* number, int length, int index)  
25. {  
26.     //到了最后一位数字，递归结束  
27.     if (index == length - 1)  
28.     {  
29.         PrintNumber(number);  
30.         return;  
31.     }  
32.   
33.     for (int i = 0; i < 10; i++)  
34.     {  
35.         //整数转为字符串  
36.         number[index + 1] = i + '0';  
37.   
38.         Print1ToMaxOfNDigitsRecursively(number, length, index + 1);  
39.     }  
40. }  

测试用例：

1.功能测试（输入1，2，3，…）；

 

2.特殊输入测试（输入-1，0）。

 

完整代码及测试用例实现：

 

[cpp]  view plain  copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <string.h>  
4.   
5. //打印1到最大N位数字  
6. void PrintNumber(char* number);  
7. //字符串number表示一个数字，在 number上增加1，如果做加法溢出，返回true；否则为false  
8. bool Increment(char* number);  
9. //数字全排列递归法  
10. void Print1ToMaxOfNDigitsRecursively(char* number, int length, int index);  
11.   
12.   
13. // ====================方法一====================  
14. void Print1ToMaxOfNDigits_1(int n)  
15. {  
16.     if (n <= 0)  
17.     {  
18.         printf("n必须为正整数，参数错误！");  
19.         return;  
20.     }  
21.   
22.     char* number = new char[n + 1];  
23.     memset(number, '0', n);  
24.     number[n] = '\0';  
25.   
26.     while (!Increment(number))  
27.     {  
28.         PrintNumber(number);  
29.     }  
30.   
31.     delete[] number;  
32. }  
33.   
34.   
35. // 字符串number表示一个数字，在 number上增加1,如果做加法溢出，则返回true；否则为false  
36. bool Increment(char* number)  
37. {  
38.     bool isOverflow = false;  
39.     int nTakeOver = 0;  
40.     int nLength = strlen(number);  
41.   
42.     for (int i = nLength - 1; i >= 0; i--)  
43.     {  
44.         //将字符串number变为整数，后面才可以自++运算  
45.         int nSum = number[i] - '0' + nTakeOver;  
46.   
47.         if (i == nLength - 1)  
48.         {  
49.             nSum++;  
50.         }  
51.   
52.         if (nSum >= 10)  
53.         {  
54.             if (i == 0)//由9变为10，这里用0代替，加法溢出了  
55.             {  
56.                 isOverflow = true;  
57.             }  
58.             else  
59.             {  
60.                 nSum -= 10;  
61.                 nTakeOver = 1;  
62.                 number[i] = '0' + nSum;//将整数number变为字符串，方便后面进行打印  
63.             }  
64.         }  
65.         else  
66.         {  
67.             number[i] = '0' + nSum;  
68.             break;  
69.         }  
70.     }  
71.   
72.     return isOverflow;  
73. }  
74.   
75.   
76. // ====================方法二====================  
77. void Print1ToMaxOfNDigits_2(int n)  
78. {  
79.     if (n <= 0)  
80.     {  
81.         printf("n必须为正整数，参数错误！");  
82.         return;  
83.     }  
84.   
85.     char* number = new char[n + 1];  
86.     number[n] = '\0';  
87.   
88.     for (int i = 0; i < 10; i++)  
89.     {  
90.         number[0] = i + '0';//整数转为字符串  
91.   
92.         Print1ToMaxOfNDigitsRecursively(number, n, 0);  
93.     }  
94.   
95.     delete[] number;  
96. }  
97.   
98. //数字全排列递归法  
99. void Print1ToMaxOfNDigitsRecursively(char* number, int length, int index)  
100. {  
101.     //到了最后一位数字，递归结束  
102.     if (index == length - 1)  
103.     {  
104.         PrintNumber(number);  
105.         return;  
106.     }  
107.   
108.     for (int i = 0; i < 10; i++)  
109.     {  
110.         //整数转为字符串  
111.         number[index + 1] = i + '0';  
112.   
113.         Print1ToMaxOfNDigitsRecursively(number, length, index + 1);  
114.     }  
115. }  
116.   
117. // ====================公共函数====================  
118. // 字符串number表示一个数字，数字有若干个0开头， 打印出这个数字，并忽略前面的0  
119. void PrintNumber(char* number)  
120. {  
121.     bool isBeginning = true;  
122.     int nLength = strlen(number);  
123.   
124.     for (int i = 0; i < nLength; i++)  
125.     {  
126.         if (isBeginning&&number[i] != '0')  
127.         {  
128.             isBeginning = false;  
129.         }  
130.         if (!isBeginning)  
131.         {  
132.             printf("%c", number[i]);  
133.         }  
134.     }  
135.   
136.     printf("\t");  
137. }  
138.   
139.   
140. // ====================测试代码====================  
141. void Test(int n)  
142. {  
143.     printf("Test for %d begins(方法一):\n", n);  
144.     Print1ToMaxOfNDigits_1(n);  
145.     printf("\n");  
146.   
147.     printf("Test for %d begins(方法二):\n", n);  
148.     Print1ToMaxOfNDigits_2(n);  
149.     printf("\n");  
150.   
151.     printf("Test for %d ends.\n", n);  
152. }  
153.   
154. int main(int argc, int* argv[])  
155. {  
156.     Test(1);  
157.     Test(2);  
158.     Test(3);  
159.     Test(0);  
160.     Test(-1);  
161.     system("pause");  
162.     return 0;  
163. }  

运行结果：

Test for 1 begins(方法一):

1       2       3       4       5       6       7       8       9

Test for 1 begins(方法二):

        1       2       3       4       5       6       7       8       9

Test for 1 ends.

Test for 2 begins(方法一):

1       2       3       4       5       6       7       8       9       10      11      12      13      14      15

16      17      18      19      20      21      22      23      24      25      26      27      28      29      30

31      32      33      34      35      36      37      38      39      40      41      42      43      44      45

46      47      48      49      50      51      52      53      54      55      56      57      58      59      60

61      62      63      64      65      66      67      68      69      70      71      72      73      74      75

76      77      78      79      80      81      82      83      84      85      86      87      88      89      90

91      92      93      94      95      96      97      98      99

Test for 2 begins(方法二):

        1       2       3       4       5       6       7       8       9       10      11      12      13      14

15      16      17      18      19      20      21      22      23      24      25      26      27      28      29

30      31      32      33      34      35      36      37      38      39      40      41      42      43      44

45      46      47      48      49      50      51      52      53      54      55      56      57      58      59

60      61      62      63      64      65      66      67      68      69      70      71      72      73      74

75      76      77      78      79      80      81      82      83      84      85      86      87      88      89

90      91      92      93      94      95      96      97      98      99

Test for 2 ends.

Test for 3 begins(方法一):

1       2       3       4       5       6       7       8       9       10      11      12      13      14      15

16      17      18      19      20      21      22      23      24      25      26      27      28      29      30

31      32      33      34      35      36      37      38      39      40      41      42      43      44      45

46      47      48      49      50      51      52      53      54      55      56      57      58      59      60

61      62      63      64      65      66      67      68      69      70      71      72      73      74      75

76      77      78      79      80      81      82      83      84      85      86      87      88      89      90

91      92      93      94      95      96      97      98      99      100     101     102     103     104     105

106     107     108     109     110     111     112     113     114     115     116     117     118     119     120

121     122     123     124     125     126     127     128     129     130     131     132     133     134     135

136     137     138     139     140     141     142     143     144     145     146     147     148     149     150

151     152     153     154     155     156     157     158     159     160     161     162     163     164     165

166     167     168     169     170     171     172     173     174     175     176     177     178     179     180

181     182     183     184     185     186     187     188     189     190     191     192     193     194     195

196     197     198     199     200     201     202     203     204     205     206     207     208     209     210

211     212     213     214     215     216     217     218     219     220     221     222     223     224     225

226     227     228     229     230     231     232     233     234     235     236     237     238     239     240

241     242     243     244     245     246     247     248     249     250     251     252     253     254     255

256     257     258     259     260     261     262     263     264     265     266     267     268     269     270

271     272     273     274     275     276     277     278     279     280     281     282     283     284     285

286     287     288     289     290     291     292     293     294     295     296     297     298     299     300

301     302     303     304     305     306     307     308     309     310     311     312     313     314     315

316     317     318     319     320     321     322     323     324     325     326     327     328     329     330

331     332     333     334     335     336     337     338     339     340     341     342     343     344     345

346     347     348     349     350     351     352     353     354     355     356     357     358     359     360

361     362     363     364     365     366     367     368     369     370     371     372     373     374     375

376     377     378     379     380     381     382     383     384     385     386     387     388     389     390

391     392     393     394     395     396     397     398     399     400     401     402     403     404     405

406     407     408     409     410     411     412     413     414     415     416     417     418     419     420

421     422     423     424     425     426     427     428     429     430     431     432     433     434     435

436     437     438     439     440     441     442     443     444     445     446     447     448     449     450

451     452     453     454     455     456     457     458     459     460     461     462     463     464     465

466     467     468     469     470     471     472     473     474     475     476     477     478     479     480

481     482     483     484     485     486     487     488     489     490     491     492     493     494     495

496     497     498     499     500     501     502     503     504     505     506     507     508     509     510

511     512     513     514     515     516     517     518     519     520     521     522     523     524     525

526     527     528     529     530     531     532     533     534     535     536     537     538     539     540

541     542     543     544     545     546     547     548     549     550     551     552     553     554     555

556     557     558     559     560     561     562     563     564     565     566     567     568     569     570

571     572     573     574     575     576     577     578     579     580     581     582     583     584     585

586     587     588     589     590     591     592     593     594     595     596     597     598     599     600

601     602     603     604     605     606     607     608     609     610     611     612     613     614     615

616     617     618     619     620     621     622     623     624     625     626     627     628     629     630

631     632     633     634     635     636     637     638     639     640     641     642     643     644     645

646     647     648     649     650     651     652     653     654     655     656     657     658     659     660

661     662     663     664     665     666     667     668     669     670     671     672     673     674     675

676     677     678     679     680     681     682     683     684     685     686     687     688     689     690

691     692     693     694     695     696     697     698     699     700     701     702     703     704     705

706     707     708     709     710     711     712     713     714     715     716     717     718     719     720

721     722     723     724     725     726     727     728     729     730     731     732     733     734     735

736     737     738     739     740     741     742     743     744     745     746     747     748     749     750

751     752     753     754     755     756     757     758     759     760     761     762     763     764     765

766     767     768     769     770     771     772     773     774     775     776     777     778     779     780

781     782     783     784     785     786     787     788     789     790     791     792     793     794     795

796     797     798     799     800     801     802     803     804     805     806     807     808     809     810

811     812     813     814     815     816     817     818     819     820     821     822     823     824     825

826     827     828     829     830     831     832     833     834     835     836     837     838     839     840

841     842     843     844     845     846     847     848     849     850     851     852     853     854     855

856     857     858     859     860     861     862     863     864     865     866     867     868     869     870

871     872     873     874     875     876     877     878     879     880     881     882     883     884     885

886     887     888     889     890     891     892     893     894     895     896     897     898     899     900

901     902     903     904     905     906     907     908     909     910     911     912     913     914     915

916     917     918     919     920     921     922     923     924     925     926     927     928     929     930

931     932     933     934     935     936     937     938     939     940     941     942     943     944     945

946     947     948     949     950     951     952     953     954     955     956     957     958     959     960

961     962     963     964     965     966     967     968     969     970     971     972     973     974     975

976     977     978     979     980     981     982     983     984     985     986     987     988     989     990

991     992     993     994     995     996     997     998     999

Test for 3 begins(方法二):

        1       2       3       4       5       6       7       8       9       10      11      12      13      14

15      16      17      18      19      20      21      22      23      24      25      26      27      28      29

30      31      32      33      34      35      36      37      38      39      40      41      42      43      44

45      46      47      48      49      50      51      52      53      54      55      56      57      58      59

60      61      62      63      64      65      66      67      68      69      70      71      72      73      74

75      76      77      78      79      80      81      82      83      84      85      86      87      88      89

90      91      92      93      94      95      96      97      98      99      100     101     102     103     104

105     106     107     108     109     110     111     112     113     114     115     116     117     118     119

120     121     122     123     124     125     126     127     128     129     130     131     132     133     134

135     136     137     138     139     140     141     142     143     144     145     146     147     148     149

150     151     152     153     154     155     156     157     158     159     160     161     162     163     164

165     166     167     168     169     170     171     172     173     174     175     176     177     178     179

180     181     182     183     184     185     186     187     188     189     190     191     192     193     194

195     196     197     198     199     200     201     202     203     204     205     206     207     208     209

210     211     212     213     214     215     216     217     218     219     220     221     222     223     224

225     226     227     228     229     230     231     232     233     234     235     236     237     238     239

240     241     242     243     244     245     246     247     248     249     250     251     252     253     254

255     256     257     258     259     260     261     262     263     264     265     266     267     268     269

270     271     272     273     274     275     276     277     278     279     280     281     282     283     284

285     286     287     288     289     290     291     292     293     294     295     296     297     298     299

300     301     302     303     304     305     306     307     308     309     310     311     312     313     314

315     316     317     318     319     320     321     322     323     324     325     326     327     328     329

330     331     332     333     334     335     336     337     338     339     340     341     342     343     344

345     346     347     348     349     350     351     352     353     354     355     356     357     358     359

360     361     362     363     364     365     366     367     368     369     370     371     372     373     374

375     376     377     378     379     380     381     382     383     384     385     386     387     388     389

390     391     392     393     394     395     396     397     398     399     400     401     402     403     404

405     406     407     408     409     410     411     412     413     414     415     416     417     418     419

420     421     422     423     424     425     426     427     428     429     430     431     432     433     434

435     436     437     438     439     440     441     442     443     444     445     446     447     448     449

450     451     452     453     454     455     456     457     458     459     460     461     462     463     464

465     466     467     468     469     470     471     472     473     474     475     476     477     478     479

480     481     482     483     484     485     486     487     488     489     490     491     492     493     494

495     496     497     498     499     500     501     502     503     504     505     506     507     508     509

510     511     512     513     514     515     516     517     518     519     520     521     522     523     524

525     526     527     528     529     530     531     532     533     534     535     536     537     538     539

540     541     542     543     544     545     546     547     548     549     550     551     552     553     554

555     556     557     558     559     560     561     562     563     564     565     566     567     568     569

570     571     572     573     574     575     576     577     578     579     580     581     582     583     584

585     586     587     588     589     590     591     592     593     594     595     596     597     598     599

600     601     602     603     604     605     606     607     608     609     610     611     612     613     614

615     616     617     618     619     620     621     622     623     624     625     626     627     628     629

630     631     632     633     634     635     636     637     638     639     640     641     642     643     644

645     646     647     648     649     650     651     652     653     654     655     656     657     658     659

660     661     662     663     664     665     666     667     668     669     670     671     672     673     674

675     676     677     678     679     680     681     682     683     684     685     686     687     688     689

690     691     692     693     694     695     696     697     698     699     700     701     702     703     704

705     706     707     708     709     710     711     712     713     714     715     716     717     718     719

720     721     722     723     724     725     726     727     728     729     730     731     732     733     734

735     736     737     738     739     740     741     742     743     744     745     746     747     748     749

750     751     752     753     754     755     756     757     758     759     760     761     762     763     764

765     766     767     768     769     770     771     772     773     774     775     776     777     778     779

780     781     782     783     784     785     786     787     788     789     790     791     792     793     794

795     796     797     798     799     800     801     802     803     804     805     806     807     808     809

810     811     812     813     814     815     816     817     818     819     820     821     822     823     824

825     826     827     828     829     830     831     832     833     834     835     836     837     838     839

840     841     842     843     844     845     846     847     848     849     850     851     852     853     854

855     856     857     858     859     860     861     862     863     864     865     866     867     868     869

870     871     872     873     874     875     876     877     878     879     880     881     882     883     884

885     886     887     888     889     890     891     892     893     894     895     896     897     898     899

900     901     902     903     904     905     906     907     908     909     910     911     912     913     914

915     916     917     918     919     920     921     922     923     924     925     926     927     928     929

930     931     932     933     934     935     936     937     938     939     940     941     942     943     944

945     946     947     948     949     950     951     952     953     954     955     956     957     958     959

960     961     962     963     964     965     966     967     968     969     970     971     972     973     974

975     976     977     978     979     980     981     982     983     984     985     986     987     988     989

990     991     992     993     994     995     996     997     998     999

Test for 3 ends.

Test for 0 begins(方法一):

n必须为正整数，参数错误！

Test for 0 begins(方法二):

n必须为正整数，参数错误！

Test for 0 ends.

Test for -1 begins(方法一):

n必须为正整数，参数错误！

Test for -1 begins(方法二):

n必须为正整数，参数错误！

Test for -1 ends.

请按任意键继续. . .

 

考点：

1.考查解决大数问题的能力；

2.时间空间复杂度尽可能好；

3.能否用递归做。

 

总结：

    如果面试题是关于n位的整数并且没有限定n的取值范围，或者是输入任意大小的整数，那么这个题目很有可能是需要考虑大数问题。字符串是一个简单、有效的表示大数的方法。