好久没回家-护师资格考试

摘 要

数据结构课程设计，要求学生在数据结构的逻辑特性 和物理表示、数据结
构的选择和应用、算法的设计及其实现等方面，加深对课程基本内容的理解。
同时，在程序设计方法以及上机操作等基本技能和科学作风方面受到比较系统
和严格的训练。而在一般 的程序运算中，长整数是无法计算的，因为计算机一
次能够运算的位数是有限，一旦整数很长，就需要一 个程序来进行多次计算，
通过长整数运算这个程序，可一把一个长整数分成多个普通整数来进行计算，< br>使得长整数也可以进行运算。我编写的这个程序就可以进行长整数的加减运
算，各个数据也可以是 负数。
关键词：长整数；运算；加法；减法

Abstract
Data structure course design, students in the logical characteristics and physical
data structure for the representation of the design, selection and application of data
structure, algorithm and its realization, deepen the understanding of basic content of
courses. At the same time, by the systematic and rigorous training in basic skills
program design method and the operation and scientific style of work. But in the
general program operation, long integers can not be calculated, because the computer
time to operation number is limited, once the integer is long, need a program to
calculate several times, operation of this program through the long integer, can put a
long integer into a plurality of ordinary integers to calculate, the long integer can be
calculated. This program I wrote to long integer addition and subtraction, all data can
be negative.
Keywords: long integer; arithmetic; additive; subtraction

目 录
1概述 .................................................. .................................................. .................. 1
1.1题目内容 ................. .................................................. ................................... 1
1.2需求分析 .................................................. .................................................. .. 1
1.3设计要求 ................................. .................................................. ................... 1
2概要设计 .................. .................................................. ......................................... 3
2.1设计分析 ...................................... .................................................. .............. 3
2.2功能模块介绍 ................... .................................................. ......................... 3
2.3函数介绍 .......... .................................................. .......................................... 4
2.4数据结构介绍 .................................... .................................................. ........ 5
3详细设计 ............................. .................................................. .............................. 6
3.1程序流程介绍 ... .................................................. ......................................... 6
3.2函数功能介绍 .................................... .................................................. ........ 6
3.2.1主函数 .......................... .................................................. ....................... 6
3.2.2插入函数 .......... .................................................. ................................... 8
3.2.3读入数据并插入对应的链表函数 .......................... ............................. 9
3.2.4输出函数 .... .................................................. ....................................... 10
3.2.5加法函数 .................................... .................................................. ....... 10
3.2.6判断俩正数大小函数 .................... .................................................. ... 12
3.2.7 减法函数 ............................ .................................................. ............... 13
4调试分析 ..................... .................................................. .................................... 15
4.1使用说明 ...................................... .................................................. ............ 15
4.2测试结果 ...................... .................................................. ............................ 15
5总结 .......... .................................................. .................................................. ..... 19
参考文献 ................................ .................................................. ............................ 20
致 谢 ....... .................................................. .................................................. ....... 21
附 录 ............................... .................................................. .................................... 22

