[已解决]数据结构

Echo。

[问题描述]设计一个程序实现两个任意 长的整数的求和运算

[输入形式]按中国对于长整数的表示习惯，每四位一一组， 组间用逗号隔开

[输出形式]每四位一组，组间用逗号隔开

【评分标准】任何整形变量的范围是：-（215-1）~（215-1）。采用恰当的存储结构，如：利用双向循环链表实现长整数的存储，每个结点中仅存十进制数的4位，即不超过9999的非负整数，整个链表视为万位制数。可以利用头结点数据域的符号代表长整数的符号，用其绝对值表示元素结点数目。相加过程中不要破坏两个操作数链表。两操作数的头指针存于指针数组中是简化程序结构的一种方法。不能给长整数的位数规定上限。

【选作内容】修改上述程序，使它在整形量范围是-（2n-1）~（2n-1）的计算机上都能有效地运行。其中，n是由程序读入的参量。

最佳答案

月排行榜 / 总排行榜

xieglt

2020-12-7 14:44:37

后面才看到要考虑符号。又改了下，一个有符号的版本

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. #define BASE                (10000)
   
6. #define        NUM_LEN                (4)
   
7. #define        _BASE_SIZE        (1024)
   
8. #define ISINIT(p)        ((p->_data != 0) && (p->_flag == 0))
   
9. 
   
10. typedef struct tagInteger
    
11. {
    
12.         int * _data;
    
13.         int _size;
    
14.         int _len;
    
15.         int _signed;
    
16.         int _flag;
    
17. }INTEGER,*LPINTEGER;
    
18. 
    
19. int _InitInteger(LPINTEGER n,int size = 0)
    
20. {
    
21.         size = ((size == 0) ? _BASE_SIZE : size);
    
22.        
    
23.         n->_size = 0;
    
24.         n->_data = (int *)malloc(size * sizeof(int));
    
25.        
    
26.         if(n->_data == 0)
    
27.         {
    
28.                 return 0;
    
29.         }
    
30. 
    
31.         memset(n->_data,0,size * sizeof(int));
    
32.         n->_len = 0;
    
33.         n->_size = size;
    
34.         n->_flag = 0;
    
35.         return 1;
    
36. }
    
37. 
    
38. void _UninitInteger(LPINTEGER n)
    
39. {
    
40.         if(ISINIT(n))
    
41.         {
    
42.                 free(n->_data);
    
43.         }
    
44. }
    
45. 
    
46. int _ResizeInteger(LPINTEGER n,int _size = 0)
    
47. {
    
48.         int len = n->_size;
    
49.        
    
50.         if(!ISINIT(n))
    
51.         {
    
52.                 return _InitInteger(n,_size);
    
53.         }
    
54.                
    
55.         if(_size < _BASE_SIZE)
    
56.         {
    
57.                 n->_size += _BASE_SIZE;
    
58.         }
    
59.         else
    
60.         {
    
61.                 n->_size += _size;
    
62.         }
    
63.                
    
64.         n->_data = (int *)realloc(n->_data,n->_size * sizeof(int));
    
65.                
    
66.         if(n->_data == 0)
    
67.         {
    
68.                         return 0;
    
69.         }
    
70.        
    
71.         memset(n->_data + len,0,(n->_size - len) * sizeof(int));
    
72.         return 1;
    
73. }
    
74. 
    
75. int _String2Integer(LPINTEGER pNum,char * number)
    
