数据结构课程设计长的整数加法

1、哈本淇打工上尊数据结构课程设计题目名称：长的整数加法计算机科学与技术学院一、 需 求分析1. 问题描述：设计一个程序实现两个任意长的整数的求和运算。2. 基本要求：利用双向循环链表，设计一个实现任意长的整数进行加法运算的演示程序。要求输入和输出每四位一组，组间用逗号隔开。如： 1， 0000， 0000， 0000， 0000。3. 任务陈述：(a) 输入的形式和输入值的范围：本实验中演示中，长整数的每位上的数字必须为数字0 9 之间， 长整数的位数要求无限长。测试的时候输入数据，当输入回车键的时候结束输入，如果输入的字符不符合题目要求，则程序能过滤这些不符合要求的字符。(b) 输出的形式:

2、整数的范围无限制，可为正数，可为负数。按照中国对于长整数的表示习惯，每四位是一组，组间用逗号隔开。(c) 程序所能达到的功能: 演示程序以用户和计算机的对话方式执行，即在计算机显示 “提示信息”后之后， 由用户在键盘上输入演示程序中规定的运算命令；相应的输入数据和运算结果显示在其后，并对错误。(d)测试数据：一为正确输入数据，为错误输入数据(超出4位)， 为错误输入数据(不足 4位 )。两长整数a=b=0请按照如下形式输入第一个长整数，每四位一组: -1234,1234,1234 按该模式输入0 输入长整数a您的输入结果为:0 显示 a( 防止错误输入)请按照如下形式输入第一个长整数，每四位一

3、组: -1234,1234,1234 输入长整数b您的运算结果为:0 输出b>a>0: -1234,1234,1234请按照如下形式输入第一个长整数，每四位一组1,1111,1111,1111您的输入结果为: 1,1111,1111,1111请按照如下形式输入第二个长整数，每四位一组: -1234,1234,12349,9999,9999,9999您的输入结果为: 9,9999,9999,9999您的运算结果为:11,1111,1111,1110a>b>0: -1234,1234,1234请按照如下形式输入第一个长整数，每四位一组9999,9999,9999您的输入结果

4、为:9999,9999,9999: -1234,1234,1234请按照如下形式输入第二个长整数，每四位一组您的输入结果为:您的运算结果为:1,0000,0000,0001 b<a<0请按照如下形式输入第一个长整数，每四位一组-2345,6789您的输入结果为:-2345,6789请按照如下形式输入第二个长整数，每四位一组-7654,3211您的输入结果为:-7654,3211您的运算结果为: 1,0000,0000 a<0,b>0,|a|>|b|请按照如下形式输入第一个长整数，每四位一组-1,0000,00001您的输入结果为:-1,0000,0001请按照如下

5、形式输入第二个长整数，每四位一组2您的输入结果为:2您的运算结果为:-9999,9999 a<0,b>0,|a|<|b|请按照如下形式输入第一个长整数，每四位一组: -1234,1234,1234: -1234,1234,1234: -1234,1234,1234: -1234,1234,1234: -1234,1234,1234-9999您的输入结果为:-9999请按照如下形式输入第二个长整数，每四位一组1,0000您的输入结果为:1,0000您的运算结果为:1 a>0,b<0,|a|>|b|请按照如下形式输入第二个长整数，每四位一组1,0000,0000

6、您的输入结果为:1,0000,0000请按照如下形式输入第二个长整数，每四位一组-9999您的输入结果为:-9999您的运算结果为:9999,0001 a>0,b<0,|a|<|b|请按照如下形式输入第一个长整数，每四位一组1您的输入结果为: -1234,1234,1234: -1234,1234,1234: -1234,1234,1234: -1234,1234,12341请按照如下形式输入第二个长整数，每四位一组: -1234,1234,1234-1,0000,0000您的输入结果为:-1,0000,0000您的运算结果为:-9999,9999错误输入（例：输入超过四位，

7、则自动取其前四位进行运算）请按照如下形式输入第一个长整数，每四位一组: -1234,1234,12341,00000您的输入结果为:1,0000请按照如下形式输入第二个长整数，每四位一组: -1234,1234,1234-99998,01234您的输入结果为:-9999,1234您的运算结果为:-9998,1234错误输入（例： 非第一次输入少于四位，则在输入前加0 补足四位进行运算）请按照如下形式输入第一个长整数，每四位一组: -1234,1234,12341,000您的输入结果为:1,0000请按照如下形式输入第二个长整数，每四位一组: -1234,1234,1234-1,11您的输入结果