1概述
1.1题目内容
题目：长整数运算
内容：使用双向循环链表存储长整数，每个结点含一个整型变量，主要功
能有：长整数输入（建 立双向循环链表）、长整数的加法、长整数的减法及结
果的显示输出等。
1.2需求分析
1.本程序实现计算任意长的整数的加法运算. 以用户和计算机对话的方式，
即在计算机终端 上显示“提示信息”之后，由用户在键盘上输入演示程序中规定
的运算命令，然后程序就计算并显示出这 两个数的运算。
2.本程序中，集合的元素限定为数字字符[„0‟~‟9‟]和字符„，‟与„；‟ ，输入字
符可以任意长，输入形式以“回车符”为结束标志，串中字符顺序不限，且允许
出现重 复字符。
3.现实长整数的分组存储，每个结点含一个整形变量。输入的形式以回车
结束，可 以直接输入正数或负数。按中国对于长整数的表示习惯，每四位一
组，除数字和位于首位置的负号外，其 它一切字符都将作为分隔符，连续多个
分隔符当一个处理。但不使用分隔符也不影响结果。
输 入和输出形式是按中国对于长整数的表示习惯，每四位一组，组间用逗
号隔开，长整数位数没有上限，以 分号结束长整型数据的输入。
1.3设计要求
该设计要求设计程序，实现两个任意长的整数 求和及差的运算问题。通过
该题目的设计过程，可以加深理解线性表的逻辑结构、存储结构，掌握线性表
上基本运算的实现，进一步理解和熟练掌握课本中所学的各种数据结构，学会
如何把学到的知识 用于解决实际问题，培养学生的动手能力。
详细要求：
（1）至少要用10组测试数据，算 法对于这些合法的输入数据都能产生满
足规格说明要求的结果；
（2）算法对于精心选择的典 型、苛刻而带有刁难性的几组输入数据能够得
出满足规格说明要求的结果；对算法实现过程中的异常情况 能给出有效信息；

（3）任何整型变量的范围是-(215-1 )~（215-1）。输入和输出形式：按中
国对于长整数的表示习惯，每四位一组，组间用逗号隔开， 例1，0000，00
00，0000；而输入为1，0001，0001和-1，0001，000 0实现加法时，应输出
；
（4）较高要求：使程序在整型量范围是-(2n-1)~(2n- 1)的计算机上都能有效
地运行。其中，n是由程序读入的参量。

2概要设计
2.1设计分析
我们首先要考虑 的是如何表示长整型数。按照传统习惯要求每4位数形成
1组，而一个长整型数可能会有很多组这种4位 数，而每节之间是有先后顺序
的，因此我们可以考虑用数组和链表来存储数据。(1)再考虑到每个长整 型数的
长度在输入之间是无法预知的，因此使用链表在存储空间的分配上更方便一
些。(2)在 输入数据时总是从高位到低位地存储，而计算时总是从低位向高位运
算，因此采用双向链表更方便，而为 了从头结点方便地转到尾结点可以采用循
环链表。总之，为了实现上述功能，应以双向循环链表表示长整 数，每个结点
含一个整型变量，且仅绝对值不超过9999的整数，整个链表用十进制数表示。
(3)对于每一个长整型数可以设置一个头结点，其中的数据域用来表示该长整型
数的正负号及组数，该 值的符号则表示该长整型数的符号，该数的绝对值表示
该长整型数包含的4位数的组数。第一个存储4位 数据组的结点称为首结点，
而最后一个4位数据组结点称为尾结点。
为此需要两个结构数据类 型：双向循环链表和长整数，两个类型采用相同
的结构，只是双向循环链表用来存储数据，长整型用表示 数据的运算。
利用双向循环链表来实现对长整数的存储。选择该数据结构来完成长整数
的加减 运算是因为要对长整数进行运算，需要对长整数进行存储，所以选择用
链表对长整数存储，又由于存储的 顺序是从左到右，而运算的顺序则是从右到
左，这样位了操作方便选择循环链表，在运算过程中有进位和 借位的操作，所
以最终选择双向循环链表的数据结构。
2.2功能模块介绍
该程序主要由以下几大模块组成：
1.主程序模块：主要实现对个模块的调用和界面的管理， 提示用户，帮助
用户快速准确的完成运算。
2.双向循环链表处理模块：实现对数据的存储、管理，主要由void
ListInitiate、int ListLength等函数组成。
3.长整型数的输入输出模块：主要 由void OutputNumber、int InputNumber
等函数组成，实现数据的输入。

4.长整数运算模块：主要由void add、int change 、int change等函数组
成。也就是函数void yunsuan(DLNode *head1,DLNode *head2,DLNode
*head3,char ch)实现的 是正数，负数，加法，减法。计算式共分为八种运算，在
这之前我已经实现了二种运算，那么这个函数就 是把这八种运算按照一定的规
则转化成已经实现的二种运算来实现完整的加减法运算。
程序功能模块图如图2.1所示。







