计算机软件及应用课程设计实验报告长整型数四则运算.docx
- 文档编号:7516329
- 上传时间:2023-01-24
- 格式:DOCX
- 页数:26
- 大小:139.07KB
计算机软件及应用课程设计实验报告长整型数四则运算.docx
《计算机软件及应用课程设计实验报告长整型数四则运算.docx》由会员分享,可在线阅读,更多相关《计算机软件及应用课程设计实验报告长整型数四则运算.docx(26页珍藏版)》请在冰豆网上搜索。
计算机软件及应用课程设计实验报告长整型数四则运算
数据结构实验报告
题目:
长整型数四则运算
学院计算机学院
专业软件工程
年级班别2010级1班
成绩____________________
2012年7月1日
题目:
长整型数四则运算
一、实验概要
1、设计一个实现任意长的整数进行四则运算的程序。
2、输入和输出形式是按中国对于长整数的表示习惯,每四位一组,组间用逗号隔开,长整数位数没有上限,以分号结束长整型数据的输入。
3、程序执行的命令包括:
1)、输入长整数1;2)、输入长整数2;3)、输入执行的运算符;4)、计算并输出结果;5)、结束。
4、测试数据:
(以加法为例)
(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”.
二、实验目的
输入和输出形式是按中国对于长整数的表示习惯,每四位一组,组间用逗号隔开,长整数位数没有上限,以分号结束长整型数据的输入,进行计算
三、实验环境
VisualC++6.0
四、抽象数据类型的定义
1、双向循环链表的数据结构及操作定义如下:
typedefshortElemType;//定义基本数据类型,我们采用short来表示任意4位整数。
typedefstructDuCiLinkNode{//双向循环链表结点的存储结构
ElemTypedata;
structDuCiLinkNode*prior;//指向上一结点
structDuCiLinkNode*next;//指向下一结点
}DuCiLinkNode,*DuCiLinkList;//定义双向循环链表结点及链表的类型名
基本操作:
DuCiLinkNode*MakeNode(ElemTypee);//以4位整数e构造1个双向循环链表结点
StatusInitList(DuCiLinkList*L);//初始化1个双向循环链表,分配1个结点作头结点
//数据域赋初值0,上下结点指针指向自己
voidDestroyList(DuCiLinkList*L);//消毁1个双向循环链表,释放它所占用的所有内存空间
//并让链表*L指向NULL
voidClearList(DuCiLinkListL);//清除1个双向循环链表,释放数据结点所占用的内存空间
//保留头结点,并将数据域置为0,上下结点指针指向自己
StatusInsTail(DuCiLinkListL,ElemTypee);//在双向循环链表L的尾结点之后加入1个以e为
//数据域的新结点,并返回OK;否则返回ERROR。
StatusInsFirst(DuCiLinkListL,ElemTypee);
//将数据元素e插入在线性链表L头结点之后,并返回OK;否则返回ERROR。
StatusCopyList(DuCiLinkListL,DuCiLinkListC);
//将双向循环链表L复制到双向循环链表C中。
2、长整数的数据类型和和操作定义为:
typedefstructDuCiLinkNodeLongIntNode,*LongInt;//采用双向循环链表为实际的存储结构
voidadd(LongIntc,LongInta,LongIntb);//长整型数c=a+b
voidsub(LongIntc,LongInta,LongIntb);//长整型数c=a-b
Statusmul(LongIntc,LongInta,LongIntb);//长整型数c=a*b
voiddiv(LongIntc,LongInta,LongIntb);//长整型数c=a/b(整除)
voidfactorial(LongIntc,LongInta);//长整型数c=a!
(阶乘)
voidpower(LongIntc,LongInta,intn);//长整型数c=a^n(乘方)
CStringLongInttoCString(LongInta);//将LongInt型数a转化成CString
LongIntCStringtoLongInt(CStringa);//将CString型数a转化成LongInt
五、存储结构的定义
typedefshortElemType;
typedefstructDuCiLinkNode{//双向循环链表结点的存储结构
ElemTypedata;
structDuCiLinkNode*prior;//指向上一结点
structDuCiLinkNode*next;//指向下一结点
}DuCiLinkNode,*DuCiLinkList;
六、算法设计
1.DuCiLink.cpp
#include"DuCiLink.h"
DuCiLinkNode*MakeNode(ElemTypee)
{/*e为数据构造结点*/
DuCiLinkNode*s;
s=(DuCiLinkNode*)malloc(sizeof(DuCiLinkNode));
if(s)s->data=e;
returns;
}
StatusInitList(DuCiLinkList*L)
{/*初始化双向循环链表*/
(*L)=(DuCiLinkNode*)malloc(sizeof(DuCiLinkNode));
if(!
(*L))returnOVERFLOW;//存储分配失败
(*L)->data=0;
(*L)->prior=(*L);
(*L)->next=(*L);
returnOK;
}
voidDestroyList(DuCiLinkList*L)
{/*消毁双向循环链表,释放空间*/
DuCiLinkNode*p,*s;
p=(*L)->prior;
(*L)->prior=NULL;
while(p){s=p;p=p->prior;free(s);}
(*L)=NULL;
}
voidClearList(DuCiLinkListL)
{/*清除双向循环链表,释放空间,保留头结点*/
DuCiLinkNode*p,*s;
p=L->prior;
while(p!
=L){s=p;p=p->prior;free(s);}
L->data=0;
L->prior=L;
L->next=L;
}
StatusCopyList(DuCiLinkListL,DuCiLinkListC)
{/*将双向循环链表L复制到双向循环链表C中。
*/
DuCiLinkNode*p,*s;
C->data=L->data;
p=L->prior;
while(p!
=L)
{
s=(DuCiLinkNode*)malloc(sizeof(DuCiLinkNode));
if(!
s)returnOVERFLOW;//存储分配失败
s->data=p->data;
C->next->prior=s;
s->next=C->next;
s->prior=C;
C->next=s;
p=p->prior;
}
returnOK;
}
StatusInsTail(DuCiLinkListL,ElemTypee)
{/*在双向循环链表L的尾结点之后加入1个以e为
数据域的新结点,并返回OK;否则返回ERROR。
*/
DuCiLinkNode*s;
s=(DuCiLinkNode*)malloc(sizeof(DuCiLinkNode));
if(!
s)returnOVERFLOW;//存储分配失败
s->data=e;
s->prior=L->prior;
s->next=L;
L->prior->next=s;
L->prior=s;
returnOK;
}//InsTail
StatusInsFirst(DuCiLinkListL,ElemTypee)
{//将数据元素e插入在线性链表L头结点之后,并返回OK;否则返回ERROR。
DuCiLinkNode*s;
s=(DuCiLinkNode*)malloc(sizeof(DuCiLinkNode));
if(!
s)returnOVERFLOW;//存储分配失败
s->data=e;
L->next->prior=s;
s->next=L->next;
s->prior=L;
L->next=s;
returnOK;
}//InsTail
2.DuCiLink.h
typedefintStatus;
typedefshortElemType;
typedefstructDuCiLinkNode{//双向循环链表结点的存储结构
ElemTypedata;
structDuCiLinkNode*prior;//指向上一结点
structDuCiLinkNode*next;//指向下一结点
}DuCiLinkNode,*DuCiLinkList;
DuCiLinkNode*MakeNode(ElemTypee);//以4位整数e构造1个双向循环链表结点
StatusInitList(DuCiLinkList*L);//初始化1个双向循环链表,分配1个结点作头结点
voidDestroyList(DuCiLinkList*L);//消毁1个双向循环链表,释放空间并让链表*L指向NULL
voidClearList(DuCiLinkListL);//清除1个双向循环链表,释放空间,保留头结点
StatusInsTail(DuCiLinkListL,ElemTypee);//在双向循环链表L的尾结点之后加入1个以e为数据域的新结点,并返回OK;否则返回ERROR。
StatusInsFirst(DuCiLinkListL,ElemTypee);//将数据元素e插入在线性链表L头结点之后,并返回OK;否则返回ERROR。
StatusCopyList(DuCiLinkListL,DuCiLinkListC);//将双向循环链表L复制到双向循环链表C中。
3.LongInt.cpp
#include"LongInt.h"
StatusUnsignedAdd(LongIntc,LongInta,LongIntb)
{/*无符号数相加*/
shortsum,carry=0;//进位
LongIntNode*pa,*pb;
pa=a->prior;/*pa,pb分别指两个加数的尾结点*/
pb=b->prior;
while(pa!
=a&&pb!
=b)/*a和b中都有没加的组时,执行加法*/
{
sum=pa->data+pb->data+carry;
carry=sum/10000;/*进位*/
sum=sum%10000;/*当前组的数值*/
if(!
InsFirst(c,sum))returnERROR;/*加到和长整型数的首位*/
pa=pa->prior;
pb=pb->prior;
c->data++;
}
while(pa!
=a)/*a中还有没加的组时,补到和上去*/
{
sum=pa->data+carry;
carry=sum/10000;
sum=sum%10000;
if(!
InsFirst(c,sum))returnERROR;
pa=pa->prior;
c->data++;
}
while(pb!
=b)/*b中还有没加的组时,补到和上去*/
{
sum=pb->data+carry;
carry=sum/10000;
sum=sum%10000;
if(!
InsFirst(c,sum))returnERROR;
pb=pb->prior;
c->data++;
}
if(carry)/*如果还有进位*/
{
if(!
InsFirst(c,carry))returnERROR;
c->data++;
}
returnOK;
}
StatusUnsignedSub(LongIntc,LongInta,LongIntb)
{/*无符号数相减*/
shortdiff,borrow=0;
LongIntNode*pa,*pb,*pc,*s;
pa=a->prior;
pb=b->prior;
while(pa!
=a&&pb!
=b)
{
diff=pa->data-borrow-pb->data;
if(diff<0){borrow=1;diff+=10000;}elseborrow=0;
if(!
InsFirst(c,diff))returnERROR;
pa=pa->prior;
pb=pb->prior;
c->data++;
}
while(pa!
=a)
{
diff=pa->data-borrow;
if(diff<0){borrow=1;diff+=10000;}elseborrow=0;
if(!
InsFirst(c,diff))returnERROR;
pa=pa->prior;
c->data++;
}
if(borrow||pb!
=b)returnPleaseExchange;
/*不够减,提请调用程序交换a,b*/
pc=c->next;
while(pc->data==0&&pc->next!
=c)
{/*相减可能造成前几节数据为0,需要删除,结果为零时不能将0删除完*/
s=pc;pc=pc->next;
c->next=pc;
pc->prior=c;
free(s);
c->data--;
}
returnOK;
}
voidadd(LongIntc,LongInta,LongIntb)
{/*加法*/
if((a->data*b->data)>0)
{/*两数同号,则执行无符号加法,零为当成正数处理*/
UnsignedAdd(c,a,b);
c->data*=(a->data>=0)?
1:
-1;
}
else/*两数异号,则执行无符号减法*/
{/*总是用绝对值大的数减绝对小的数*/
if(UnsignedSub(c,a,b)==PleaseExchange)
{/*a不够b减,则交换a,b的顺序再减*/
ClearList(c);
UnsignedSub(c,b,a);
c->data*=(b->data>=0)?
1:
-1;
}
else/*a够b减*/
{
c->data*=(a->data>=0)?
1:
-1;
}
}
}
voidsub(LongIntc,LongInta,LongIntb)
{/*减法*/
b->data*=-1;
add(c,a,b);
b->data*=-1;
}
voidmul(LongIntc,LongInta,LongIntb)
{
longproduct,carry=0;//进位
shortsum;
LongIntNode*pa,*pb,*pcend,*pccur,*pc,*s;
pa=a->prior;/*从a的尾结点,即最后一个4位组开始*/
pcend=c;/*记录a的每一组与b相乘时最低位应加到积的哪一组之前*/
while(pa!
=a)/*只要a中还有结点未纳入运算,则循环*/
{
if(pa->data==0)/*如果a的当前4位组为0,则直接加0*/
{
InsFirst(c,0);
c->data++;
}
else
{
pccur=pcend->prior;/*记录乘数应加到积的哪一组*/
pb=b->prior;/*取b的每组与a的当前组相乘*/
while(pb!
=b)
{/*特别注意两个0-9999以内的数相乘需要用long来记录,否则会有溢出*/
product=carry+(long)pa->data*(long)pb->data;
carry=product/10000;/*进位*/
product=product%10000;/*余数,也即当前组的值*/
if(pccur==c)/*需要新的结点来存放数据*/
{
InsFirst(c,(short)product);
pccur=c->next;
c->data++;
}
else/*以前的运算已经插入过本4位组,则增加到当前组上*/
{
sum=pccur->data+(short)product;
if(sum>9999){carry++;sum-=10000;}
pccur->data=sum;
}
pccur=pccur->prior;/*移动乘积数的当前指针*/
pb=pb->prior;/*移动被乘数的当前指针*/
}/*如果还有进位,则加上去*/
if(carry>0)InsFirst(c,(short)carry);
carry=0;c->data++;/*清空进位器,并将4位数组数加1*/
}
pcend=pcend->prior;/*乘积数的最低位上移一组*/
pa=pa->prior;/*乘数上移一组*/
}
c->data*=((a->data*b->data)>=0)?
1:
-1;
pc=c->next;
while(pc->data==0&&pc->next!
=c)
{/*相乘可能造成前几节数据为0,需要删除,但结果为零时又不能将0删除完*/
s=pc;pc=pc->next;
c->next=pc;
pc->prior=c;
free(s);
c->data--;
}
}
voidAddn(LongIntc,shortn)
{/*一个正的长整型加一个最大为20000的正数*/
shortcarry=n,sum;
LongIntNode*pc;
pc=c->prior;
while(carry!
=0&&pc!
=c)
{
sum=pc->data+carry;
carry=sum/10000;
sum=sum%10000;
pc->data=sum;
pc=pc->prior;
}
while(carry!
=0)/*如果进位不为零说明需要新的结点*/
{
sum=carry;
carry=sum/10000;
sum=sum%10000;
InsFirst(c,sum);
c->data++;
}
}
Statusdiv(LongIntc,LongInta,LongIntb)/*整除*/
{
LongIntd,e;
shorti=0,EnoughSub;
shortadata=a->data,bdata=b->data;
if(b->data==1&&b->next->data==0)returnOVERFLOW;
if(a->data<0)a->data*=-1;
if(b->data<0)b->data*=-1;
InitList(&d);InitList(&e);/*使用临时长整型数*/
CopyList(a,e);/*e=a*/
EnoughSub=UnsignedSub(d,e,b);/*d=e-b*/
while(EnoughSub==OK)
{
i++;
if(i==20000)/*多次相减后再才保存*/
{
Addn(c,i);
i=0;
}
ClearList(e);CopyList(d,e);ClearList(d);
EnoughSub=UnsignedSub(d,e,b);
}
Addn(c,i);/*将最后的尾数补上*/
a->data=adata;b->data=bdata;
c->data*=((adata*bdata>=0)?
1:
-1);
DestroyList(&d);DestroyList(&e);
returnOK;
}
voidfactorial(LongIntc,LongInta)
{
LongIntb,d,e,start;
if((a->data==1||a->data==-1)&&(a->prior->data==1||a->prior->data==0)){InsFi
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 计算机软件 应用 课程设计 实验 报告 整型 四则运算