76. {
    
77.         int i = 0;
    
78.         int nRet = 0;
    
79.         char cByte = 0;
    
80.         int value = 0;
    
81.         int power = 0;
    
82.         int index =0;
    
83.         int len = strlen(number);
    
84.         int size = len / NUM_LEN + (len % NUM_LEN == 0 ? 0 : 1);
    
85.         int flag = 0;
    
86. 
    
87.         do
    
88.         {
    
89.                 if(len == 0)
    
90.                 {
    
91.                         break;
    
92.                 }
    
93. 
    
94.                
    
95.                 if(number[0]=='-' || number[0]=='+')
    
96.                 {
    
97.                         if(number[0] == '-')
    
98.                         {
    
99.                                 flag = 1;
    
100.                         }
     
101.                        
     
102.                         number ++;
     
103.                         len --;
     
104.                 }
     
105.                
     
106.                 if(!ISINIT(pNum) && _InitInteger(pNum,size) == 0)
     
107.                 {
     
108.                         break;
     
109.                 }
     
110. 
     
111.                 if(size > pNum->_size && _ResizeInteger(pNum,size) == 0)
     
112.                 {
     
113.                         break;
     
114.                 }
     
115.                
     
116.                 for(i=0 ; i<len ; i++)
     
117.                 {
     
118.                         if(number[i]<'0' || number[i]>'9')
     
119.                         {
     
120.                                 break;
     
121.                         }
     
122.                 }
     
123.                 if(i < len--)
     
124.                 {
     
125.                         break;
     
126.                 }
     
127. 
     
128. 
     
129.                 for(i=len ; i>=0 ; i--)
     
130.                 {
     
131.                         if((len - i) % NUM_LEN == 0)
     
132.                         {
     
133.                                 if(len - i != 0)
     
134.                                 {
     
135.                                         pNum->_data[index++] = value;
     
136.                                 }
     
137. 
     
138.                                 value = 0;
     
139.                                 power = 1;
     
140.                         }
     
141.                         cByte = number[i] - 0x30;
     
142.                         value += power * cByte;
     
143.                         power *= 10;
     
144.                 }
     
145. 
     
146.                 if(value != 0)
     
147.                 {
     
148.                         pNum->_data[index++] = value;
     
149.                 }
     
150.                 pNum->_signed = flag;
     
151.                 pNum->_len = index;
     
152.                 while(pNum->_data[pNum->_len-1] == 0)
     
153.                 {
     
154.                         pNum->_len--;
     
155.                 }
     
156.                 nRet = 1;
     
157.         }while(0);
     
158. 
     
159.         return nRet;
     
160. }
     
161. 
     
162. int _Integer2String(LPINTEGER pNum,char * number)
     
163. {
     
164.         int i = 0;
     
165.         int nRet = 0;
     
166.         char buffer[16] = {0};
     
167.        
     
168.         do
     
169.         {
     
170.                 if(!ISINIT(pNum))
     
171.                 {
     
172.                         break;
     
173.                 }
     
174. 
     
175.                 if(number == 0)
     
176.                 {
     
177.                         nRet = pNum->_len * (NUM_LEN + 1) + 1;
     
178.                         break;
     
179.                 }
     
180. 
     
181.                 number[0] = 0;
     
182. 
     
183.                 if(pNum->_signed != 0)
     
184.                 {
     
185.                         strcat(number,"-");
     
186.                 }
     
187.                
     
188.                 for(i=pNum->_len-1 ; i>=0 ; i--)
     
189.                 {
     
190.                         if(i == pNum->_len-1)
     
191.                         {
     
192.                                 sprintf(buffer,"%d",pNum->_data[i]);
     
193.                         }
     
194.                         else
     
195.                         {
     
196.                                 sprintf(buffer,"%04d",pNum->_data[i]);
     
197.                         }
     
198.                         strcat(number,buffer);
     
199.                         if(i != 0)
     
200.                         {
     
201.                                 strcat(number,",");
     
202.                         }
     
203.                 }
     
204. 
     
205.                 nRet = strlen(number);
     
206.         }while(0);
     
207. 
     
208.         return nRet;
     
209. }
     
210. 
     
211. void _PushBack(LPINTEGER src,int data)
     
212. {
     
213. 
     
214.         if(src->_len == src->_size)
     
215.         {
     
216.                 if(!_ResizeInteger(src))
     
217.                 {
     
218.                         return;
     
219.                 }
     
220.         }
     
221. 
     
222.         src->_data[src->_len++] = data;
     
223. }
     
224. 
     
225. void _SimpleAdd(LPINTEGER src,LPINTEGER dst)
     
226. {
     
227.         int sizeofme = src->_len;
     
228.         int sizeofyou = dst->_len;
     
229.         int len = sizeofme >= sizeofyou ? sizeofme : sizeofyou;
     
230.         int i = 0;
     
231.         int value = 0;
     
232.         int carry = 0;
     
233. 
     
234.         for(i=0 ; i<len ; i++)
     
235.         {
     
236.                 value = carry;
     
237.                 if(i < sizeofme)
     
238.                 {
     
239.                         value += src->_data[i];
     
240.                 }
     
241. 
     
242.                 if(i < sizeofyou)
     
243.                 {
     
244.                         value += dst->_data[i];
     
245.                 }
     
246. 
     
247.                 carry = value / BASE;
     
248.                 value %= BASE;
     
249. 
     
250.                 if(i < sizeofme)
     
251.                 {
     
252.                         src->_data[i] = value;
     
253.                 }
     
254.                 else
     
255.                 {
     
256.                         _PushBack(src,value);
     
257.                 }
     
258.         }
     
259. 
     
260.         if(carry != 0)
     
261.         {
     
262.                 if(i < sizeofme)
     
263.                 {
     
264.                         src->_data[i] = carry;
     
265.                 }
     
266.                 else
     
267.                 {
     
268.                         _PushBack(src,carry);
     
269.                 }
     
270.         }
     
271. };
     