双向循环链表单元模块
图2.1功能模块图

长整数运算模块
主程序模块

长整数输入输出模块

2.3函数介绍
void ListInitiate(DLNode **head)
操作结果：初始化一个头结点为head的双向循环链表。
int ListLength(DLNode *head)
操作结果：计算以head为头结点的链表的长度。
int ListInsert(DLNode *head,int i,int x)
操作结果：将节点数据为x的节点插到第i个位置上去。
int abs(int x)
操作结果：绝对值函数，返回x的绝对值。
int InputNumber(DLNode *head)
操作结果：将从键盘中接收数据并把得到的数据存入以head为头结点的链
表 中。四位一存，中间以逗号区分，结束符为分号。
void OutputNumber(DLNode *head,int sign)
操作结果：将以head为头结点的链表中的所有数据输出到显示屏上。

void add(DLNode *head1,DLNode *head2,DLNode *head3)
操作结果：实现正数加正数的加法操作。
int change(DLNode *head1,DLNode *head2)
操作 结果：判断存在俩个链表中的数的大小，如何head1中的数大于head2
中的数那么返回值为0， 反之返回值为1，相等时返回值为2。
void minus(DLNode *head1,DLNode *head2,DLNode *head3)
操作结果：计算正数减正数的减法运算。
void main()
操作结果：主函数。调用以上的各个函数来引导用户进行长整数的加法运
算，加法运算.。
2.4数据结构介绍
本次课设所使用的数据结构双向循环链表的节点由三个部分组成，第一是
数据部分data存储此节点的数据，第二是此节点的前驱指针部分*prior指向此
节点的 前驱，第三是此节点的后继指针部分*next指向此节点的后继。数据部分
我们约定它为整形变量，前 驱后继指针均为结构体Node类型。代码如下：
typedef struct Node 双向链表的结构体定义
{ int data;
struct Node *prior;
struct Node *next;
}DLNode;

3详细设计
3.1程序流程介绍
由上面的提到的主程序 、长整数运算、长整数输入输出、双向循环链表等
几个主要模块，可得到程序运行图如下：






开始
输入两位整数
数字转化链表
Y




两个负数相加
两个正数相加
第一个数减第二个数
N
情况判断








第二个数减第一数
输出转化
输出结果
结束

图3.1主程序流程图
3.2函数功能介绍
3.2.1主函数
主要的作用是为用户做一个提示，如何完成自己想要的运算。同时调用各< br>个函数实现运算。代码如下：

