长整数四则运算Word格式文档下载.docx
《长整数四则运算Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《长整数四则运算Word格式文档下载.docx（18页珍藏版）》请在冰豆网上搜索。
StatusListInsert_DuL（DuLinkList&
L,inti,ElemTypee）;
//删除带头结点的双链循环线性表L中第i个元素，i的合法值为1<
=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
StatusDestroyList_DuL（DuLinkList&
//用e返回L中第i个数据元素的值
voidGetElem_DuL（DuLinkListL,inti,ElemType&
//返回双向循环链表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*/
L）
{//构造一个空的双向循环线性表，L为头结点
L=（DuLinkList）malloc（sizeof（DuLNode））;
if（!
L）exit（OVERFLOW）;
L->
next=L;
prior=L;
returnOK;
}//InitList_DuL
DuLinkListGetElemP_DuL（DuLinkListL,inti）
{//在L中确定第i个元素的位置指针p
DuLinkListp;
p=L;
for（intj=0;
j<
i;
j++）
p=p->
next;
return（p）;
}//GetElemP_DuL
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））;
s）returnERROR;
s->
data=e;
prior=p;
s->
next=p->
p->
next->
prior=s;
p->
next=s;
returnOK;
}
}//ListInsert_DuL
e）
{//删除带头结点的双链循环线性表L中第i个元素，i的合法值为1<
（p=GetElemP_DuL（L,i））||p==L）
returnERROR;
e=p->
data;
p->
prior->
prior=p->
prior;
free（p）;
}//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;
next!
=L;
p=p->
next）
i++;
return（i）;
}//ListLength_DuL
{//若线性表L已存在，将L置为空表
ElemTypee;
ListEmpty_DuL（L））
for（inti=1;
i<
=ListLength_DuL（L）;
i++）
ListDelete_DuL（L,i,e）;
}//ClearList_DuL
{//销毁线性表L
free（L）;
}//DestroyList_DuL
{//用e返回L中第i个数据元素的值
0||i>
ListLength_DuL（L））
printf（"
TheFunctionGetElem_Sq（）foundNothinginthisposition\n"
）;
e=GetElemP_DuL（L,i）->
}//GetElem_DuL
intCounter_DuL（DuLinkListL,ElemTypee）
{//返回双向循环链表L中e出现的次数
inti;
for（i=0,p=L;
if（p->
data==e）i++;
returni+1;
}//Counter_DuL
intPosition_DuL（DuLinkListL,intn,ElemTypee）
{//返回第n个e的在链表中位置n的合法值为0<
n<
inti,j;
if（n<
1||n>
Counter_DuL（L,e））returnOVERFLOW;
else
for（i=0,j=0,p=L->
p!
{
j++;
if（p->
data=='
;
'
）i++;
if（i==n）break;
}
return（j）;
}//else
}//Position_DuL
/*decride.cpp*/
voiddecride_d（）
printf（"
*************************************************************\n"
*注意!
!
请严格按照国家对于长整数的表示习惯:
\n"
*即每四位一组;
组间用\'
\'
隔开\'
\'
每个数以\"
\"
结束\n"
*否则可能导致系统运行出错!
**************************************************************\n"
输入N:
退出,按任意键继续,回车进行计算!
\n"
}
/*ExChange.cpp*/
function.h"
math.h>
j）
inti=0,sum=0;
DuLinkListt;
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*/
/****************************操作函数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;
k;
）//分号的位置
j[i-1]=Position_DuL（p,++i,'
if（p->
-'
）f[0]='
//判断正负数
elsef[0]='
+'
for（i=1;
if（GetElemP_DuL（p,j[i-1]）->
）
f[i]='
elsef[i]='
for（q=p,i=0;
n=0;
q=q->
for（;
q!
=GetElemP_DuL（p,j[i]）;
q=q->
if（q->
'
）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;
if（num[i]<
=0）;
else
{
t=（f[i]=='
?
-1:
1）;
if（GetElemP_DuL（p,j[i]-1）->
）j[i]-=1;
sum+=t*GetElemP_DuL（p,j[i]-1）->
num[i]--;
}
}//for
for（i=i-1;
=0;
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
ListLength_DuL（r）;
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）;
GetElemP_DuL（r,i）->
data*=（-1）;
}//if
for（i=ListLength_DuL（r）;
1;
if（GetElemP_DuL（r,i）->
GetElemP_DuL（r,i-1）->
data--;
data+=10000;
}//Pack_Up
/*------------------------------------------------------------------------------------------------------*/
voidoutput（DuLinkListr）
intx=0,i=0;
if（GetElemP_DuL（r,0）->
）printf（"
-"
=ListLength_DuL（r）;
if（i!
=1）
x=counter（GetElemP_DuL（r,i）->
data）;
for（intj=0;
4-x;
printf（"
0"
%d"
GetElemP_DuL（r,i）->
=r）printf（"
"
DestroyList_DuL（r）;
}//output
intmax（int*num,intk）//返回最大值
inti=0,a=0,b=0;
a=num[0];
b=num[1];
if（a<
=b）
a=b;
b=num[i+1];
returna;
}//max
intcounter（inta）//计算整数位数
{
if（1000<
=a&
a<
10000）return4;
elseif（100<
1000）return3;
elseif（10<
100）return2;
elseif（0<
10）return1;
}//counter
/*Read.cpp*/
/****************************读入函数read_r（）******************************************************/
DuLinkListread_r（）
DuLinkListL;
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!
）++j;
return（L）;
}//read_r
/*main.cpp*/
conio.h>
intmain（）
charch;
decride_d（）;
do
请输入长整数:
....\n"
operate（read_r（））;
system（"
Pause"
fflush（stdin）;
}while（（ch=getch（））!
N'
ch!
n'
return0;
五.实验数据和结果分析
六.总结
通过本实验，对链表的逻辑结构特性有一定的了解，对线性表的链式存储结构有比较深刻的印象
升级会员 