四个大数相加 问题的分析(转 韩卫平的笔记 )

转至于

http://student.csdn.net/space.php?uid=39102&do=blog&id=6381&t=1305520464

前几天看到一个同学在课堂问一个大数相加的问题也给出了自己的代码，有Bug。很想帮他看一下，但代码实在是难读。所以我就写出来我对这个问题的想法。代码使用C语言写。（且不考虑越界输入错误之类的情况）代码我只做过简单的测试，如果发现错误希望能及时通知我。之前我也写过一个完整的大数运算代码有兴趣的同学可以到这里看看

说明一下，写这篇笔记目的不是为了研究算法，而是如何去写一个程序能够让他易读。

 

首先对于这个问题我采用一个结构体来保存一个大整数。

Code:

1. struct __BigNum  
2. {  
3.     unsigned char Num[MaxLen];  
4.     unsigned int len;  
5. };  
6. typedef struct __BigNum BigNum;   

 

　　其中Num用来保存每一位的数字（十进制的位)，len表示有多少位，这样使用的时候直接使用BigNum来表示一个大数。

　　结构体定义出来了，那下一步就是如何保存，考虑Num[0]是最高位还是最低位合适，假如Num[0]是高位，那么由于大数的位数不同，相加的时候会有多个变量保存不同大数对应的位，会造成一定的混乱。再考虑一下要是有进位则更麻烦，需要将数组中的数字都移动一下。如果进位处理和加法在一个循环中处理的话，就会相当的复杂，所以我采用的是Num[0]保存低位。这样循环相加的时候只需要一个变量即可，处理进位也容易。

　　数据结构已经确定了接下来就是如何实现的问题了

　　先写出来辅助函数

Code:

1. BigNum* NewBigNum()  
2. {  
3.     BigNum* p = (BigNum*)malloc( sizeof(BigNum) );  
4.     memset( p , 0 , sizeof( BigNum ) );  
5.     return p;  
6. }   

 

很简单就是分配一个BigNum的结构体。

　　在接下来是如何读取，我们用scanf读取一个字符串。观察一下字符串和我们定义的结构体。

Code:

1. char sz[2010]={0};  
2. scanf("%s",sz);  

 

　　如果我输入123那么sz存的内容就是sz[0]=/'1/'  、 sz[1]=/'2/' 、sz[2]=/'3/';那么先对每一位减去/'0/'然后反转整个字符串就跟我们定义的结构体一致了。于是我们的读取函数可以这么写

Code:

1. void reverse(unsigned char* pS , unsigned char* pE)//反转函数  
2. {  
3.     for( ; pS < pE ; pS++ ){  
4.         unsigned char temp = *pS;  
5.         --pE;  
6.         *pS = *pE;  
7.         *pE = temp;  
8.     }  
9. }  
10.   
11. BigNum* ReadBigNum()  
12. {  
13.     unsigned int i=0;  
14.     BigNum* pNum = NewBigNum();  
15.     scanf(/"%s/",pNum->Num);  
16.     pNum->len = strlen( (const char*)(pNum->Num) );  
17.     for( ; i< pNum->len ; ++i )  
18.         pNum->Num[i] -= /'0/';  
19.     reverse( pNum->Num , pNum->Num + pNum->len );  
20.     return pNum;  
21. }   

 

再接下来是输出函数

Code:

1. void print( BigNum*pNum)  
2. {  
3.     unsigned int i=0;  
4.     reverse( pNum->Num , pNum->Num + pNum->len );  
5.     for( ; i< pNum->len ; ++i )  
6.         pNum->Num[i] += /'0/';  
7.     puts( (const char*)(pNum->Num) );  
8. }  

 

　　至此输入输出的功能已经够了，接下来就是核心的加法功能了，先来完成2个数字的加法。由低到高依次循环将加法的结果放到大数对应的位。再次进行一次循环来处理进位。算法也很简单。于是就写下两个数字相加的函数

 

Code:

