长整数四则运算加减法Word格式文档下载.docx

长整数四则运算加减法Word格式文档下载.docx

《长整数四则运算加减法Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《长整数四则运算加减法Word格式文档下载.docx（23页珍藏版）》请在冰豆网上搜索。

（4）1,0001,0001；

-1,0001,0001；

加法应输出“0”，减法应输出”2,0002,0002”。

（5）1,0001,0001；

-1,0001,0000；

加法应输出“1”，减法应输出”2,0002,0001”。

（6）-9999,9999,9999；

-9999,9999,9999；

加法应输出“1,9999,9999,9998”，减法应输出”0”。

（7）1,0000,9999,9999；

1；

加法应输出“1,0001,0000,0000”，减法应输出”1,0000,9999,9998”。

二、概要设计

1.设计思路：

（1）利用双向循环链表现实长整数的存储，每个结点中可以存放的最大整数为32767，才能保证两数相加不会溢出，但若这样存放，即相当于按32768进制存放，在十进制与32768进制数之间的转换十分不方便，故可以在每个结点中仅存十进制的4位，即不超过9999的非负整数，整个链表表示为万进制。

（2）可以利用头结点数据域的符号代表长整数的符号。

用其绝对值表示元素结点数目。

相加过程中不要破坏两个操作数链表。

两操作数的头指针存于指针数组中是简化程序结构的一种方法。

不能给长整数位数规定上限。

2.数据结构设计：

1）数据类型：

typedefintDataType;

//定义数据类型

typedefstructDoubleNode//定义链表元素

{

DataTypedata;

structDoubleNode*prior;

structDoubleNode*next;

}DLNode;

2）存储结构：

顺序结构，链式存储。

采用链式存储的方式会方便字符的读入和操作，且算法简单易懂。

3.软件结构设计：

1）初始化链表

voidInitNode（DLNode**head）

2）向链表第n个位置插入元素X

intInsertNode（DLNode*head,intn,DataTypex）

3）判断整数N有几位

intdigit（intn）

4）两数相加

voidadd（DLNode*h1,DLNode*h2）

5）两数相减

voidjian（DLNode*h1,DLNode*h2）

6）打印链表

voidPrintNode（DLNode*head）

7）删除链表

voidDestroyNode（DLNode**head）

8）主函数

intmain（）

三、详细设计

数据类型。

2.存储结构类型：

voidInitNode（DLNode**head）//初始化链表

{

if（（*head=（DLNode*）malloc（sizeof（DLNode）））==NULL）

exit

（1）;

（*head）->

prior=*head;

next=*head;

}

3.主函数和其他函数的伪码算法；

1.主函数：

intmain（）//主函数

{

DLNode*head1,*head2;

chardata1[N],data2[N];

chard1[10],d2[10];

inti,j,k;

intxun;

printf（"

提示：

较长的字符串数作为被加数，如果等长，则第一个数加第二个数\n\n"

）;

while

（1）

printf（"

输入数据：

\n"

scanf（"

%s%s"

data1,data2）;

InitNode（&

head1）;

head2）;

i=0;

k=0;

while（data1[i]!

='

;

'

）//将数1用链表储存

{

for（j=0;

j<

10;

j++）

d1[j]=0;

j=0;

&

data1[i]!

'

）

d1[j++]=data1[i++];

if（data1[i]=='

i++;

if（data1[0]=='

-'

）//处理正负数

j=-（int）fabs（atoi（d1））;

//atoi（）把字符串转换成整型数,头文件:

#include<

stdlib.h>

else

j=atoi（d1）;

InsertNode（head1,k++,j）;

}

k=0;

while（data2[i]!

）//将数2用链表储存

{

d2[j]=0;

j=0;

data2[i]!

d2[j++]=data2[i++];

if（data2[i]=='

）

i++;

if（data2[0]=='

）//处理正负数

j=-（int）fabs（atoi（d2））;

j=atoi（d2）;

InsertNode（head2,k++,j）;

选择加减法：

1—加法，0—退出\n"

%d"

&

xun）;

if（xun==0）

break;

switch（xun）

case1:

if（strlen（data1）>

=strlen（data2））//较长的数作为被加数

add（head1,head2）;

elseadd（head2,head1）;

break;

default:

break;

}

DestroyNode（&

printf（"

\n\n"

}

return0;

}

2.初始化链表：

3.向链表第n个位置插入元素X

intInsertNode（DLNode*head,intn,DataTypex）//向链表第n个位置插入元素X

DLNode*p,*nt;

inti=0;

p=head->

next;

while（p!

=head&

i<

n）//寻找插入位置

p=p->

i++;

if（i!

=n）

插入位置错误\n"

if（（nt=（DLNode*）malloc（sizeof（DLNode）））==NULL）

nt->

data=x;

prior=p->

prior;

prior->

next=nt;

next=p;

p->

prior=nt;

return1;

4.判断整数N有几位

intdigit（intn）//判断整数N有几位

inti;

for（i=1;

n/=10,i++）

if（n/10==0）

returni;

5.打印链表

voidPrintNode（DLNode*head）//打印链表

结果是：

"