8、为:-1,0011您的运算结果为:-11二、概要设计1. 目标需求与设计思想通过尾插输入长整数，为实现顺序存入，并用头插存储的运算后的长整数，因为运算必定从后向前计算，同样为了实现顺序存入。因为任意的长整数可能为负数，则第一步需判断其符号。先判断长整数a，b 的符号的异同，相同，则将a 的符号存入新的双向链表c 的符号位；相异，则将b的符号存入c,之后再处理。根据 c 的符号位，使用加法或减法的函数，需要考虑进位借位，从后开始进行运算。通过删除函数，删除因借位而出现的多余的0。最后打印运算后的c。2 数据结构此实验采用的数据结构是双向循环链表。这样可以很容易的找到他的前驱以及它的后继，并使用它

9、们存储。这是其结构体声明：typedef struct DualNodeint data;struct DualNode *prior, *next;DualNode, *DualList;2. 程序构成1) DualList InputData()操作结果：初始化一双向循环链表，完成输入操作，并将该链表返回。2) DualList AddList(DualList a, DualList b)操作结果：判断其符号3) DualList InitList(int sign)操作结果：初始化一双向循环链表，存储符号位，并将该链表返回4) void InsertNodeAtTail(DualLis

10、t L, int data)操作结果：尾插，用于存储数据的存入。5) void InsertNodeAtHead(DualList L, int data)操作结果：插在头结点之后，用于计算结果的存储。6) void Add(DualList a, DualList b, DualList c)操作结果：加运算7) void Sub(DualList a, DualList b, DualList c)操作结果：减运算8) void DelNode(DualList L, DualNode *p)操作结果：删除因借位产生的多余的009) void PrintList(DualList L)操作

11、结果：打印链表10) 程及调用关系主程序模块输入a输入b率 调用 InputData()PrintList()调用AddList()InitList()调用DelNode()PrintList()结束三、详细设计1. 头文件定义#include <stdio.h>#include <stdlib.h>#include <ctype.h>2. 数据结构详细设计typedef struct DualNodeint data;struct DualNode *prior, *next;DualNode, *DualList;双向循环链表的节点由三个部分组成，第一是