272. 
     
273. void _SimpleSub(LPINTEGER src,LPINTEGER dst)
     
274. {
     
275.         int sizeofme = src->_len;
     
276.         int sizeofyou = dst->_len;
     
277.         int i = 0;
     
278.         int value = 0;
     
279.         int carry = 0;
     
280.        
     
281.         for(i=0 ; i<sizeofme ; i++)
     
282.         {
     
283.                 value = src->_data[i];
     
284. 
     
285.                 if(i < sizeofyou)
     
286.                 {
     
287.                         value -= dst->_data[i];
     
288.                 }
     
289.                
     
290.                 value -= carry;
     
291.                
     
292.                 if(value < 0)
     
293.                 {
     
294.                         value += BASE;
     
295.                         carry = 1;
     
296.                 }
     
297.                 else
     
298.                 {
     
299.                         carry = 0;
     
300.                 }
     
301.                 src->_data[i] = value;
     
302.         }
     
303. 
     
304.         while(src->_data[src->_len-1] == 0)
     
305.         {
     
306.                 src->_len--;
     
307.         }
     
308. }
     
309. 
     
310. int _UnsignedCompare(LPINTEGER src,LPINTEGER dst)
     
311. {
     
312.         int i = 0;
     
313. 
     
314.         if(src->_len > dst->_len)
     
315.         {
     
316.                 return 1;
     
317.         }
     
318.         else if(src->_len < dst->_len)
     
319.         {
     
320.                 return -1;
     
321.         }
     
322.        
     
323.         for(i=src->_len-1 ; i>=0 ; i--)
     
324.         {
     
325.                 if(src->_data[i] > dst->_data[i])
     
326.                 {
     
327.                         return 1;
     
328.                 }
     
329.                 else if(src->_data[i] < dst->_data[i])
     
330.                 {
     
331.                         return -1;
     
332.                 }
     
333.         }
     
334. 
     
335.         return 0;
     
336. }
     
337. 
     
338. void _CopyInteger(LPINTEGER dst,LPINTEGER src)
     
339. {
     
340.         if(!ISINIT(dst))
     
341.         {
     
342.                 if(!_InitInteger(dst,src->_size))
     
343.                 {
     
344.                         return;
     
345.                 }
     
346.         }
     
347.         else if(dst->_size < src->_size)
     
348.         {
     
349.                 if(!_ResizeInteger(dst,src->_size))
     
350.                 {
     
351.                         return;
     
352.                 }
     
353.         }
     
354. 
     
355.         memcpy(dst->_data,src->_data,src->_size);
     
356.         dst->_len = src->_len;
     
357.         dst->_signed = src->_signed;
     
358. }
     
359. 
     
360. void _UnsignedSub(LPINTEGER src,LPINTEGER dst)
     
361. {
     
362.         INTEGER n;
     
363.         int _signed = src->_signed;
     
364. 
     
365.         if(_UnsignedCompare(src,dst) == -1)
     
366.         {
     
367. 
     
368.                 _CopyInteger(&n,dst);
     
369.                 _SimpleSub(&n,src);
     
370.                 _CopyInteger(src,&n);
     
371.                 _UninitInteger(&n);
     
372.                 src->_signed = !_signed;
     
373.         }
     
374.         else
     
375.         {
     
376.                 _SimpleSub(src,dst);
     
377.         }
     
378. }
     
379. 
     
380. void _AddInteger(LPINTEGER src,LPINTEGER dst)
     
381. {
     
382.         int _signed = src->_signed - dst->_signed;
     
383.         if(_signed == 0)
     
384.         {
     
385.                 _SimpleAdd(src,dst);
     
386.         }
     
387.         else
     
388.         {
     
389.                 _UnsignedSub(src,dst);
     
390.         }
     
391. }
     
392. 
     
393. void _SubInteger(LPINTEGER src,LPINTEGER dst)
     
394. {
     
395.         int _signed = src->_signed - dst->_signed;
     
396.         if(_signed != 0)
     
397.         {
     
398.                 _SimpleAdd(src,dst);
     
399.         }
     
400.         else
     
401.         {
     
402.                 _UnsignedSub(src,dst);
     
403.         }
     
404. }
     
