数据结构课程设计报告长整数运算Word文档下载推荐.docx
《数据结构课程设计报告长整数运算Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《数据结构课程设计报告长整数运算Word文档下载推荐.docx（18页珍藏版）》请在冰豆网上搜索。
InitLinkList（&
L,a）操作结果：
构造一个双向循环链表L，用a判断是正数还是负数DestroyList（&
L）
初始条件：
双向循环两已经存在操作结果：
销毁有序表L
Insert（&
L,a）初始条件：
双向循环链表已经存在操作结果：
在循环链表的末尾插入一个结点，且此结点的数据值为aHeadInsert（&
L,a）
在循环链表的头结点后插入一个结点，且此结点的数据值为aCountNode（&
双向循环链表存在操作结果：
计算出链表中结点的个数，并返回个数
Compare（&
L1,&
L2）初始条件：
L1和L2存在操作结果：
比较两个双向循环链表的大小，用返回值1表示L1大于L2,返回值-1标志
L1小于L2,返回值0标志L1和L2相等
ToNum（*s,i,&
e）
s为字符串中指向某个字符的指针操作结果：
将s的前i个字符转换为数字，存入e中CreatNum（&
L,&
s）
s为某个字符串，双向循环链表L存在操作结果：
将字符串s转换成数字存入到循环链表L中Add（L1，L2,op）
双向循环链表L1和L2存在，op为结果的标识符操作结果：
两个链表相加，求出结果。
Sub（L1,L2,op）初始条件：
双向循环链表L1和L2存在操作结果：
L1减去L2,求出结果，op为结果的标识符EraseZero（Link&
双向循环链表L存在
操作结果：
删去L链表头结点后，第一个数据不为零结点前的所有数据为零的结点。
如果结点数据都为零，则保存一个结点。
print（L）
双向循环链表L存在操作结果：
从L头结点开始顺此打印每个结点中的数据
3.软件结构设计：
本程序包含四个模块：
1.主程序模块
Intmain（）
接受命令
While（“命令”!
=“退出”）
输入字符串
建立双向循环链表
将字符串转换为要求的格式存入链表的每个结点
对链表中数据进行即兴操作数理再次接受命令
2.双向链表操作模块------实现结点的插入、删除、修改
3.字符串转换存储模块----实现将字符串转换为数字按格式存储在链表中
4.数据计算模块一——对存储在链表中的数据进行计算，得到最终期望的结果各个模块调用的关系如下：
主程序模块中的函数原型：
voidInterface（）操作界面函数
StatusCreatNum（Link&
L,char*s）----创建数字链表函数
LinkCompute（Link&
L1,Link&
L2,charOpe）----数据计算函数
数据运算模块：
LinkAdd（Link&
L2,charop）----加法计算
LinkSub（Link&
L2,charop）----减法运算
双向链表操作模块
voidInitLinkList（Link&
L,chara）
StatusDestroyList（Link&
StatusInsert（Link&
L,Elemtypea）
intCountNode（LinkL）
BOOLCompare（Link&
L1,Link&
L2）
voidEraseZero（Link&
StatusHeadInsert（Link&
L,Elemtypea）
字符串转换模块
StatusCreatNum（Link&
L,char*s）
StatusToNum（char*s,inti,long&
人机界面：
三、详细设计
仁根据分析和链表操作的特点，采用双向循环链表实现，这里头结点存储数字的符号typedeflongElemtype;
typedefintStatus;
typedefintBOOL;
typedefstructLNode{
Elemtypedata;
LNode*next;
LNode*prior;
}Node,*Link;
voidInitLinkList（Link&
L,chara）{
//对一个双向循环链表进行初始化，分配头结点
L=（Link）malloc（sizeof（Node））;
//动态分配存储空间
If（!
L）returnFALSE;
if（a=='
-'
）L->
data=-1;
//L->
data存放符号节点，如果是‘-'
则为，否则为0
elseL->
data=1;
L->
prior=L;
next=L;
L）{
//销毁链表L
if（!
L）returnERROR;
//链表不存在
p=L->
prior;
//p指向链表头节点的前驱
while（p!
=L）//删除节点节点p
q=p->
free（p）;
//释放节点p的空间
p=q;
free（L）;
//释放链表L的存储空间
returnOK;
L,Elemtypea）{
//分配一个结点，并将其数据值存为a,插入到链表的末尾
p=（Link）malloc（sizeof（LNode））;
p）
exit（OVERFLOW）;
p->
next=p->
prior=NULL;
data=a;
Linkq=L->
q->
next=p;
prior=q;
p->
next=L;
L->
prior=p;
StatusHeadInsert（Link&
//分配一个结点，并将其数据值存为a，按头插入法插入
if（!
p）exit（OVERFLOW）;
next;
q->
next=q;
prior=L;
StatusToNum（char*s,inti,long&
e）{
//将字符串s的前i位转换为正数，并由sum=0;
e保存
的值每次是原来的10倍
for（m=1,n=1;
m<
=i;
n=n*10）//n
m++;
e=sum;
StatusCreatNum（Link&
L,char*s）{
//将字符串转分割成很多部分，每部分转换为数字后存在一个链表结点中。
InitLinkList（L,s[0]）;
if（*s=='
）
{InitLinkList（L,s[0]）;
s++;
else
InitLinkList（L,s[0]）;
while（*s!
='
\0'
if（*s=='
'
）
{ToNum（s,i,e）;
Insert（L,e）;
i=-1;
//因为这是已经将某一个逗号前i个字符变成数字加入
}//数字链表中，逗号不算本次
i++;
s++;
ToNum（s,i,e）;
intCountNode（LinkL）{
//计算链表L的结点数
Linkp=L->
=L）
p=p->
returni;
L2）{
//比较链表L1和L2的大小，如果L1大于L2,返回1,如果L2大于L1,返回-1,如果相等，返回0{
if（CountNode（L1）>
CountNode（L2））
//L1大于L2
elseif（CountNode（L1）<
L2大于L1
else{
p1=L1->
next,p2=L2->
next;
while（p1!
=L1&
&
p2!
=L2）
if（p1->
data>
p2->
data）
data<
return-1;
p1=p1->
next;
p2=p2->
L1和L2相等
L2,charop）主要函数
//将字符串L1和L2的数据相加，得到的结果链表头结点指针返回
Intc=0,temp
Linkp1,p2,p3
p1=p1_>
prior,p2=p2_>
prior
InitLinkList（L3）
p1!
p2!
=L2
Temp=p1->
data+p2->
data+c
是否temp>
=10000
是
否
temp=temp-10000
HeadInsert（L3,temp）c=0
HeadInsert（L3,temp）c=1
P1=p1->
priorp2=p2>
=L1
temp=p1->
data+cc=temp/10000
HeadInsert（L3,temp）
p1=p1->
temp=p2->
p2=p2_>
是否c=1
HeadInsert（L3,c）
LinkSub（LinkL1,LinkL2,charop）主要函数
//将字符串L1和L2的数据相减，得到的结果链表的头结点指针返回
InitLinkList（L3）
data-p2->
data-c
是否tempvO
temp=temp+10000
priorp2=p2_>
temp=temp+10000c=1
是否
{//删除链表L的无效零元素结点
p=L->
next,q;
while（p->
data==0&
next!
=L）{
q=p;
p_>
prior=q_>
free（q）;
next=p;
LinkCompute（Link&
L2,charOpe）//主要函数
//对链表L1和链表L2进行计算，即相加，相减等等
EraseZero（L1）EraseZero（L2）
p1=L1->
priorp2=L2->
op='
+'
L1->
data==1&
L2->
data==1
L3=Add（L1丄2,'
+'
data==-1&
data==1
是否L1和L2相等
L3=
Sub（L1,L2,'
'
是否L1大于L2
L3=Sub
（L1,L2，'
-
L3=Sub（L2丄1,'
data
==-1
Sub（L1,L2,'
+
Sub（L2,L1,'
data==-11&
data==-1
L3=Add（L1，L2,'
c
L3=Sub（L1,L2,'
L3=Sub（L2,L1,'
L3=Add（L1丄2,'
）;
L3=Add（L1丄2,'
data==-1
L3=Sub（L1,L2,'
L3=Sub（L2,L1,'
voidInterface（）
//界面函数，显示操作的主界面
Statusprint（LinkL）{
//顺次打印链表L中的数据
EraseZero（L）;
//第一个不是数字也不是-，则出错
if（*s<
48&
*s!
='
||*s>
57）
returnERROR;
if（*s=='
）k=0;
elsek=1;
i=1;
while（*（s+i）!
if（*（s+i）!
（*（s+i）>
57||*（s+i）<
48））returnERROR;
*（s+i）!
）{
k++;
if（k>
5）
if（*（s+i）=='
k=4;
if（k!
=4）
//此时逗号字符不能在四个数字的计算之中
//最后一个逗号后必须有四个数
k=-1;
函数调用关系图：
main
四、调试分析
1.实际完成的功能有：
长整数的加法和减法，支持的数据类型是整形，能够对异常输入进行判断，打印和计算的时候能够消除可能出现的前置零。
2.程序的主要函数compute时间复杂度为0（n），其实n为计算的两个链表的结点个数的较大值。
物理存储使用的是双向链表，有两个指针域，空间消耗在合理范围之内
3.调试中由于是双向链表，在插入时应该注意将prior域进行考虑，刚开始写程序时忘记，
导致输出结果错误。
清楚前置零的时候开始没有考虑输入数据全是零的时候，结果将全部的
数据结点都给删除，最后没有结果输出，调试中发现这个问题，应该将每个链表至少保存一个数据结点。
4.由于时间仓促，而且长整数四则运算的乘法一直没有想到好的办法，如果再有几天时间，
乘法这个功能完全可以加上。
随之就可以完成乘方的计算
5.本程序还有很大的扩充地方，应该可以将程序由正数扩充为浮点数，能够运行更复杂的
数据，如求阶乘，开方等功能。
如果实现了，则这个计算器的功能方面就可以和windows
系统自带的计算器媲美了。
五、测试结果
列出你的测试结果，包括输入和输出。
注意测试数据应该完整和严格，至少给出2
组测试结果（含合法数据与非法数据）。
输入0;
0，输出0
输入1,0001,0001;
-1,0001,0001;
输出0
输入1,0001,0001；
-1,0001,0000;
输出1
输入-9999,9999；
-9999；
9999;
输出-1,9999,9998
非法数据
1,000;
000,1;
输出“输入错误”
六、用尸手册
说明如何使用你编写的程序，详细列出每一步的具体操作步骤。
这里可以有适当的
运行结果抓图。
用户手册与开发过程无关，只与使用有关，必须是StepbyStep的。
所有运行结果截图均要求有实际数据的内容，截图尺寸要求按页宽排版两张大小，且要求有每张图下面有规范的标题说明如何使用你编写的程序，详细列出每一步的操作
步骤。
1.进入操作主界面
2
3＞退岀
2•按照命令提示操作
⑴选1，进入加法运算
两个数的加法操作•输入两个数格式是•為一个数
1输入第一个操作数：
并且按照提示格式输入
如果输入错误，比如1,000，则程序会提示错误，重新输入
2如果输入正确，比如输入1,0000，输入下一个数
3输入正确，如输入9999,9999则计算出结果
4输出每个链表中的结点值，便于观察比较
5输出结果1,0000,9999
⑵选2，进入减法运算
I賁两个数的加法操作-输入两个数了入格式是****洛一个数
1输入第一个操作数，并按照提示的格式输入
如果输入错误，比如，10,000，程序会提示输入错误，重新输入
2如果输入正确，比如9999,9999，输入下一个数。
3第二个数也输入正确，比如输入10,0000，输出结果
4提示是否继续计算，选择丫或者y退出，其他任意键继续操作
是否结東？
S退出「其他任意犍继续
七、体会与自我评价
长整数四则运算的一些思考
这次的课程设计中，长整数四则运算这个实验给了我很大的挑战，在设计中遇到了很多
的困难，比如如何用如何将字符数据分割成很多部分存储进双向循环链表，如何判断输入的
字符串是否是正确的；
在输入特殊数据买比如0000,00000时，程序能够消除无用的前置零得出正确的结果，我在这些问题上都考虑的很久，一点点的攻破难题，
而在这次实验中我对长正数的各种运算也有了一定的认识，对于特别长的数的计算，只
能先求局部结果，最后将局部结果综合起来，得到最终结果。
比如加法就是从最低位开始计
算，判断进位后再一次向高位计算，最终得到结果。
计算加法的时候，由于是每四位一个结
点，所以是以万位为进制。
输出时如果一个结点中数据是以为，则前面输出三个零，如果是两位，则输出两个零，如果是三位，则输出一个零，四位数直接输出。
如果节点数据为零，则按第一种情况输出是前面加三个零即可。
为了程序的健壮性，应该考虑负数和正数相加的
情况，如果一个较大的正数加上一个数值较小的负数，应该是大数减去去掉振幅符号的小数，
即可。
如果是一个较小的正数加上一个数值较大的负数，则应该是去掉正负号的负数减去正
数，最后在结果里加上一个负号即可。
乘法的基本思想是相加，但是在双向循环链表中，如果乘数很大的时候，单纯的相加要进行很多次，效率上完全不够满足要求，一般是用字符串直接按位相乘，按竖式结构计算。
除法的实现可以用减法，但是问题还是和乘法一样，如果数字太大的话，用双向循环链表，要进行的减法次数也是很庞大的。
以上是我对长整数四则运算的一点思考，本次实验中学到的很多的知识，对循环链表的
操作也更加的熟悉，更让我增长了许多的编程经验，我相信以后的编程学习中我会表现的更加出色。
升级会员 