打印从１到最大的n位数（考虑大数问题）

主要考虑大数问题。n一大很容易超过正数能表示的范围，因此需要用字符数组模拟。

先增加1，再打印。如下

[objc] view plain copy print ?

1. <span style="font-size: 18px;">#include <stdio.h>  
2. #include <stdlib.h>  
3.   
4. //溢出返回1，否则0  
5. int add(char* number)  
6. {  
7.     int overflow = 0,i,current_value;  
8.     int nLength = strlen(number),jinwei = 0;  
9.    
10.     for(i = nLength - 1; i >= 0; i --){  
11.         current_value = number[i] - '0' + jinwei;  //每一位加上进位  
12.         if(i == nLength - 1)  //最低位还要加上1  
13.             current_value ++;  
14.    
15.         if(current_value >= 10){  //其实是在等于10的时候，需要进位  
16.             if(i == 0)  
17.                 overflow = 1;  //最高位需要进位时说明已经到了最大值  
18.             else{  
19.                 current_value -= 10;  //不是最高位就要进位操作，首先将当前位减去10，然后设置进位标志待下一次使用  
20.                 jinwei = 1;  
21.                 number[i] = '0' + current_value;  
22.             }  
23.         }  
24.         else{  //不需要进位就把current_value赋值给number位就行  
25.             number[i] = '0' + current_value;  
26.             break;  
27.         }  
28.     }  
29.    
30.     return overflow;  
31. }  
32.   
33.   
34. //打印出这个数字，并忽略开头的0  
35. void print_a_number(char* number)  
36. {  
37.     int begin = 0,i;  
38.    
39.     for(i = 0; i < strlen(number); ++ i){  
40.         if(!begin && number[i] != '0')  
41.             begin = 1;  
42.    
43.         if(begin)  
44.             printf("%c", number[i]);  
45.     }  
46.    
47.     printf("\t");  
48. }  
49.   
50. void print_all(int n)  
51. {   
52.     charchar *number = (char*)malloc((n+1) * sizeof(char));  //最后一位要放 \0  
53.     if(n <= 0)   return;  
54.     memset(number, '0', n);  
55.     number[n] = '\0';  
56.    
57.     while(!add(number)){  
58.         print_a_number(number);  
59.     }  
60.    
61.     free(number);  
62. }  
63.   
64.   
65. void main()  
66. {  
67.     print_all(2);  
68.     getch();  
69. }</span>  

<span style="font-size: 18px;">#include <stdio.h>
#include <stdlib.h>

//溢出返回1，否则0
int add(char* number)
{
    int overflow = 0,i,current_value;
    int nLength = strlen(number),jinwei = 0;
 
    for(i = nLength - 1; i >= 0; i --){
        current_value = number[i] - '0' + jinwei;  //每一位加上进位
        if(i == nLength - 1)  //最低位还要加上1
            current_value ++;
 
        if(current_value >= 10){  //其实是在等于10的时候，需要进位
            if(i == 0)
                overflow = 1;  //最高位需要进位时说明已经到了最大值
            else{
                current_value -= 10;  //不是最高位就要进位操作，首先将当前位减去10，然后设置进位标志待下一次使用
                jinwei = 1;
                number[i] = '0' + current_value;
            }
        }
        else{  //不需要进位就把current_value赋值给number位就行
            number[i] = '0' + current_value;
            break;
        }
    }
 
    return overflow;
}


//打印出这个数字，并忽略开头的0
void print_a_number(char* number)
{
    int begin = 0,i;
 
    for(i = 0; i < strlen(number); ++ i){
        if(!begin && number[i] != '0')
            begin = 1;
 
        if(begin)
            printf("%c", number[i]);
    }
 
    printf("\t");
}

void print_all(int n)
{ 
    char *number = (char*)malloc((n+1) * sizeof(char));  //最后一位要放 \0
    if(n <= 0)	return;
    memset(number, '0', n);
    number[n] = '\0';
 
    while(!add(number)){
        print_a_number(number);
    }
 
    free(number);
}


void main()
{
    print_all(2);
    getch();
}</span>

参考剑指offer