void main()
{ int n;
char ch,ch1,m;
while(1)
{ DLNode *a,*b,*c;
ListInitiate(&a);
ListInitiate(&b);
ListInitiate(&c);
printf(长整数运算 --------------nn
printf(请输入数A(以分号结束):
InputNumber(a);
printf(请输入数B(以分号结束):
InputNumber(b);
printf(请选择操作符：<+,->:
do
{ scanf(
if(ch1=='+'||ch1=='-')
{


}
else
{printf(此版本不支持%c运算！是否重新输入运算符？(yn)：
scanf(
if(m=='Y'||m=='y') { n=2; printf(请输入运算符'-'或'+'：
else break;
}
}
while(n=2);
yunsuan(a,b,c,ch1);
OutputNumber(c,1);
break;

printf(要继续新的运算吗？(yn) :
scanf(


if(ch=='Y'||ch=='y')
{ printf(


continue;
}
else exit(0):
}
}
3.2.2插入函数
已知一双向链 表，在第i个位置插入data为x的节点。函数需要注意的是
在什么位置插入才是合法的，在就是在该 节点指针时的顺序不要搞错。代码如
下：
int ListInsert(DLNode *head,int i,int x) 双向链表的数据插入,i表示是插入
的第几个元素
{ DLNode *p,*s;
int j;
p=head->next;
j=0;
while(p!=head&&jnext; j++; }
if(j!=i) { printf(插入位置不合法！
if((s=(DLNode *)malloc(sizeof(DLNode)))==NULL) exit(0);
s->data=x;
s->prior=p->prior;插入
p->prior->next=s;
s->next=p;
return 1;
}
p->prior=s;

3.2.3读入数据并插入对应的链表函数
实现从键盘上得到数据根据三种情况进行不同的处 理，判断是否是头结
点，判断是否是整数，判断输入的字符是否是“；”分号。并且如果是正整数它的头结点data等于1否则为0。代码如下：
int InputNumber(DLNode *head) 读入输入的数据
{ int input,i=0;第i个节点
char c;
scanf(
while(1)
{











if(input<0&&i==0)输入数为负且是第一个节点
{

}
else if(input>=0&&i==0)输入数为正且是第一个节点
{

}
else
{


if(head->next->data>=0)
ListInsert(head,i,input);非第一个节点
else

head->data=1;将长整数的符号保存在头结点中
ListInsert(head,i,input);插入数据
head->data=0;将长整数的符号保存在头结点中
ListInsert(head,i,input);插入数据
ListInsert(head,i,input);
}
i++;


}
return 1;
}
if(c==';') break;遇到数据输入完成标志，跳出循环
scanf(

3.2.4输出函数
实现将最后的结果输出到显示屏上，经过判断数据的正负和数据的范围来
进行不同的处理，以保证在显示屏上显示的是正确的格式。代码如下：
void OutputNumber(DLNode *head,int sign) 从表尾输出数据元素
{ DLNode *r=head->next;
while(r->data==0&&r!=head->prior)
{ r=r->next; }
if(sign==1) printf(结果是:
else printf(结果是: -
printf(








}
r=r->next;
while(r!=head)
{




if(r->data<10) printf(
else if(r->data<100) printf(
else if(r->data<1000) printf(
else printf(
r=r->next;
} printf(
3.2.5加法函数
实现两个正数之间的相加运算，主要的算法和我们手算加 法是一样的，首
先设置一个进位计数的变量，根据存储的特点从低位开始相加带上进位即可得
出 相应的位和，最后更新进位变量。处理边界状况：如果两个链表一样长同时
他们最高位在计算完成时仍然 会有进位，那么应该考虑到在数据的更高位插入
一个1表示最后的计算结果，这样才可以保证数据的完整 性。代码如下：
void add(DLNode *head1,DLNode *head2,DLNode *head3){
int z=0,e;
DLNode *p1,*p2;
p1=head1->prior;

p2=head2->prior;
while(p1!=head1&&p2!=head2)
{ e=p1->data+p2->data+z;
if(e>=10000)
{ z=1; e=e%10000; }
else z=0;
ListInsert(head3,0,e);
p1=p1->prior;p2=p2->prior;
}
if(p1==head1&&p2!=head2)
{ while(p2!=head2)
{ e=p2->data+z;
if(e>=10000) { z=1; e=e%10000; }
else z=0; ListInsert(head3,0,e);
p2=p2->prior;
}
if(z==1) ListInsert(head3,0,z);
}
else if(p1!=head1&&p2==head2){
while(p1!=head1)
{ e=p1->data+z;
if(e>=10000) { z=1; e=e%10000; }
else z=0;
ListInsert(head3,0,e);
p1=p1->prior;
} if(z==1) ListInsert(head3,0,z);
}
else { if(z==1) ListInsert(head3,0,z); }
}

3.2.6判断俩正数大小函数
实现判断俩个正数的大小。考虑俩正数的在链表中所占存储单 元的多少，
多的一定大，当他们一样长时，一位一位的比较直到找到一个节点中的data比
另 一个链表的对应节点的data大为止。如果最后仍是一样大那么这两个数就是
一样大的。返回值为自己 约定的参数r等于2表示俩数一样大，等于1表示第
二个数大，等于 0表示第一个数大。代码如下：

int change(DLNode *head1,DLNode *head2)
{ int length1,length2,r=2;
length1=ListLength(head1);
length2=ListLength(head2);
DLNode *p1,*p2;
p1=head1->next;
p2=head2->next;
if(length1>length2)
{ r=0; return r; }
else if(length1 { r=1; return r; }
else
{








int i=0;
for(i=0;i{





}
if(p1->data>p2->data)
{ r=0; return r; break; }
else if(p2->data>p1->data)
{
else
{ p1=p1->next; p2=p2->next; r=2; }
r=1; return r; break; }
} return r;
}

3.2.7 减法函数
实现两个正数的减法运算。整个 函数分为俩大部分，第一部分处理第一个
数大于第二个数，第二部分是处理第二个数大于第一个数。代码 如下：
void minus(DLNode *head1,DLNode *head2,DLNode *head3)
{ int z=0,x=-1,e;
DLNode *p1,*p2;
p1=head1->prior;
p2=head2->prior;
x=change(head1,head2);
if(x==0)
{















while(p1!=head1&&p2!=head2)
{












}
p1->data=p1->data+z;
p1->data=p1->data+z;
if(p1->data>=p2->data)
{



}
else
{

e=10000+p1->data-p2->data;
ListInsert(head3,0,e);
e=p1->data-p2->data;
ListInsert(head3,0,e);
p1=p1->prior; p2=p2->prior;
z=0;
p1=p1->prior;p2=p2->prior;

}
z=-1;
while(p1!=head1)
{e=p1->data;
ListInsert(head3,0,e);

p1=p1->prior;
}
}
else if(x==1)
{ p2=head1->prior; p1=head2->prior;















while(p1!=head2&&p2!=head1)
{











}
p1->data=p1->data+z;
p1->data=p1->data+z;
if(p1->data>=p2->data)
{ e=p1->data-p2->data;



}
else
{

e=10000+p1->data-p2->data;
ListInsert(head3,0,e);
ListInsert(head3,0,e);
p1=p1->prior; p2=p2->prior;
z=0;
p1=p1->prior; p2=p2->prior;
z=-1; }
while(p1!=head2)
{ e=p1->data;
ListInsert(head3,0,e);
p1=p1->prior;
}
head3->next->data=-1*head3->next->data;
}
else { head3->next->data=0;
}
}

4调试分析
1.由于对任意长整数运算的算法推敲不足，是程序调试时费时不少。
2.本程序有些代码重复出现，从而减少了空间的利用率和增加了程序代码
的杂乱性。
3.本程序模块划分比较合理，且把指针全部封装在链表模块中，操作方
便。
4.算法的时空分析，由于链表采用双向循环链表结构，可以从链表两头操
作，各种操作的算法时间复杂 度比较合理，各函数以及确定链表中的结点位置
都是O（n）,n为链表长度。
5.本课设采用数据抽象的程序设计方法，将程序分为4个模块，使得设计
时思路清晰，实现时调试顺利 ，各模块具有较好的可重用性，确实得到了一次
良好的程序设计训练。
4.1使用说明 用户在使用该程序时，只需按照程序中的规定进行即可实现长整数的加减
运算，具体使用步骤如下：

1.点击运行按钮，在DOS窗口下按照规定输入的数字需要从低位开始数四
位一组 用逗号隔开。输入第一个数字；
2.同上输入第二个数；
3.选择要对这两个长整数进行的运算；
4.两个操作数与运算符选择完毕后，按回车键即可得到运算结果。
4.2测试结果
1.输入0和0做加法运算，输出“0”，结果如下图：
图4.1 零的加减运算截图

2.输入2345，6789和-7654，3211做减法运算 ，输出“1，0000，0000”，结
果如下图：
图4.2正数减负数截图
3.输入1，0000， 0000和9999，9999做减法运算，输出“9999，0000，
0001”，结果如下图：
图4.3大数减小数截图
4.输入1，0001，0001和1，0001，0001做减法 运算，输出“0”，结果如下
图：
图4.4两相等数相减截图

5.输入1,2345,6789 和9,8765,4321做减法运算，结果如下图：
图4.5小数减大数截图
6.输入3 456，6547,1324,4352和6543,3452,8675,5648做加法运算，结果如
下图：
图4.6两数相加截图

7.输入6,4567,1358,7821和 -3456,2263,6524做加法运算，结果如下图：
图4.7正数加负数截图

8.当输入运算符错误时会提醒是否重新输入进行运算，结果如下图：
图4.8符号输入错误截图

5总结
这次的课程设计中，长整 数运算这个题目给了我很大的挑战，在设计中遇
到了很多的困难，比如如何用如何将字符数据分割成很多 部分存储进双向循环
链表，如何判断输入的字符串是否是正确的；在输入特殊数据比如0000,000 00
时，程序能够消除无用的前置零得出正确的结果，我在这些问题上都考虑的很
久，一点点的 攻破难题。
而在这次课程设计中我对长正数的各种运算也有了一定的认识，对于特别
长的数的 计算，只能先求局部结果，最后将局部结果综合起来，得到最终结
果。比如加法就是从最低位开始计算， 判断进位后再一次向高位计算，最终得
到结果。计算加法的时候，由于是每四位一个结点，所以是以万位 为进制。输
出时如果一个结点中数据是以为，则前面输出三个零，如果是两位，则输出两
个零， 如果是三位，则输出一个零，四位数直接输出。如果节点数据为零，则
按第一种情况输出是前面加三个零 即可。为了程序的健壮性，应该考虑负数和
正数相加的情况，如果一个较大的正数加上一个数值较小的负 数，应该是大数
减去去掉振幅符号的小数，即可。如果是一个较小的正数加上一个数值较大的
负 数，则应该是去掉正负号的负数减去正数，最后在结果里加上一个负号即
可。
以上是我对长 整数运算的一点思考，本次课程设计中学到的很多的知识，
对循环链表的操作也更加的熟悉，更让我增长 了许多的编程经验，我相信以后
的编程学习中我会表现的更加出色。

参考文献
[1]严蔚敏，吴伟民.数据结构（C语言版）.清华大学出版社
[2]严蔚敏，吴伟民.数据结构题集（C语言版）.清华大学出版社
[3] William Ford,William Topp .DATA STRUCTURE WITH C++.清华大学出
版社（影印版）.
[4]谭浩强.C语言程序设计. 清华大学出版社
[5][美]S巴斯.计算机算法:设计和分析引论.上海:复旦大学出版社，1985.
[6]姚诗斌.数据库系统基础.计算机工程与应用，1981.
[7]黄维通.C语言设计教程.清华大学出版社，2005.
[8]王成端.C语言程序设计.中国水利水电出版社，2005.
[9]张基温.C语言程序设计案例教程.清华大学出版社，2004.
[10]苏小红，陈惠鹏.C语言大学实用教程[M].电子工业出版社，2007.
[11]林建秋，韩静萍.C语言程序设计[M].电子工业出版社，2004.

致 谢
首先感谢杨书鸿老 师，感谢她对我学习的悉心教导，她为我创造了各种机
会去迎接各种各样的挑战，使我能够迅速成长起来 ，让我明白了学无止境，必
须以正确的态度面对各种挑战。当然，我也要感谢我的同学和那些互联网上的
朋友，他们毫不吝啬的将自己所掌握的知识拿出来资源共享，才能使我的部分
功能模块得以实现 ，谢谢你们。通过本次实训，我的知识领域得到了进一步扩
展，专业技能进一步提高，同时增强了分析和 解决实际问题的综合能力。
在此，向杨老师致以诚挚的谢意和崇高的敬意,也对我的同学表示衷心的感
谢，在他们的帮助下，我学会了很多，在这为期两周的课程设计当中，我们精
诚合作，克服了不 少难题，取长补短了解俄很多其他的知识，也了解了合作精
神在学习过程中的重要性，在以后的学业生涯 中，我一定会再接再厉！

附 录
源程序：
#include
#include
#include
typedef struct Node 双向链表的结构体定义
{ int data;
struct Node *prior;
struct Node *next;
}DLNode;
void ListInitiate(DLNode **head) 双向链表的初始化
{ if((*head=(DLNode *)malloc(sizeof(DLNode)))==NULL) exit(0);
(*head)->prior=*head;
(*head)->next=*head;
}
int ListLength(DLNode *head) 双向链表的表长
{ DLNode *p=head;
int size=0;
while(p->next!=head)
{ p=p->next; size++; }
return size;
}
双向链表的数据插入,i表示是插入的第几个元素
int ListInsert(DLNode *head,int i,int x)
{ DLNode *p,*s;
int j;
p=head->next;
j=0;
while(p!=head&&jnext; j++; }

if(j!=i){ printf(插入位置不合法！
if((s=(DLNode *)malloc(sizeof(DLNode)))==NULL) exit(0);
s->data=x;
s->prior=p->prior;插入
p->prior->next=s;
s->next=p;
return 1;
}
int abs(int x)
{ if(x<0) return -x;
else return x;
}
int InputNumber(DLNode *head) 读入输入的数据
{ int input,i=0;第i个节点
char c;
scanf(
while(1)
{ if(input<0&&i==0)输入数为负且是第一个节点
{ head->data=0;将长整数的符号保存在头结点中
ListInsert(head,i,input);插入数据
}
else if(input>=0&&i==0)输入数为正且是第一个节点
{ head->data=1;将长整数的符号保存在头结点中

}
else
{ if(head->next->data>=0)
ListInsert(head,i,input);非第一个节点
else { input=-1*input; ListInsert(head,i,input); }
ListInsert(head,i,input);插入数据
p->prior=s;

} i++;
if(c==';') break;遇到数据输入完成标志，跳出循环
scanf(
} return 1;
}
void OutputNumber(DLNode *head,int sign) 从表尾输出数据元素
{ DLNode *r=head->next;
while(r->data==0&&r!=head->prior)
{ r=r->next; }
if(sign==1) printf(结果是:
else printf(结果是: -
printf(
r=r->next;
while(r!=head)
{ if(r->data<10) printf(
else if(r->data<100) printf(
else if(r->data<1000) printf(
else printf(
r=r->next;
} printf(
}
void add(DLNode *head1,DLNode *head2,DLNode *head3){
int z=0;
int e;
DLNode *p1,*p2;
p1=head1->prior;
p2=head2->prior;
while(p1!=head1&&p2!=head2)
{ e=p1->data+p2->data+z;

if(e>=10000) { z=1; e=e%10000; }
else z=0;
ListInsert(head3,0,e);
p1=p1->prior; p2=p2->prior;
}
if(p1==head1&&p2!=head2)
{ while(p2!=head2)
{ e=p2->data+z;
if(e>=10000) { z=1; e=e%10000; }
else z=0;
ListInsert(head3,0,e);
p2=p2->prior;
}
if(z==1) ListInsert(head3,0,z);
}
else if(p1!=head1&&p2==head2){
while(p1!=head1)
{ e=p1->data+z;
if(e>=10000) { z=1; e=e%10000; }
else z=0;
ListInsert(head3,0,e);
p1=p1->prior;
} if(z==1) ListInsert(head3,0,z);
}
else { if(z==1) ListInsert(head3,0,z); }
}
int change(DLNode *head1,DLNode *head2)
{ int length1,length2,r=2;
length1=ListLength(head1);

length2=ListLength(head2);
DLNode *p1,*p2;
p1=head1->next; p2=head2->next;
if(length1>length2) { r=0; return r; }
else if(length1 else
{ int i=0;
for(i=0;i { if(p1->data>p2->data) { r=0; return r; break; }
else if(p2->data>p1->data) { r=1; return r; break; }
else { p1=p1->next; p2=p2->next; r=2; }
}
} return r;
}
void minus(DLNode *head1,DLNode *head2,DLNode *head3)
{ int z=0,x=-1,e;
DLNode *p1,*p2;
p1=head1->prior;
p2=head2->prior;
x=change(head1,head2);
if(x==0)
{ while(p1!=head1&&p2!=head2)
{ p1->data=p1->data+z;
if(p1->data>=p2->data)
{ e=p1->data-p2->data;




ListInsert(head3,0,e);
p1=p1->prior;p2=p2->prior;
z=0;
}

}
else
{ e=10000+p1->data-p2->data;
ListInsert(head3,0,e);
p1=p1->prior;p2=p2->prior;
z=-1;
}
p1->data=p1->data+z;
while(p1!=head1)
{ e=p1->data;
ListInsert(head3,0,e);
p1=p1->prior;
}
}
else if(x==1)
{ p2=head1->prior; p1=head2->prior;
while(p1!=head2&&p2!=head1)
{ p1->data=p1->data+z;
if(p1->data>=p2->data)










{ e=p1->data-p2->data;
ListInsert(head3,0,e);
p1=p1->prior; p2=p2->prior;
z=0;
}
else
{ e=10000+p1->data-p2->data;
ListInsert(head3,0,e);
p1=p1->prior; p2=p2->prior;
z=-1;

}
}
p1->data=p1->data+z;
while(p1!=head2)
{ e=p1->data;
ListInsert(head3,0,e);

}
head3->next->data=-1*head3->next->data;
}
else { head3->next->data=0; }
}
void yunsuan(DLNode *head1,DLNode *head2,DLNode *head3,char ch)
{DLNode *p1,*p2;
p1=head1->next; p2=head2->next;
if(head1->data==1&&head2->data==1)
{ if(ch=='+') add(head1,head2,head3);
else minus(head1,head2,head3);
}
else if(head1->data==1&&head2->data==0)
{ if(ch=='+')






{ head2->next->data*=-1;
minus(head1,head2,head3);
}
else
{ head2->next->data*=-1;
add(head1,head2,head3);
p1=p1->prior;
}
}

else if(head1->data==0&&head2->data==1)
{









}
else
{





if(ch=='+')
{



}
head1->next->data*=-1;
head2->next->data*=-1;
add(head1,head2,head3);
head3->next->data*=-1;
if(ch=='+')
{

}
else
{



}
head1->next->data*=-1;
head2->next->data*=-1;
add(head1,head2,head3);
head3->next->data*=-1;
head1->next->data*=-1;
minus(head2,head1,head3);
else




}
}
void main()
{ int n;
char ch,ch1,m;
{


}
head1->next->data*=-1;
head2->next->data*=-1;
minus(head2,head1,head3);

while(1)
{ DLNode *a,*b,*c;
ListInitiate(&a);
ListInitiate(&b);
ListInitiate(&c);
printf(长整数运算 --------------nn
printf(请输入数A(以分号结束):
InputNumber(a);
printf(请输入数B(以分号结束):
InputNumber(b);
printf(请选择操作符：<+,->:
do{
scanf(
if(ch1=='+'||ch1=='-') { yunsuan(a,b,c,ch1); OutputNumber(c,1); break; }
else
{ printf(此版本不支持%c运算！是否重新输入运算符？(yn)：
scanf(
if(m=='Y'||m=='y') { n=2; printf(请输入运算符'-'或'+'：
else break;
}
}
while(n=2);
printf(要继续吗运算吗？(yn) :
scanf(
if(ch=='Y'||ch=='y') { printf(
else exit(0);
}
}