长整数四则运算.docx
《长整数四则运算.docx》由会员分享，可在线阅读，更多相关《长整数四则运算.docx（18页珍藏版）》请在冰豆网上搜索。
长整数四则运算
一试验目的和要求
1.实验目的
了解线性表的逻辑结构特性，熟练掌握线性表的链式存储结构，熟练掌握线性表在链式存储结构上实现基本操作：
查找，插入，删除的算法。
能在实际应用中选用适合的链表结构。
加深对链表的本质了解。
2.实验要求
利用双向链表实现长整数的存储，每个结点含一个整型变量。
设计一个实现任意长的整数进行四则运算的演示程序。
二实验环境萨大苏打sdasd
本程序可以在98/2000/XP下运行,可以用VC++6.0执行
三程序的逻辑框图
四,程序源代码
/*list.h*/
#include
#include
#include
#include
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineINFEASLBLE-1
#defineOVERFLOW-2
typedefintStatus;
typedefintElemType;
typedefstructDuLNode
{
ElemTypedata;
structDuLNode*prior,*next;
}DuLNode,*DuLinkList;
//构造一个空的双向循环线性表，L为头结点
StatusInitList_DuL（DuLinkList&L）;
//在L中确定第i个元素的位置指针p
DuLinkListGetElemP_DuL（DuLinkListL,inti）;
//在带头结点的双链循环线性表L中第i个位置之前插入元素e,
//i的合法值为1<=i<=ListLength_DuL（L）+1
StatusListInsert_DuL（DuLinkList&L,inti,ElemTypee）;
//删除带头结点的双链循环线性表L中第i个元素，i的合法值为1<=i<=ListLength_DuL（L）
StatusListDelete_DuL（DuLinkList&L,inti,ElemType&e）;
//若L为空表，则返回TRUE,否则返回FALSE
boolListEmpty_DuL（DuLinkListL）;
//线性表L已存在，返回L中数据元素个数
StatusListLength_DuL（DuLinkListL）;
//若线性表L已存在，将L置为空表
StatusClearList_DuL（DuLinkList&L）;
//销毁线性表L
StatusDestroyList_DuL（DuLinkList&L）;
//用e返回L中第i个数据元素的值
voidGetElem_DuL（DuLinkListL,inti,ElemType&e）;
//返回双向循环链表L中e出现的次数
intCounter_DuL（DuLinkListL,ElemTypee）;
//返回第n个e的在链表中位置n的合法值为0<=n<=Counter_DuL（L,n）
intPosition_DuL（DuLinkListL,intn,ElemTypee）;
/*function.cpp*/
#include"list.h"
/**************************************************************************************************/
/****************************函数声明**************************************************************/
/**************************************************************************************************/
DuLinkListcalculate（DuLinkListp,int*j,char*f,int*num,intk）;
voidoutput（DuLinkListr）;
DuLinkListPack_Up（DuLinkListr）;//整理链表r
voidexchange（DuLinkList&L,int&j）;
DuLinkListread_r（）;
voidoperate（DuLinkListp）;
voiddecride_d（）;
intcounter（inta）;//计算整数位数
intmax（int*num,intk）;//返回最大值
/*list.cpp*/
#include"list.h"
StatusInitList_DuL（DuLinkList&L）
{//构造一个空的双向循环线性表，L为头结点
L=（DuLinkList）malloc（sizeof（DuLNode））;
if（!
L）exit（OVERFLOW）;
L->next=L;
L->prior=L;
returnOK;
}//InitList_DuL
DuLinkListGetElemP_DuL（DuLinkListL,inti）
{//在L中确定第i个元素的位置指针p
DuLinkListp;
p=L;
for（intj=0;jp=p->next;
return（p）;
}//GetElemP_DuL
StatusListInsert_DuL（DuLinkList&L,inti,ElemTypee）
{//在带头结点的双链循环线性表L中第i个位置之后插入元素e,
//i的合法值为0<=i
DuLinkLists,p;
if（i<0）returnOVERFLOW;
else
{
p=GetElemP_DuL（L,i）;
if（!
（p））
returnERROR;
s=（DuLinkList）malloc（sizeof（DuLNode））;
if（!
s）returnERROR;
s->data=e;
s->prior=p;s->next=p->next;
p->next->prior=s;p->next=s;
returnOK;
}
}//ListInsert_DuL
StatusListDelete_DuL（DuLinkList&L,inti,ElemType&e）
{//删除带头结点的双链循环线性表L中第i个元素，i的合法值为1<=i<=ListLength_DuL（L）
DuLinkListp;
if（!
（p=GetElemP_DuL（L,i））||p==L）
returnERROR;
e=p->data;
p->prior->next=p->next;
p->next->prior=p->prior;
free（p）;
returnOK;
}//ListDelete_DuL
boolListEmpty_DuL（DuLinkListL）
{//若L为空表，则返回TRUE,否则返回FALSE
if（L->prior==L->next）returnTRUE;
elsereturnFALSE;
}//listElemty_DuL
StatusListLength_DuL（DuLinkListL）
{//线性表L已存在，返回L中数据元素个数
inti=0;
DuLinkListp=NULL;
for（p=L;p->next!
=L;p=p->next）
i++;
return（i）;
}//ListLength_DuL
StatusClearList_DuL（DuLinkList&L）
{//若线性表L已存在，将L置为空表
ElemTypee;
if（!
ListEmpty_DuL（L））
for（inti=1;i<=ListLength_DuL（L）;i++）
ListDelete_DuL（L,i,e）;
returnOK;
}//ClearList_DuL
StatusDestroyList_DuL（DuLinkList&L）
{//销毁线性表L
ElemTypee;
if（!
ListEmpty_DuL（L））
for（inti=1;i<=ListLength_DuL（L）;i++）
ListDelete_DuL（L,i,e）;
free（L）;
returnOK;
}//DestroyList_DuL
voidGetElem_DuL（DuLinkListL,inti,ElemType&e）
{//用e返回L中第i个数据元素的值
if（i<0||i>ListLength_DuL（L））
printf（"TheFunctionGetElem_Sq（）foundNothinginthisposition\n"）;
else
e=GetElemP_DuL（L,i）->data;
}//GetElem_DuL
intCounter_DuL（DuLinkListL,ElemTypee）
{//返回双向循环链表L中e出现的次数
inti;
DuLinkListp=NULL;
for（i=0,p=L;p->next!
=L;p=p->next）
if（p->data==e）i++;
returni+1;
}//Counter_DuL
intPosition_DuL（DuLinkListL,intn,ElemTypee）
{//返回第n个e的在链表中位置n的合法值为0inti,j;
DuLinkListp=NULL;
if（n<1||n>Counter_DuL（L,e））returnOVERFLOW;
else
{
for（i=0,j=0,p=L->next;p!
=L;p=p->next）
{
j++;
if（p->data==';'）i++;
if（i==n）break;
}
return（j）;
}//else
}//Position_DuL
/*decride.cpp*/
#include
voiddecride_d（）
{
printf（"*************************************************************\n"）;
printf（"*注意!
!
请严格按照国家对于长整数的表示习惯:
\n"）;
printf（"*即每四位一组;组间用\',\'隔开\';\'每个数以\";\"结束\n"）;
printf（"*否则可能导致系统运行出错!
!
!
\n"）;
printf（"**************************************************************\n"）;
printf（"输入N:
退出,按任意键继续,回车进行计算!
\n"）;
printf（"**************************************************************\n"）;
}
/*ExChange.cpp*/
#include"function.h"
#include
voidexchange（DuLinkList&L,int&j）
{
inti=0,sum=0;
DuLinkListt;
ElemTypee;
for（i=j,sum=0;i>0;i--）
{
t=GetElemP_DuL（L,ListLength_DuL（L））;
sum+=（（int）t->data-48）*（int）pow（10.0,（double）（j-i））;
ListDelete_DuL（L,ListLength_DuL（L）,e）;
}
ListInsert_DuL（L,ListLength_DuL（L）,sum）;
j=0;
}//exchange
/*Operration.cpp*/
#include"function.h"
/**************************************************************************************************/
/****************************操作函数operate（DuLinkList）******************************************/
/**************************************************************************************************/
voidoperate（DuLinkListp）
{
DuLinkListq;
intk=0,i=0,n=0;
k=Counter_DuL（p,';'）;
int*j=（int*）malloc（k*sizeof（int））;
char*f=（char*）malloc（k*sizeof（char））;
int*num=（int*）malloc（k*sizeof（int））;
for（i=0;ij[i-1]=Position_DuL（p,++i,';'）;
if（p->next->data=='-'）f[0]='-';//判断正负数
elsef[0]='+';
for（i=1;i{
if（GetElemP_DuL（p,j[i-1]）->next->data=='-'）
f[i]='-';
elsef[i]='+';
}
for（q=p,i=0;i{
n=0;
q=q->next;
for（;q!
=GetElemP_DuL（p,j[i]）;q=q->next）
if（q->data==','）n++;
num[i]=n+1;
}
output（Pack_Up（calculate（p,j,f,num,k）））;
free（j）;free（f）;free（num）;
DestroyList_DuL（p）;
}//operate
/*------------------------------------------------------------------------------------------------------*/
DuLinkListcalculate（DuLinkListp,int*j,char*f,int*num,intk）//计算
{
DuLinkListr;
intsum=0,i=0,t=0,m=0,ma=0,JW=0;
InitList_DuL（r）;
for（JW=0,m=0,ma=max（num,k）;m<=ma;m++）
{
for（i=0,sum=0;i{
if（num[i]<=0）;
else
{
t=（f[i]=='-'?
-1:
1）;
if（GetElemP_DuL（p,j[i]-1）->data==','）j[i]-=1;
sum+=t*GetElemP_DuL（p,j[i]-1）->data;
num[i]--;
}
}//for
for（i=i-1;i>=0;i--）
j[i]-=1;
if（（sum+JW）<10000&&（sum+JW）>-10000）{ListInsert_DuL（r,0,sum+JW）;JW=0;}
else{ListInsert_DuL（r,0,（sum+JW）%10000）;JW=（sum+JW）/10000;}
}//for
returnr;
}//calculate
/*------------------------------------------------------------------------------------------------------*/
DuLinkListPack_Up（DuLinkListr）//整理链表r
{
ElemTypee;
inti=0;
for（i=1;i{
if（GetElemP_DuL（r,1）->data==0）
ListDelete_DuL（r,1,e）;
elsebreak;
}//for清零。
if（GetElemP_DuL（r,1）->data<0）
{
GetElemP_DuL（r,0）->data='-';
for（i=ListLength_DuL（r）;i>0;i--）
GetElemP_DuL（r,i）->data*=（-1）;
}//if
for（i=ListLength_DuL（r）;i>1;i--）
{
if（GetElemP_DuL（r,i）->data<0）
{
GetElemP_DuL（r,i-1）->data--;
GetElemP_DuL（r,i）->data+=10000;
}
}//for
for（i=1;i{
if（GetElemP_DuL（r,1）->data==0）
ListDelete_DuL（r,1,e）;
elsebreak;
}//for清零。
returnr;
}//Pack_Up
/*------------------------------------------------------------------------------------------------------*/
voidoutput（DuLinkListr）
{
intx=0,i=0;
if（GetElemP_DuL（r,0）->data=='-'）printf（"-"）;
for（i=1;i<=ListLength_DuL（r）;i++）
{
if（i!
=1）
{
x=counter（GetElemP_DuL（r,i）->data）;
for（intj=0;j<4-x;j++）
printf（"0"）;
}
printf（"%d",GetElemP_DuL（r,i）->data）;
if（GetElemP_DuL（r,i）->next!
=r）printf（","）;
}//for
DestroyList_DuL（r）;
}//output
/*------------------------------------------------------------------------------------------------------*/
intmax（int*num,intk）//返回最大值
{
inti=0,a=0,b=0;
a=num[0];
b=num[1];
for（i=1;i{
if（a<=b）
a=b;
b=num[i+1];
}
returna;
}//max
/*------------------------------------------------------------------------------------------------------*/
intcounter（inta）//计算整数位数
{
if（1000<=a&&a<10000）return4;
elseif（100<=a&&a<1000）return3;
elseif（10<=a&&a<100）return2;
elseif（0<=a&&a<10）return1;
}//counter
/*Read.cpp*/
#include"function.h"
/**************************************************************************************************/
/****************************读入函数read_r（）******************************************************/
/**************************************************************************************************/
DuLinkListread_r（）
{
DuLinkListL;
ElemTypee;
inti=0,j=0,n=0;
InitList_DuL（L）;
for（j=0;（e=getchar（））!
='\n';）
{
if（e==','||e==';'）exchange（L,j）;
ListInsert_DuL（L,ListLength_DuL（L）,（int）e）;
if（e!
=','&&e!
=';'&&e!
='-'）++j;
}
return（L）;
}//read_r
/*main.cpp*/
#include"function.h"
#include
intmain（）
{
charch;
decride_d（）;
do
{
printf（"请输入长整数:
....\n"）;
operate（read_r（））;
printf（"\n"）;
system（"Pause"）;
decride_d（）;
fflush（stdin）;
}while（（ch=getch（））!
='N'&&ch!
='n'）;
return0;
}
五.实验数据和结果分析
六.总结
通过本实验，对链表的逻辑结构特性有一定的了解，对线性表的链式存储结构有比较深刻的印象
升级会员 