DLNode*p=head->

while（p->

data==0）//去掉前面的一串0

p=p->

if（p==head）

0\n"

return;

p->

data）;

//最前面的一个数进行特殊处理,不用补零

=head）//打印后面的数字

"

if（p->

data==0）

0000"

continue;

}

for（i=0;

4-digit（p->

i++）//补零

0"

6.删除链表

DLNode*p,*p1;

p=（*head）->

=*head）

p1=p;

free（p1）;

free（p）;

head=NULL;

7.两数相加

inti=0,j=0;

DLNode*head3;

head3）;

DLNode*p1=h1->

prior,*p2=h2->

prior,*p3;

while（p1!

=h1&

p2!

=h2）//每个链表元素相加

i=p1->

data+p2->

data;

p1=p1->

p2=p2->

InsertNode（head3,j++,i）;

=h1）

InsertNode（head3,j++,p1->

p1=p1->

p3=head3->

while（p3!

=head3->

prior）//处理链表元素

if（p3->

data>

=10000）

p3->

next->

data+=p3->

data/10000;

p3->

data%=10000;

data<

0）//处理负数

if（head3->

prior!

=0）

{

p3->

data-=1;

data+=10000;

}

data=（int）fabs（p3->

p3=p3->

if（head3->

=10000）//处理最前面的数

InsertNode（head3,j,head3->

data/10000）;

head3->

=-10000）

head3->

data=（int）fabs（head3->

PrintNode（head3）;

}

8.两数相减

voidjian（DLNode*h1,DLNode*h2）

DLNode*head4;

head4）;

prior,*p4;

=h2）//每个链表元素相减

data-p2->

p2=p2->

InsertNode（head4,j++,i）;

InsertNode（head4,j++,p1->

p4=head4->

while（p4!

=head4->

if（p4->

p4->

data+=p4->

p4->

if（p4->

if（head4->

=0&

p4->

p4->

data=（int）fabs（p4->

p4=p4->

if（head4->

InsertNode（head4,j,head4->

head4->

head4->

data=（int）fabs（head4->

PrintNode（head4）;

4.主函数的程序流程图

四、调试分析

1.实际完成的情况说明

程序基本功已完成，包括：

输入长整型数字字符，用双向循环链表储存，计算两数之和、之差，输出值，删除链表，基本符合题目要求。

2.程序的性能分析

时间复杂度：

O（strlen（data1）+strlen（data2））

3.上机过程中出现的问题及其解决方案

1）双向循环链表指针指向错误

双向循环链表使用错误，指针顺序不对，参考教课书改正。

2）打印顺序错误

由于计算值储存顺序是从尾到头，开始误认为是从头到尾，修改指针指向改正。

3）中间计算值错误

中间计算值不足四位的应用0补足。

4）中间值小于0处理错误

中间值小于0但大于-100000的数应取绝对值，小于-10000的数应先借位，这个数加上10000后，再取绝对值

4.程序中可以改进的地方说明

两操作数的头指针存于指针数组中是简化程序结构的一种方法，但由于广泛使用指针易造成混乱，所以就放弃了，以后可以改进。

5.程序中可以扩充的功能及设计实现假想。

本程序可拓展到乘除运算，还有乘方和阶乘运算。

五、测试结果

●测试方法：

输入数据

●测试数据：

六、用户手册

本程序使用起来简单方便，只要按照菜单提示进行即可。

1.加法

1.输入0；

2.输入-2345,6789；

3.输入-9999,9999；

4.输入1,0001,0001；

5.输入1,0001,0001；

6.输入-9999,9999,9999；

7.输入1,0000,9999,9999；

2.减法

8.输入0；

后输入0退出

七、体会与自我评价

通过这次的课程设计，我进一步加深了对数据结构的理解。

这次课程设计我抽到的题目是长整数四则运算，长整数四则运算的功能比较单一，即输入两个长整数（数字字符和“，”和“；

”），每四个数字字符通过atoi（）函数转换成数字后储存在一个节点里，每两个对应的节点相加、相减后，生成一个新的节点来储存，然后对链表进行处理，可采用双向循环链表实现长整数的存储，主要原因是顺序表操作起来比较简单，算法较易理解，然后打印链表，最后删除链表，销毁头结点。

这次的课程设计我采用的是C语言编程语言，在编程过程中也遇到了很多问题，但经过努力调试修改，基本实现了长整数加法的基本功能。

通过这次课程设计我回顾了以前所学的编程知识，理解了学习完数据结构后的编程与以前编程方法上的不同。

在以往的编程方法上，我们习惯于是用数组和顺序的储存结构进行编程，这种方法在进行插入和删除是及为复杂不易实现。

但数据结构给我们提供了更多的不同的而且较为简单的编程方法，如链表，而且通过这次课程设计，我认识到了链表的许多优点。

通过这次编程我还学习到了一些新的知识，现如下总结：

1）把字符串转换成整型数函数：

atoi（）函数，它包含在头文件:

中。

2）双向循环链表的使用，使我对链表的储存结构有了全新的认识

3）再进行数据处理时应仔细分析

4）应仔细分析运算法则