12、数据部分data 存储此节点的数据，第二是此节点的前驱指针部分*prior 指向此节点的前驱，第三是此节点的后继指针部分*next 指向此节点的后继。数据部分我们约定它为整形变量，前驱后继指针均为结构体DualNode类型。3. 输入函数与初始化函数设计DualList InputData()int FirstNum = 1, data;char c;DualList L;L = (DualList)malloc(sizeof(DualNode);L->next = L->prior = L;printf("Please Input as Format: -1234,12

13、34,1234n");if (c = getchar() = '-')L = InitList(-1);elseL = InitList(1);if (isdigit(c) /判断是否为10进制数/ 退格处理ungetc(c, stdin);doscanf("%d", &data);while(data>9999) data=data/10;InsertNodeAtTail(L, data);while(c = getchar() != 'n');printf("Your Input is:n");

14、PrintList(L);return L;该函数在其内创建了一个双向函数链表，通过返回该链表完成初始化，减少函数个数，降低复杂度。L = (DualList)malloc(sizeof(DualNode) 为开辟存储空间， L->next = L->prior = L 将其前驱、后继都指向L, 构成循环。调用的函数InitList() 是为了在头结点存放符号。ungetc() 的使用， 是因为将本该输入却被取出的数返回到输入流中去，以便正常输入。do-while 语句是为了当输入回车时，能够停止。while(data>9999) data=data/10该句是为了当输入错误

15、，超过 4 位时，取前四位当做正常输入存储。PrintList(L) 打印存储的链表，以便观察输入的长整数是否符合预期，并在该函数中，解决当输入小于4 位的错误的情况，在前补0 存储。4. 符号位的存放DualList InitList(int sign)/ 头结点存放符号位，1 为正， -1 为负DualList L;L = (DualList)malloc(sizeof(DualNode);L->next = L->prior = L;L->data = sign;return L;建立一个双向循环链表，并将其返回。在头结点存储其符号位，1 为正， -1为负。5. 符号位

16、的初步判断DualList AddList(DualList a, DualList b) /判断符号DualList c;if (a->data * b->data > 0)c = InitList(a->data);Add(a, b, c);elsec=InitList(b->data);Sub(a, b, c);return c;当 a， b 符号相乘大于0 时，即相同时，运算后c 的符号一定等于a 的符号，执行 Add() 函数。当 a， b 符号相乘小于0 时， 即相异时，运算后 c 的符号不一定等于b 的符号。因为间 可能大于|b| ,则需在Sub()

17、函数，进一步进行判断。6. 尾插用于输入数据的存储/ 尾插，用于存储数据的输入DualNode *s;s = (DualList)malloc(sizeof(DualNode);s->data = data;s->next = L;s->prior = L->prior;L->prior->next = s;L->prior = s;例如：输入1,2345先是 1 被存入一个新的结点，在插入L 的末尾，之后2345 再存入结点，插入末尾，如此一来，方便数据的调用。7. 头插用于运算后数据的存储void InsertNodeAtHead(DualList

18、 L, int data)/ 即插在头结点之后，用于计算结果的存储DualNode *s;s = (DualList)malloc(sizeof(DualNode);s->data = data;s->next = L->next;s->prior = L;L->next->prior = s;L->next = s;例如： a=1234,5678 b=1,0001 。在本程序中，无论加减运算都从最后四位向前运算，则在头结点后存储，即为顺序存储，符合人的思维逻辑。即先在头结点存入5679， 再在头结点后存入1235，这样存储着为：1235,5679。8

19、. 打印void PrintList(DualList L)/ 打印int FirstTime = 1;DualNode *p = L;if (p->data = -1&&p->next->data!=0) printf("-");p = p->next;while(p != L)if (FirstTime)FirstTime = 0;printf("%d", p->data);elseprintf(",%04d", p->data);p = p->next;printf(&q

20、uot;n");if (p->data = -1&&p->next->data!=0) printf("-")首先判断头结点的符号并将其输出。FirstTime 的作用是判断是否为前四位，当 FirstTime=0 时， 则需要在前输出逗号。在本函数中，printf(",%04d", p->data)解决了当输入小于4 位时的输入错误，通过在前补0 的方法。9. 加预算void Add(DualList a, DualList b, DualList c)DualList pa, pb;int carry

21、 = 0, tmp;pa = a->prior;pb = b->prior;while(pa != a) && (pb != b)tmp = pa->data + pb->data + carry;if (tmp >= 10000)carry = 1;tmp -= 10000;elsecarry = 0;InsertNodeAtHead(c, tmp);pa = pa->prior;pb = pb->prior;while(pa != a)/ pb = btmp = pa->data + carry;if (tmp >= 1

22、0000)carry = 1;tmp -= 10000;elsecarry = 0;InsertNodeAtHead(c, tmp);pa = pa->prior;while(pb != b)/ pa = atmp = pb->data + carry;if (tmp >= 10000)carry = 1;tmp -= 10000;elsecarry = 0;InsertNodeAtHead(c, tmp);pb = pb->prior;if (carry != 0)InsertNodeAtHead(c, 1);本函数主要由3 个 while 语句和一个if 语句构成。

23、首先 int carry = 0, tmp; carry 代表着进位，开始为0。 tmp 为存储运行中的结果。pa = a->prior;pb = b->prior;因为a， b 为双向循环链表，pa， pb 指向其前驱，则为a， b 的末尾。例如： a=1,1111 b=2,2222 此时 pa->data=1111,pb->data=2222, 符合运算顺 序。第一个 while 语句：while(pa != a) && (pb != b)这是用来将a， b 从后开始相同长度的结点数据进行运算。tmp = pa->data + pb->d

24、ata + carry; 考虑进位的正常加法if (tmp >= 10000)carry = 1;tmp -= 10000;elsecarry = 0;当运算结果大于等于10000时， 进位 carry=1 ， 因为进位，运算结果减-10000。否则进位为0。InsertNodeAtHead(c, tmp); 将运算结果插入到c 的头结点后。pa = pa->prior; pb = pb->prior;前移第二个 while 语句：while(pa != a) 则说明a的长度大于等于b,这是需将a剩余的结点导入c 中，需要考虑进位。第三个 while 语句：while(pa

25、!= a) 则说明b的长度大于a,这是需将b剩余的结点导入c中，需要考虑进位。If 语句当 a,b 中的数据结点都运算后，还存在进位，则需要在c 的头结点插入1。10. 减运算void Sub(DualList a, DualList b, DualList c)DualList pa, pb, pc;int borrow = 0,tmp;pa = a->prior;pb = b->prior;while(pa != a) && (pb != b)/判断a>b还是a<bif (pa->data >= pb->data + borrow)

26、borrow = 0;elseborrow = 1;pa = pa->prior;pb = pb->prior;)if (pa != a | (pa = a && pb = b && borrow = 0) /判断 a>b还是a<b(/ a >= bc->data = a->data;)pa = a->prior;pb = b->prior;if(c->data!=b->data) /a>b情况borrow=0;while(pa != a) && (pb != b)/将 b

27、中与 a 等大的相减导入cif (pa->data >= pb->data + borrow) /不存在借位tmp = pa->data - pb->data - borrow;borrow = 0;elsetmp = 10000 + pa->data - pb->data - borrow;borrow = 1;InsertNodeAtHead(c, tmp);pa = pa->prior;pb = pb->prior;把 a 中剩余导入cwhile(pa != a)/if (pa->data >= borrow)tmp =

28、pa->data - borrow;borrow = 0;elsetmp = 10000 - pa->data - borrow;borrow = 1;InsertNodeAtHead(c, tmp);pa = pa->prior;else/c<bc->data=b->data;borrow=0;将 a 中与 b 等大导入cwhile(pa != a) && (pb != b)/if (pb->data >= pa->data + borrow)tmp = pb->data - pa->data - borrow

29、;borrow = 0;elsetmp = 10000 + pb->data - pa->data - borrow;borrow = 1;InsertNodeAtHead(c, tmp);pa = pa->prior;pb = pb->prior;while(pb != b) /导入 b 中剩余if (pb->data >= borrow)tmp = pb->data - borrow;borrow = 0;elsetmp = 10000 - pb->data - borrow;borrow = 1;InsertNodeAtHead(c, tm

30、p);pb = pb->prior;pc = c->next;while(pc->next !=c && pc->data = 0) /为了防止头因借位变为0的情况pc = pc->next;DelNode(c, pc->prior);本函数主要由1 个 while 与 2 个 if 语句构成。int borrow = 0,tmp; borrow 表示借位，tmp 同加函数。第一个 while 语句：while(pa != a) && (pb != b)/判断 a>b 还是 a<bif (pa->data &

31、gt;= pb->data + borrow)borrow = 0;elseborrow = 1;pa = pa->prior;pb = pb->prior;通过不断地指向前驱，以判断 a 和 b 谁先到达头结点，以判断 a 和 b 的绝对值谁大，从而判断符号是否正确。第一个 if 语句：if (pa != a | (pa = a && pb = b && borrow = 0)/ a >= bc->data = a->data;判断a>b还是a<b,因为在AddList函数中，将b的符号赋予给c,但如果a 的绝对

32、值大于b的绝对值，则将a的符号赋予给c,已完成符号位的正确判断。第二个 if 语句：if(c->data!=b->data)/|a|>|b|情况borrow=0;/重新置借位为0while(pa != a) && (pb != b)/不为符号位时进行if (pa->data >= pb->data + borrow) /因为 |a|>|b|, 应该用大数减小数tmp = pa->data - pb->data - borrow; /考虑借位的减法borrow = 0;/借位置 0elsetmp = 10000 + pa-&g

33、t;data - pb->data - borrow; /需向前一位借 1borrow = 1;InsertNodeAtHead(c, tmp);/在 c 的头结点后插入pa = pa->prior;pb = pb->prior;while(pa != a) /把a中剩余导入c,因为|a|>|b ,则只可能a有剩余if (pa->data >= borrow)tmp = pa->data - borrow;borrow = 0; elsetmp = 10000 - pa->data - borrow;borrow = 1;InsertNodeAt

34、Head(c, tmp);pa = pa->prior;Else 语句 : 大体内容同上，只是|a|<|b| 的区别。DelNode() 函数的调用：pc = c->next;while(pc->next !=c && pc->data = 0)pc = pc->next;DelNode(c, pc->prior);这是为了防止开头因借位变为0 的情况。例如： a=1,0000b=-1运算后为0,9999 ，这时 0时多余的，需要删除。11删除多余0：void DelNode(DualList L, DualNode *p)p->

35、prior->next = p->next;p->next->prior = p->prior;free(p);删除结点12主函数：int main()while(1)多组输入/DualList a, b, c;a = InputData();b = InputData();c = AddList(a, b);printf("The result is:");PrintList(c);printf("*n");return 0;为了满足实验要求，采用while(1) 实现多组输入。I*四、调试分析1. 遇到的问题在实验中，主

36、要是在减函数中遇到的问题。首先我并没有对a 和 b 的长度进行比较，而是直接开始对其相同长度的部分进行减法运算，对其借位进行的是borrow = borrow?0:1; 的操作，但在实现的过程中遇到了问题，借位总是会发生错误， 导致结果出错。在最后通过先判断其大小，再进行减法这一符合正常算法的方式，解决了这个问题。在调试时，并没有考虑多组输入问题，一个一个输入输入十分麻烦，采用while(1) 的方法。在输入的时候，经常会多按或稍按几个数，导致其调试十分麻烦，则在程序中添加算法解决这个麻烦。2. 算法的时空分析在本次实验，主要是考虑长整数的加减法问题，并没有太大的时间复杂度。其主要来源于输入，

37、输入的输出，加减法运算，和输出。由于这并不是一个很大的时间复杂度，改进的方式只能从链表的存储下手，减少存入和调出的次数已减少时间复杂度。3. 经验体会本次实验是求两个无限长整数加减运算。由于没有限制长度和必须使用链表来表示两个长整数，这样来求它们的加减运算。在开始的时候，不知道怎么去做。 最后， 明白应该用模块化，将程序分成一个个小部分，在将他们串联起来，才能完成。虽然中间遇到了许多困难，但同样复习了数据结构的知识和复习链表。五、用户使用说明用户在使用该程序时，只需按照程序提示进行即可实现长整数的加减运算，具体使用步骤如下：1）按照输入格式输入2）此时会输出你刚才的数值3）按照输入格式输入第二

38、个长整数4）此时会输出你刚才的数值5）此时会输出运算结果6）可重复上述操作，多次输入六、测试结果与情况两长整数a=b=0清枝般如一.形式箱八用 T二翌烈，每四位 月;12J4, 1231, 1L0-L 0您的输入结果为：0_请按照如下形式输入第二个长缈：-1234, 1234, 1234Q您的输入结果为： 0您的运算结果为：0 b>a>0 a=1,1111,1111,1111 b=9,9999,9999,9999情技照如下先式输入第一个长整数，每四位一组：-12弘,12弘,12弘 1, 1111, 1111, 1111您的输入结果为：13 1111, 1111, 1111情按照如下

39、形式输入第二个长整数：T2码您4,12弘% 99 阻 ggg% gggg您的输入结果为：% 99以 999% 9999您的运算结果为：IL 111L 1UL 1110 a>b>0 a=9999,9999,9999 b=2情按照如下形式输入第一个长按数，每四位一组：T23%12区12孔 9999, 9999t 9999您的输入结果为： gggg gggg gggq青按船如下形布入第二个长整数；T234, 1234, 1234 2国的输入结果为：您的运算结果为：h 0。0, 0000, 0001 b<a<0 a=-2345,6789 b=-7654,3211请技照如下附式输

40、入第一个长整数，每四位一组：T2MJ2弘J2弘-2345,6789您的输入结果为：-2345 678请按的如下形式输入第二个长整数：T2M 123虫12M-7654 3211您的输入结果为：-7654, 3211您的宏算结果为：-L 0000,0000 a<0,b>0,|a|>|b| a=-1,0000,00001 b=2|按照如下形式输入第一个长整数，每四位一组；T23&I234J234-1, 0000, 00001忸的输入结果为：-LOOOa 0001请按照如下形蝌入第二个长黎数：7234, 1Z34J2342您的输入结果为：2您的运算结果为：7999, 0999

41、 a<0,b>0,|a|<|b| a=-9999 b=1,0000pC3|fF"请按照如下用式输入第一个长整数，每四位一组：T2弘,123虫1234卜 9999区的输入结果为：gggg请按，照如不用式输入第二个长整数：723生12弘,12弘1, 0000您的输入转果为：L 0000%的运算结果为：1 a>0,b<0,|a|>|b| a=1,0000,0000 b=-9999ft按照如下用式输入第一个长整数，每四位一组：-L2鸡12叫12孔1, 0000, 0000修的输入结果为：1.0000.0000诘按照如下形编ft入第二个长整数；T23% 1Z

42、股,1234-9999惶的输入结果为：-9999叵的运算结果为；9999, 0001 a>0,b<0,|a|<|b| a=1 b=-1,0000,0000,按照如下形式输入第一个长整数每四位一组；T234112M4,1234士的输入结果为：5按照如下形式输入第二个长整数：-12弘J2弘,1234-L 0000, 0000名的输入结果为；-1, QQQQ.0QC0出的运苴结臬为：-蚂99, 9999*. .n .*.4* * * *，*、*！1* :iB«油ik*ai24C 1*油.1* .* n*油.1* .* 1*. .*lH, w口 11ra 1*错误输入（例：

43、输入超过四位，则自动取其前四位进行运算）a=1,00000 b=-99998,01234请按册如下形式输入第一个长整数.每四位一组：-123包12江,1234 1.00000恿的输入结果为：L oooo法按期如下形式输入第二个长整数：72璃12泡1234-99998,01234缶的输入结果为：-9999? 1234回的运算结果为：-9998, 1234错误输入（例：非第一次输入少于四位，则在输入前加0补足四位进行 运算）a=1,000 b=-1,11口,/rur fl *«，（+/，,，+，+11，+.+，r+«r*.+i，+，,S,«®'r w

44、i ww r *+，,S,«®'r wi '1""r ，.+，+4'i'r bi rf. i,®r eH，+. rs i®'r J't rf请依照如下形装输入重一个k®E,短四根一组：-1234, 123& 12整 1,000您的输入结果为：1, 0000请按照如下形式输入第二个长整数！ T2弭1234, 1234-1. 11您的输入结果为：-1 0011您的运算结果为：-11附录（源代码）:#include <stdio.h>#include <st

45、dlib.h>#include <ctype.h>typedef struct DualNodeint data;struct DualNode *prior, *next;DualNode, *DualList;DualList InitList(int sign)/ 头结点存放符号位，1 为正， -1 为负DualList L;L = (DualList)malloc(sizeof(DualNode);L->next = L->prior = L;L->data = sign;return L;在链表最后插入void InsertNodeAtTail(D

46、ualList L, int data) / 尾插，用于存储数据的输入DualNode *s;s = (DualList)malloc(sizeof(DualNode);s->data = data;s->next = L;s->prior = L->prior;L->prior->next = s;L->prior = s;void InsertNodeAtHead(DualList L, int data)/ 即插在头结点之后，用于计算结果的存储DualNode *s;s = (DualList)malloc(sizeof(DualNode);s-

47、>data = data;s->next = L->next;s->prior = L;L->next->prior = s;L->next = s;void PrintList(DualList L)/ 打印结果int FirstTime = 1;DualNode *p = L;if (p->data = -1&&p->next->data!=0) printf("-");p = p->next;while(p != L)if (FirstTime)FirstTime = 0;printf(

48、"%d", p->data);elseprintf(",%04d", p->data);p = p->next;printf("n");DualList InputData() int count=0;int FirstNum = 1, data;char c;DualList L;L = (DualList)malloc(sizeof(DualNode);L->next = L->prior = L;if (c = getchar() = '-')L = InitList(-1);els

49、eL = InitList(1);if (isdigit(c) /判断是否为10进制数/ 退格处理ungetc(c, stdin);doscanf("%d", &data);while(data>9999) data=data/10;InsertNodeAtTail(L, data);while(c = getchar() != 'n');printf(" 您的输入结果为:n");PrintList(L);return L;void DelNode(DualList L, DualNode *p)p->prior-&g

50、t;next = p->next;p->next->prior = p->prior;free(p);void Add(DualList a, DualList b, DualList c)DualList pa, pb;int carry = 0, tmp;pa = a->prior;pb = b->prior;while(pa != a) && (pb != b)tmp = pa->data + pb->data + carry;if (tmp >= 10000)carry = 1;tmp -= 10000;elseca

51、rry = 0;InsertNodeAtHead(c, tmp);pa = pa->prior;pb = pb->prior;while(pa != a)/ pb = btmp = pa->data + carry;if (tmp >= 10000)carry = 1;tmp -= 10000;elsecarry = 0;InsertNodeAtHead(c, tmp);pa = pa->prior;while(pb != b)/ pa = atmp = pb->data + carry;if (tmp >= 10000)carry = 1;tmp -

52、= 10000;elsecarry = 0;InsertNodeAtHead(c, tmp);pb = pb->prior;if (carry != 0)InsertNodeAtHead(c, 1);DualList pa, pb, pc;int borrow = 0,tmp;pa = a->prior;pb = b->prior;while(pa != a) && (pb != b)/判断 a>b 还是 a<bif (pa->data >= pb->data + borrow)borrow = 0;elseborrow = 1;pa = pa->prior;pb = pb->prior;if (pa != a | (pa = a &