405. 
     
406. int main(int argc, char* argv[])
     
407. {
     
408.         INTEGER n,m;
     
409.         char buffer[128];
     
410.         _InitInteger(&n);
     
411.         _InitInteger(&m);
     
412.         _String2Integer(&n,"-1234567890987654321012345678909876543210123");
     
413.         _String2Integer(&m,"99998888777776666655555444433332222111100001234567890");
     
414.        
     
415.         _AddInteger(&n,&m);
     
416.         _Integer2String(&n,buffer);
     
417.         _UninitInteger(&n);
     
418.         _UninitInteger(&m);
     
419.         printf("%s",buffer);
     
420.         return 0;
     
421. }
     
422. 
     

复制代码

跳转到最佳答案楼层

xieglt

用的数组实现

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. #define BASE                (10000)
   
6. #define        NUM_LEN                (4)
   
7. #define        _BASE_SIZE        (1024)
   
8. #define ISINIT(p)        ((p->_data != 0) && (p->_flag == 0))
   
9. 
   
10. typedef struct tagInteger
    
11. {
    
12.         int * _data;
    
13.         int _size;
    
14.         int _len;
    
15.         int _flag;
    
16. }INTEGER,*LPINTEGER;
    
17. 
    
18. int _InitInteger(LPINTEGER n,int size = 0)
    
19. {
    
20.         size = ((size == 0) ? _BASE_SIZE : size);
    
21.        
    
22.         n->_size = 0;
    
23.         n->_data = (int *)malloc(size * sizeof(int));
    
24.        
    
25.         if(n->_data == 0)
    
26.         {
    
27.                 return 0;
    
28.         }
    
29. 
    
30.         memset(n->_data,0,size * sizeof(int));
    
31.         n->_len = 0;
    
32.         n->_size = size;
    
33.         n->_flag = 0;
    
34.         return 1;
    
35. }
    
36. 
    
37. void _UninitInteger(LPINTEGER n)
    
38. {
    
39.         if(ISINIT(n))
    
40.         {
    
41.                 free(n->_data);
    
42.         }
    
43. }
    
44. 
    
45. int _ResizeInteger(LPINTEGER n,int _size = 0)
    
46. {
    
47.         int len = n->_size;
    
48.        
    
49.         if(!ISINIT(n))
    
50.         {
    
51.                 return _InitInteger(n,_size);
    
52.         }
    
53.                
    
54.         if(_size < _BASE_SIZE)
    
55.         {
    
56.                 n->_size += _BASE_SIZE;
    
57.         }
    
58.         else
    
59.         {
    
60.                 n->_size += _size;
    
61.         }
    
62.                
    
63.         n->_data = (int *)realloc(n->_data,n->_size * sizeof(int));
    
64.                
    
65.         if(n->_data == 0)
    
66.         {
    
67.                         return 0;
    
68.         }
    
69.        
    
70.         memset(n->_data + len,0,(n->_size - len) * sizeof(int));
    
71.         return 1;
    
72. }
    
73. 
    
74. int _String2Integer(LPINTEGER pNum,char * number)
    
75. {
    
76.         int i = 0;
    
77.         int nRet = 0;
    
78.         char cByte = 0;
    
79.         int value = 0;
    
80.         int power = 0;
    
81.         int index =0;
    
82.         int nLen = strlen(number);
    
83.         int size = nLen / NUM_LEN + (nLen % NUM_LEN == 0 ? 0 : 1);
    
84. 
    
85.         do
    
86.         {
    
87.                 if(nLen == 0)
    
88.                 {
    
89.                         break;
    
90.                 }
    
91.                
    
92.                 if(!ISINIT(pNum) && _InitInteger(pNum,size) == 0)
    
93.                 {
    
94.                         break;
    
95.                 }
    
96. 
    
97.                 if(size > pNum->_size && _ResizeInteger(pNum,size) == 0)
    
98.                 {
    
99.                         break;
    
100.                 }
     
101.                
     
102.                 for(i=0 ; i<nLen ; i++)
     
103.                 {
     
104.                         if(number[i]<'0' || number[i]>'9')
     
105.                         {
     
106.                                 break;
     
107.                         }
     
108.                 }
     
109.                 if(i < nLen--)
     
110.                 {
     
111.                         break;
     
112.                 }
     
113. 
     
114. 
     
115.                 for(i=nLen ; i>=0 ; i--)
     
116.                 {
     
117.                         if((nLen - i) % NUM_LEN == 0)
     
118.                         {
     
119.                                 if(nLen - i != 0)
     
120.                                 {
     
121.                                         pNum->_data[index++] = value;
     
122.                                 }
     
123. 
     
124.                                 value = 0;
     
125.                                 power = 1;
     
126.                         }
     
127.                         cByte = number[i] - 0x30;
     
128.                         value += power * cByte;
     
129.                         power *= 10;
     
130.                 }
     
131. 
     
132.                 if(value != 0)
     
133.                 {
     
134.                         pNum->_data[index++] = value;
     
135.                 }
     
136. 
     
137.                 pNum->_len = index;               
     
138.                 nRet = 1;
     
139.         }while(0);
     
140. 
     
141.         return nRet;
     
142. }
     
