长整数加减运算实验报告.docx
《长整数加减运算实验报告.docx》由会员分享，可在线阅读，更多相关《长整数加减运算实验报告.docx（37页珍藏版）》请在冰豆网上搜索。
长整数加减运算实验报告
长整数加减的运算
一、需求分析
问题描述：
设计一个实现任意长的整数进行加法运算的演示程序
基本要求：
利用双向循环链表实现长整数的存储，每个结点含一个整型变量。
任何整型变量的范围是
－（215－1）～（215－1）。
输入输出形式：
按照中国对于长整数的表示习惯，每四位是一组，组间用逗号隔开
更高要求：
（1）长整数的减法
（2）多个长整数的连续加减法，并带括号等。
具体方式可以参见表达式的求值部分，利用栈
测试数据：
（1）0；0；应输出“0”
（2）－2345，6789；－7654，3211；应输出“－1，0000，0000”
（3）－9999，9999；1，0000，0000，0000；应输出“9999，0000，0001”
（4）1，0001，0001；－1，0001，0001；应输出“0”
（5）1，0001，0001；－1，0001，0000；应输出“1”
（6）－9999，9999，9999；－9999，9999，9999；应输出“－1，9999，9999，9998”
（7）1，0000，9999，9999；1；应输出“1，0001，0000，0000”
一、概要设计
1.数据结构
此实验采用的数据结构是双向循环链表。
这样可以很容易的找到他的前驱以及它的后继。
节点采用结构体类型，代码如下：
typedefstructNode//双向链表的结构体定义
{
intdata;
structNode*prior;
structNode*next;
}DLNode;
2.使用函数
1）voidListInitiate（DLNode**head）
操作结果：
初始化一个头结点为head的双向循环链表；
2）intListLength（DLNode*head）
操作结果：
计算以head为头结点的链表的长度
3）intListInsert（DLNode*head,inti,intx）
操作结果：
将节点数据为x的节点插到第i个位置上去。
4）intabs（intx）
操作结果：
绝对值函数，返回x的绝对值。
5）intInputNumber（DLNode*head）
操作结果：
将从键盘中接收数据并把得到的数据存入以head为头结点的链表中。
四位一存，中间以逗号区分，结束符为分号。
6）voidOutputNumber（DLNode*head,intsign）
操作结果：
将以head为头结点的链表中的所有数据输出到显示屏上，
7）voidadd（DLNode*head1,DLNode*head2,DLNode*head3）
操作结果：
实现正数加正数的加法操作。
8）intchange（DLNode*head1,DLNode*head2）
操作结果：
判断存在俩个链表中的数的大小，如何head1中的数大于head2中的数那么返回值为0，反之返回值为1，相等时返回值为2；
9）voidmethod（DLNode*head1,DLNode*head2,intx）
操作结果：
计算正数乘以正数的乘法运算。
10）voidminus（DLNode*head1,DLNode*head2,DLNode*head3）
操作结果：
计算正数减正数的减法运算。
11）voidyunsuan（DLNode*head1,DLNode*head2,DLNode*head3,charch）
操作结果：
正数，负数，加法，减法。
计算式共分为八种运算，在这之前我已经实现了二种运算，那么这个函数就是把这八种运算按照一定的规则转化成已经实现的二种运算来实现完整的加减法运算。
12）voidchengfa（DLNode*head1,DLNode*head2）
操作结果：
在乘法中我只是实现了正数乘以正数的运算，那么这个函数就是通过调用method函数按照一定的规则来实现完整的乘法运算。
13）voidmain（）
操作结果：
主函数。
调用以上的各个函数来引导用户进行长整数的加法运算，加法运算，乘法运算。
二、详细设计
1.数据结构详细设计
typedefstructNode//双向链表的结构体定义
{
intdata;
structNode*prior;
structNode*next;
}DLNode;
双向循环链表的节点由三个部分组成，第一是数据部分data存储此节点的数据，第二是此节点的前驱指针部分*prior指向此节点的前驱，第三是此节点的后继指针部分*next指向此节点的后继。
数据部分我们约定它为整形变量，前驱后继指针均为结构体Node类型。
2.链表初始化函数：
voidListInitiate（DLNode**head）//双向链表的初始化
{
if（（*head=（DLNode*）malloc（sizeof（DLNode）））==NULL）exit（0）;
（*head）->prior=*head;
（*head）->next=*head;
}
初始化之前需要定义一个类型为Node型的头结点变量，经过函数后完成链表的初始化即：
头节点的前驱指针指向自己，同时他的后继指针也指向自己。
3.计算已知的链表长度：
intListLength（DLNode*head）//双向链表的表长
{
DLNode*p=head;
intsize=0;
while（p->next!
=head）
{
p=p->next;
size++;
}
returnsize;
}
此函数计算的是已知链表的长度。
主要思想：
从头结点开始寻找下一个节点，找到计数器加一。
直到再次寻找到头结点时停止，计算完毕。
4.插入函数：
intListInsert（DLNode*head,inti,intx）//双向链表的数据插入,i表示是插入的第几个元素
{
DLNode*p,*s;
intj;
p=head->next;
j=0;
while（p!
=head&&j{
p=p->next;
j++;
}
if（j!
=i）
{
printf（"\n插入位置不合法！
"）;
return0;
}
if（（s=（DLNode*）malloc（sizeof（DLNode）））==NULL）exit（0）;
s->data=x;
s->prior=p->prior;//插入
p->prior->next=s;
s->next=p;
p->prior=s;
return1;
}
此函数是已知一双向链表实现在第i个位置插入data为x的节点。
函数需要注意的是在什么位置插入才是合法的，在就是在该节点指针时的顺序不要搞错。
5.绝对值函数：
intabs（intx）
{
if（x<0）return-x;
elsereturnx;
}
此函数是实现求一个整数的绝对值。
设计这么一个函数主要是考虑到在存储负数的时候头结点应该变为正整数，然后通过其他手段变相实现那种运算。
6.读入数据并插入对应的链表函数：
intInputNumber（DLNode*head）//读入输入的数据
{
intinput,i=0;//第i个节点
charc;
scanf（"%d%c",&input,&c）;
while
（1）
{
if（input<0&&i==0）//输入数为负且是第一个节点
{
head->data=0;//将长整数的符号保存在头结点中
//input=abs（input）;//取输入数字的绝对值
ListInsert（head,i,input）;//插入数据
}
elseif（input>=0&&i==0）//输入数为正且是第一个节点
{
head->data=1;//将长整数的符号保存在头结点中
ListInsert（head,i,input）;//插入数据
}
else
{
if（head->next->data>=0）
ListInsert（head,i,input）;//非第一个节点
else
{
//input=-1*input;
ListInsert（head,i,input）;
}
}
i++;
if（c==';'）break;//遇到数据输入完成标志，跳出循环
scanf（"%d%c",&input,&c）;
}
return1;
}
此函数实现的是从键盘上得到数据根据三种情况进行不同的处理，判断是否是头结点，判断是否是整数，判断输入的字符是否是“；”分号。
并且如果是正整数它的头结点data等于1否则为0。
7.输出函数
voidOutputNumber（DLNode*head,intsign）//从表尾输出数据元素
{
DLNode*r=head->next;
while（r->data==0&&r!
=head->prior）
{
r=r->next;
}
if（sign==1）
{
printf（"结果是:
"）;
}
else
{
printf（"结果是:
-"）;
}
printf（"%d",r->data）;
r=r->next;
while（r!
=head）
{
if（r->data<10）
{
printf（",000"）;
printf（"%d",r->data）;
}
elseif（r->data<100）
{
printf（",00"）;
printf（"%d",r->data）;
}
elseif（r->data<1000）
{
printf（",0"）;
printf（"%d",r->data）;
}
else
{
printf（",%d",r->data）;
}
r=r->next;
}
printf（"\n"）;
}
此函数实现的是将最后的结果输出到显示屏上，经过判断数据的正负和数据的范围来进行不同的处理，以保证在显示屏上显示的是正确的格式。
8.不完整加法函数（只可实现正数加上正数）
voidadd（DLNode*head1,DLNode*head2,DLNode*head3）{
intz=0;
inte;
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;
}
elsez=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;
}
elsez=0;
ListInsert（head3,0,e）;
p2=p2->prior;
}
if（z==1）ListInsert（head3,0,z）;
}
elseif（p1!
=head1&&p2==head2）{
while（p1!
=head1）
{
e=p1->data+z;
if（e>=10000）
{
z=1;
e=e%10000;
}
elsez=0;
ListInsert（head3,0,e）;
p1=p1->prior;
}
if（z==1）ListInsert（head3,0,z）;
}
else{
if（z==1）ListInsert（head3,0,z）;
}
}
此函数实现的是两个正数之间的相加运算，主要的算法和我们手算加法是一样的，首先设置一个进位计数的变量，根据存储的特点从低位开始相加带上进位即可得出相应的位和，最后更新进位变量。
处理边界状况：
如果两个链表一样长同时他们最高位在计算完成时仍然会有进位，那么应该考虑到在数据的更高位插入一个1表示最后的计算结果，这样才可以保证数据的完整性。
9.判断俩正数大小函数：
intchange（DLNode*head1,DLNode*head2）
{
intlength1,length2,r=2;
length1=ListLength（head1）;
length2=ListLength（head2）;
DLNode*p1,*p2;
p1=head1->next;
p2=head2->next;
if（length1>length2）
{
r=0;
returnr;
}
elseif（length1{
r=1;
returnr;
}
else
{
inti=0;
for（i=0;i{
if（p1->data>p2->data）
{
r=0;
returnr;
break;
}
elseif（p2->data>p1->data）
{
r=1;
returnr;
break;
}
else
{
p1=p1->next;
p2=p2->next;
r=2;
}
}
}
returnr;
}
此函数实现的是判断俩个正数的大小。
考虑俩正数的在链表中所占存储单元的多少，多的一定大，当他们一样长时，一位一位的比较直到找到一个节点中的data比另一个链表的对应节点的data大为止。
如果最后仍是一样大那么这两个数就是一样大的。
返回值为自己约定的参数r等于2表示俩数一样大，等于1表示第二个数大，等于0表示第一个数大。
10.乘法函数：
voidmethod（DLNode*head1,DLNode*head2,intx）
{
voidminus（DLNode*head1,DLNode*head2,DLNode*head3）;
DLNode*temp1;
DLNode*temp2;
DLNode*temp3;
DLNode*temp4;
DLNode*temp5;
inte,z=0,i,j;
ListInitiate（&temp1）;
ListInitiate（&temp2）;
ListInitiate（&temp3）;
ListInsert（temp2,0,0）;
DLNode*p1,*p2;
p1=head1->prior;
p2=head2->prior;
for（i=0;iListInitiate（&temp4）;
ListInitiate（&temp5）;
ListInsert（temp4,0,0）;
while（p1!
=head1）
{
e=p1->data*p2->data+z;
if（e>9999）
{
z=e/10000;
e=e-z*10000;
}
elsez=0;
ListInsert（temp1,0,e）;
p1=p1->prior;
}
if（z!
=0）ListInsert（temp1,0,z）;
for（j=0;j{
ListInsert（temp1,ListLength（temp1）,0）;
}
add（temp1,temp2,temp3）;
temp1=temp4;
temp2=temp3;
temp3=temp5;
z=0;
p1=head1->prior;
p2=p2->prior;
}OutputNumber（temp2,x）;
}
此函数实现的是俩个整数的乘法运算。
模仿手算乘法，乘数的每一位分别和被乘数相乘得到的结果相加，注意的是在每次乘完相加时注意把低位的空缺补上0，以保证数据可以按位相加。
在每一位乘法时需要注意一定要加上低位的进位以及改变进位的值，这样才能保证每一位诚出来的结果是正确的。
11.减法函数：
voidminus（DLNode*head1,DLNode*head2,DLNode*head3）
{
intz=0,x=-1;
inte;
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;
}
}
elseif（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）;
p1=p1->prior;
}
head3->next->data=-1*head3->next->data;
}
else
{
head3->next->data=0;
}
}
此函数实现的是两个正数的减法运算。
整个函数分为俩大部分，第一部分处理第一个数大于第二个数，第而部分是处理第二个数大于第一个数。
在这个为题上我自己想了好长时间，感觉俩部分可以结合成一部分，但是由于本人的知识所限没有想出更好的办法，这使得代码量增加了足足一倍之多。
仍然模仿手算减法，先找到俩数字中最大的那个，用大的减去小的。
最后判断符号位。
12.整合八种情况函数：
voidyunsuan（DLNode*head1,DLNode*head2,DLNode*head3,charch）
{
DLNode*p1,*p2;
p1=head1->next;
p2=head2->next;
if（head1->data==1&&head2->data==1）
{
if（ch=='+'）add（head1,head2,head3）;
elseminus（head1,head2,head3）;
}
elseif（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）;
}
}
elseif（head1->data==0&&head2->data==1）
{
if（ch=='+'）
{
head1->next->data*=-1;
minus（head2,head1,head3）;
}
else
{
head1->next->data*=-1;
head2->next->data*=-1;
add（head1,head2,head3）;
head3->next->data*=-1;
}
}
else
{
if（ch=='+'）
{
head1->next->data*=-1;
head2->next->data*=-1;
add（head1,head2,head3）;
head3->next->data*=-1;
}
else
{
head1->next->data*=-1;
head2->next->data*=-1;
minus（head2,head1,head3）;
}
}
}
此函数实现的是八种情况的整合。
八种情况分别是正数加正数、正数加负数、正数减正数、正数减负数、负数加负数、负数加正数、负数减正数、负数减负数。
此函数调用已经做好的正数加正数和正数减正数函数判断符号位，根据一定的规则实现八种运算。
13.整合乘法运算函数：
voidchengfa（DLNode*head1,DLNode*head2）
{
inti;
if（（head1->next->data*head2->next->data）<0）
{
head1->next->data=abs（h
升级会员 