1. BigNum* AddBigNum( BigNum* pL , BigNum* pR )  
2. {  
3.     unsigned len = (pL->len > pR->len )?pL->len : pR->len;  
4.     unsigned i = 0;  
5.     BigNum* pRet = NewBigNum();  
6.     for( ; i < len ; i++ ){  
7.         pRet->Num[i] = pRet->Num[i] + pL->Num[i] + pR->Num[i];  
8.         if( pRet->Num[i] > 9 ){//处理进位  
9.             pRet->Num[i+1] += (pRet->Num[i]/10);  
10.             pRet->Num[i] %= 10;  
11.         }  
12.     }  
13.     pRet->len = (pRet->Num[len])? len+1 : len ;//判断最高位是不是有进位  
14.     return pRet;  
15. };   

　　这里需要注意的是我将处理进位和加法在一个循环中实现了。最后需要设置结果的长度，在不考虑进位的时候可以看出来两个大数最长的位就是结果的位数。需要在判断一下最高位的下一位（指更高位)是否为0，如果最高位进位的话那么在循环中就对这一位进行赋值了。

　　到这里核心的功能已经完成了，但还是不符合题目的要求，剩下的就由读者自行完成吧。

完整代码如下

Code:

1. #include<stdio.h>  
2. #include<stdlib.h>  
3. #include<string.h>   
4.   
5. #define MaxLen 2010  
6.   
7. struct __BigNum  
8. {  
9.     unsigned char Num[MaxLen];  
10.     unsigned int len;  
11. };  
12. typedef struct __BigNum BigNum;  
13.   
14. void reverse(unsigned char* pS , unsigned char* pE)  
15. {  
16.     for( ; pS < pE ; pS++ ){  
17.         unsigned char temp = *pS;  
18.         --pE;  
19.         *pS = *pE;  
20.         *pE = temp;  
21.     }  
22. }  
23.   
24. BigNum* NewBigNum()  
25. {  
26.     BigNum* p = (BigNum*)malloc( sizeof(BigNum) );  
27.     memset( p , 0 , sizeof( BigNum ) );  
28.     return p;  
29. }  
30.   
31. BigNum* ReadBigNum()  
32. {  
33.     unsigned int i=0;  
34.     BigNum* pNum = NewBigNum();  
35.     scanf("%s",pNum->Num);  
36.     pNum->len = strlen( (const char*)(pNum->Num) );  
37.     for( ; i< pNum->len ; ++i )  
38.         pNum->Num[i] -= '0';  
39.     reverse( pNum->Num , pNum->Num + pNum->len );  
40.     return pNum;  
41. }  
42.   
43. void print( BigNum*pNum)  
44. {  
45.     unsigned int i=0;  
46.     reverse( pNum->Num , pNum->Num + pNum->len );  
47.     for( ; i< pNum->len ; ++i )  
48.         pNum->Num[i] += '0';  
49.     puts( (const char*)(pNum->Num) );  
50. }  
51.   
52. BigNum* AddBigNum( BigNum* pL , BigNum* pR )  
53. {  
54.     unsigned len = (pL->len > pR->len )?pL->len : pR->len;  
55.     unsigned i = 0;  
56.     BigNum* pRet = NewBigNum();  
57.     for( ; i < len ; i++ ){  
58.         pRet->Num[i] = pRet->Num[i] + pL->Num[i] + pR->Num[i];  
59.         if( pRet->Num[i] > 9 ){//处理进位  
60.             pRet->Num[i+1] += (pRet->Num[i]/10);  
61.             pRet->Num[i] %= 10;  
62.         }  
63.     }  
64.     pRet->len = (pRet->Num[len])? len+1 : len ;//判断最高位是不是有进位  
65.     return pRet;  
66. };  
67.   
68. int main()  
69. {  
70.     BigNum* p1 = ReadBigNum();  
71.     BigNum* p2 = ReadBigNum();  
72.     BigNum* p5 = AddBigNum( p1 , p2 );  
73.     print( p5 );  
74.     free( p1 );  
75.     free( p2 );  
76.     free( p5 );  
77. }