143. 
     
144. int _Integer2String(LPINTEGER pNum,char * number)
     
145. {
     
146.         int i = 0;
     
147.         int nRet = 0;
     
148.         char buffer[16] = {0};
     
149.        
     
150.         do
     
151.         {
     
152.                 if(!ISINIT(pNum))
     
153.                 {
     
154.                         break;
     
155.                 }
     
156. 
     
157.                 if(number == 0)
     
158.                 {
     
159.                         nRet = pNum->_len * NUM_LEN + 1;
     
160.                         break;
     
161.                 }
     
162. 
     
163.                 number[0] = 0;
     
164.                
     
165.                 for(i=pNum->_len-1 ; i>=0 ; i--)
     
166.                 {
     
167.                         if(i == pNum->_len-1)
     
168.                         {
     
169.                                 sprintf(buffer,"%d",pNum->_data[i]);
     
170.                         }
     
171.                         else
     
172.                         {
     
173.                                 sprintf(buffer,"%04d",pNum->_data[i]);
     
174.                         }
     
175.                         strcat(number,buffer);
     
176.                         if(i != 0)
     
177.                         {
     
178.                                 strcat(number,",");
     
179.                         }
     
180.                 }
     
181. 
     
182.                 nRet = strlen(number);
     
183.         }while(0);
     
184. 
     
185.         return nRet;
     
186. }
     
187. 
     
188. void _PushBack(LPINTEGER src,int data)
     
189. {
     
190. 
     
191.         if(src->_len == src->_size)
     
192.         {
     
193.                 if(!_ResizeInteger(src))
     
194.                 {
     
195.                         return;
     
196.                 }
     
197.         }
     
198. 
     
199.         src->_data[src->_len++] = data;
     
200. }
     
201. 
     
202. void _IntegerAdd(LPINTEGER src,LPINTEGER dst)
     
203. {
     
204.         int sizeofme = src->_len;
     
205.         int sizeofyou = dst->_len;
     
206.         int len = sizeofme >= sizeofyou ? sizeofme : sizeofyou;
     
207.         int i = 0;
     
208.         int value = 0;
     
209.         int carry = 0;
     
210. 
     
211.         for(i=0 ; i<len ; i++)
     
212.         {
     
213.                 value = carry;
     
214.                 if(i < sizeofme)
     
215.                 {
     
216.                         value += src->_data[i];
     
217.                 }
     
218. 
     
219.                 if(i < sizeofyou)
     
220.                 {
     
221.                         value += dst->_data[i];
     
222.                 }
     
223. 
     
224.                 carry = value / BASE;
     
225.                 value %= BASE;
     
226. 
     
227.                 if(i < sizeofme)
     
228.                 {
     
229.                         src->_data[i] = value;
     
230.                 }
     
231.                 else
     
232.                 {
     
233.                         _PushBack(src,value);
     
234.                 }
     
235.         }
     
236. 
     
237.         if(carry != 0)
     
238.         {
     
239.                 if(i < sizeofme)
     
240.                 {
     
241.                         src->_data[i] = carry;
     
242.                 }
     
243.                 else
     
244.                 {
     
245.                         _PushBack(src,carry);
     
246.                 }
     
247.         }
     
248. 
     
249. };
     
250. 
     
251. 
     
252. int main(int argc, char* argv[])
     
253. {
     
254.         INTEGER n,m;
     
255.         char buffer[128];
     
256.         _InitInteger(&n);
     
257.         _InitInteger(&m);
     
258.         _String2Integer(&n,"1234567890987654321012345678909876543210123");
     
259.         _String2Integer(&m,"9999888877777666665555544443333222211110000");
     
260.         _IntegerAdd(&n,&m);
     
261.         _Integer2String(&n,buffer);
     
262.         _UninitInteger(&n);
     
263.         _UninitInteger(&m);
     
264.         printf("%s",buffer);
     
265.         return 0;
     
266. }
     
267. 
     

复制代码

xieglt

后面才看到要考虑符号。又改了下，一个有符号的版本

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. #define BASE                (10000)
   
6. #define        NUM_LEN                (4)
   
7. #define        _BASE_SIZE        (1024)
   
8. #define ISINIT(p)        ((p->_data != 0) && (p->_flag == 0))
   
9. 
   
10. typedef struct tagInteger
    
11. {
    
12.         int * _data;
    
13.         int _size;
    
14.         int _len;
    
15.         int _signed;
    
16.         int _flag;
    
17. }INTEGER,*LPINTEGER;
    
18. 
    
19. int _InitInteger(LPINTEGER n,int size = 0)
    
20. {
    
21.         size = ((size == 0) ? _BASE_SIZE : size);
    
22.        
    
23.         n->_size = 0;
    
24.         n->_data = (int *)malloc(size * sizeof(int));
    
25.        
    
26.         if(n->_data == 0)
    
27.         {
    
28.                 return 0;
    
29.         }
    
30. 
    
31.         memset(n->_data,0,size * sizeof(int));
    
32.         n->_len = 0;
    
33.         n->_size = size;
    
34.         n->_flag = 0;
    
35.         return 1;
    
36. }
    
37. 
    
38. void _UninitInteger(LPINTEGER n)
    
39. {
    
40.         if(ISINIT(n))
    
41.         {
    
42.                 free(n->_data);
    
43.         }
    
44. }
    
45. 
    
46. int _ResizeInteger(LPINTEGER n,int _size = 0)
    
47. {
    
48.         int len = n->_size;
    
49.        
    
50.         if(!ISINIT(n))
    
51.         {
    
52.                 return _InitInteger(n,_size);
    
53.         }
    
54.                
    
55.         if(_size < _BASE_SIZE)
    
56.         {
    
57.                 n->_size += _BASE_SIZE;
    
58.         }
    
59.         else
    
60.         {
    
61.                 n->_size += _size;
    
62.         }
    
63.                
    
64.         n->_data = (int *)realloc(n->_data,n->_size * sizeof(int));
    
65.                
    
66.         if(n->_data == 0)
    
67.         {
    
68.                         return 0;
    
69.         }
    
70.        
    
71.         memset(n->_data + len,0,(n->_size - len) * sizeof(int));
    
72.         return 1;
    
73. }
    
74. 
    
75. int _String2Integer(LPINTEGER pNum,char * number)
    
76. {
    
77.         int i = 0;
    
78.         int nRet = 0;
    
79.         char cByte = 0;
    
80.         int value = 0;
    
81.         int power = 0;
    
82.         int index =0;
    
83.         int len = strlen(number);
    
84.         int size = len / NUM_LEN + (len % NUM_LEN == 0 ? 0 : 1);
    
85.         int flag = 0;
    
86. 
    
87.         do
    
88.         {
    
89.                 if(len == 0)
    
90.                 {
    
91.                         break;
    
92.                 }
    
93. 
    
94.                
    
95.                 if(number[0]=='-' || number[0]=='+')
    
96.                 {
    
97.                         if(number[0] == '-')
    
98.                         {
    
99.                                 flag = 1;
    
100.                         }
     
101.                        
     
102.                         number ++;
     
103.                         len --;
     
104.                 }
     
105.                
     
106.                 if(!ISINIT(pNum) && _InitInteger(pNum,size) == 0)
     
107.                 {
     
108.                         break;
     
109.                 }
     
110. 
     
111.                 if(size > pNum->_size && _ResizeInteger(pNum,size) == 0)
     
112.                 {
     
113.                         break;
     
114.                 }
     
115.                
     
116.                 for(i=0 ; i<len ; i++)
     
117.                 {
     
118.                         if(number[i]<'0' || number[i]>'9')
     
119.                         {
     
120.                                 break;
     
121.                         }
     
122.                 }
     
123.                 if(i < len--)
     
124.                 {
     
125.                         break;
     
126.                 }
     
127. 
     
128. 
     
129.                 for(i=len ; i>=0 ; i--)
     
130.                 {
     
131.                         if((len - i) % NUM_LEN == 0)
     
132.                         {
     
133.                                 if(len - i != 0)
     
134.                                 {
     
135.                                         pNum->_data[index++] = value;
     
136.                                 }
     
137. 
     
138.                                 value = 0;
     
139.                                 power = 1;
     
140.                         }
     
141.                         cByte = number[i] - 0x30;
     
142.                         value += power * cByte;
     
143.                         power *= 10;
     
144.                 }
     
145. 
     
146.                 if(value != 0)
     
147.                 {
     
148.                         pNum->_data[index++] = value;
     
149.                 }
     
150.                 pNum->_signed = flag;
     
151.                 pNum->_len = index;
     
152.                 while(pNum->_data[pNum->_len-1] == 0)
     
153.                 {
     
154.                         pNum->_len--;
     
155.                 }
     
156.                 nRet = 1;
     
157.         }while(0);
     
158. 
     
159.         return nRet;
     
160. }
     
161. 
     
162. int _Integer2String(LPINTEGER pNum,char * number)
     
163. {
     
164.         int i = 0;
     
165.         int nRet = 0;
     
166.         char buffer[16] = {0};
     
167.        
     
168.         do
     
169.         {
     
170.                 if(!ISINIT(pNum))
     
171.                 {
     
172.                         break;
     
173.                 }
     
174. 
     
175.                 if(number == 0)
     
176.                 {
     
177.                         nRet = pNum->_len * (NUM_LEN + 1) + 1;
     
178.                         break;
     
179.                 }
     
180. 
     
181.                 number[0] = 0;
     
182. 
     
183.                 if(pNum->_signed != 0)
     
184.                 {
     
185.                         strcat(number,"-");
     
186.                 }
     
187.                
     
188.                 for(i=pNum->_len-1 ; i>=0 ; i--)
     
189.                 {
     
190.                         if(i == pNum->_len-1)
     
191.                         {
     
192.                                 sprintf(buffer,"%d",pNum->_data[i]);
     
193.                         }
     
194.                         else
     
195.                         {
     
196.                                 sprintf(buffer,"%04d",pNum->_data[i]);
     
197.                         }
     
198.                         strcat(number,buffer);
     
199.                         if(i != 0)
     
200.                         {
     
201.                                 strcat(number,",");
     
202.                         }
     
203.                 }
     
204. 
     
205.                 nRet = strlen(number);
     
206.         }while(0);
     
207. 
     
208.         return nRet;
     
209. }
     
210. 
     
211. void _PushBack(LPINTEGER src,int data)
     
212. {
     
213. 
     
214.         if(src->_len == src->_size)
     
215.         {
     
216.                 if(!_ResizeInteger(src))
     
217.                 {
     
218.                         return;
     
219.                 }
     
220.         }
     
221. 
     
222.         src->_data[src->_len++] = data;
     
223. }
     
224. 
     
225. void _SimpleAdd(LPINTEGER src,LPINTEGER dst)
     
226. {
     
227.         int sizeofme = src->_len;
     
228.         int sizeofyou = dst->_len;
     
229.         int len = sizeofme >= sizeofyou ? sizeofme : sizeofyou;
     
230.         int i = 0;
     
231.         int value = 0;
     
232.         int carry = 0;
     
233. 
     
234.         for(i=0 ; i<len ; i++)
     
235.         {
     
236.                 value = carry;
     
237.                 if(i < sizeofme)
     
238.                 {
     
239.                         value += src->_data[i];
     
240.                 }
     
241. 
     
242.                 if(i < sizeofyou)
     
243.                 {
     
244.                         value += dst->_data[i];
     
245.                 }
     
246. 
     
247.                 carry = value / BASE;
     
248.                 value %= BASE;
     
249. 
     
250.                 if(i < sizeofme)
     
251.                 {
     
252.                         src->_data[i] = value;
     
253.                 }
     
254.                 else
     
255.                 {
     
256.                         _PushBack(src,value);
     
257.                 }
     
258.         }
     
259. 
     
260.         if(carry != 0)
     
261.         {
     
262.                 if(i < sizeofme)
     
263.                 {
     
264.                         src->_data[i] = carry;
     
265.                 }
     
266.                 else
     
267.                 {
     
268.                         _PushBack(src,carry);
     
269.                 }
     
270.         }
     
271. };
     
272. 
     
273. void _SimpleSub(LPINTEGER src,LPINTEGER dst)
     
274. {
     
275.         int sizeofme = src->_len;
     
276.         int sizeofyou = dst->_len;
     
277.         int i = 0;
     
278.         int value = 0;
     
279.         int carry = 0;
     
280.        
     
281.         for(i=0 ; i<sizeofme ; i++)
     
282.         {
     
283.                 value = src->_data[i];
     
284. 
     
285.                 if(i < sizeofyou)
     
286.                 {
     
287.                         value -= dst->_data[i];
     
288.                 }
     
289.                
     
290.                 value -= carry;
     
291.                
     
292.                 if(value < 0)
     
293.                 {
     
294.                         value += BASE;
     
295.                         carry = 1;
     
296.                 }
     
297.                 else
     
298.                 {
     
299.                         carry = 0;
     
300.                 }
     
301.                 src->_data[i] = value;
     
302.         }
     
303. 
     
304.         while(src->_data[src->_len-1] == 0)
     
305.         {
     
306.                 src->_len--;
     
307.         }
     
308. }
     
309. 
     
310. int _UnsignedCompare(LPINTEGER src,LPINTEGER dst)
     
311. {
     
312.         int i = 0;
     
313. 
     
314.         if(src->_len > dst->_len)
     
315.         {
     
316.                 return 1;
     
317.         }
     
318.         else if(src->_len < dst->_len)
     
319.         {
     
320.                 return -1;
     
321.         }
     
322.        
     
323.         for(i=src->_len-1 ; i>=0 ; i--)
     
324.         {
     
325.                 if(src->_data[i] > dst->_data[i])
     
326.                 {
     
327.                         return 1;
     
328.                 }
     
329.                 else if(src->_data[i] < dst->_data[i])
     
330.                 {
     
331.                         return -1;
     
332.                 }
     
333.         }
     
334. 
     
335.         return 0;
     
336. }
     
337. 
     
338. void _CopyInteger(LPINTEGER dst,LPINTEGER src)
     
339. {
     
340.         if(!ISINIT(dst))
     
341.         {
     
342.                 if(!_InitInteger(dst,src->_size))
     
343.                 {
     
344.                         return;
     
345.                 }
     
346.         }
     
347.         else if(dst->_size < src->_size)
     
348.         {
     
349.                 if(!_ResizeInteger(dst,src->_size))
     
350.                 {
     
351.                         return;
     
352.                 }
     
353.         }
     
354. 
     
355.         memcpy(dst->_data,src->_data,src->_size);
     
356.         dst->_len = src->_len;
     
357.         dst->_signed = src->_signed;
     
358. }
     
359. 
     
360. void _UnsignedSub(LPINTEGER src,LPINTEGER dst)
     
361. {
     
362.         INTEGER n;
     
363.         int _signed = src->_signed;
     
364. 
     
365.         if(_UnsignedCompare(src,dst) == -1)
     
366.         {
     
367. 
     
368.                 _CopyInteger(&n,dst);
     
369.                 _SimpleSub(&n,src);
     
370.                 _CopyInteger(src,&n);
     
371.                 _UninitInteger(&n);
     
372.                 src->_signed = !_signed;
     
373.         }
     
374.         else
     
375.         {
     
376.                 _SimpleSub(src,dst);
     
377.         }
     
378. }
     
379. 
     
380. void _AddInteger(LPINTEGER src,LPINTEGER dst)
     
381. {
     
382.         int _signed = src->_signed - dst->_signed;
     
383.         if(_signed == 0)
     
384.         {
     
385.                 _SimpleAdd(src,dst);
     
386.         }
     
387.         else
     
388.         {
     
389.                 _UnsignedSub(src,dst);
     
390.         }
     
391. }
     
392. 
     
393. void _SubInteger(LPINTEGER src,LPINTEGER dst)
     
394. {
     
395.         int _signed = src->_signed - dst->_signed;
     
396.         if(_signed != 0)
     
397.         {
     
398.                 _SimpleAdd(src,dst);
     
399.         }
     
400.         else
     
401.         {
     
402.                 _UnsignedSub(src,dst);
     
403.         }
     
404. }
     
405. 
     
406. int main(int argc, char* argv[])
     
407. {
     
408.         INTEGER n,m;
     
409.         char buffer[128];
     
410.         _InitInteger(&n);
     
411.         _InitInteger(&m);
     
412.         _String2Integer(&n,"-1234567890987654321012345678909876543210123");
     
413.         _String2Integer(&m,"99998888777776666655555444433332222111100001234567890");
     
414.        
     
415.         _AddInteger(&n,&m);
     
416.         _Integer2String(&n,buffer);
     
417.         _UninitInteger(&n);
     
418.         _UninitInteger(&m);
     
419.         printf("%s",buffer);
     
420.         return 0;
     
421. }
     
422. 
     

复制代码