数据结构课程设计一元多项式加法减法乘法运算的实现Word版.docx
《数据结构课程设计一元多项式加法减法乘法运算的实现Word版.docx》由会员分享，可在线阅读，更多相关《数据结构课程设计一元多项式加法减法乘法运算的实现Word版.docx（25页珍藏版）》请在冰豆网上搜索。
数据结构课程设计一元多项式加法减法乘法运算的实现Word版
1.一元多项式加法、减法、乘法运算的实现
1.1设计内容及要求
1）设计内容
（1）使用顺序存储结构实现多项式加、减、乘运算。
例如：
求和结果：
（2）使用链式存储结构实现多项式加、减、乘运算，
，
求和结果：
2）设计要求
（1）用C语言编程实现上述实验内容中的结构定义和算法。
（2）要有main（）函数，并且在main（）函数中使用检测数据调用上述算法。
（3）用switch语句设计如下选择式菜单。
***************数据结构综合性实验****************
*******一、多项式的加法、减法、乘法运算**********
*******1.多项式创建**********
*******2.多项式相加**********
*******3.多项式相减**********
*******4.多项式相乘**********
*******5.清空多项式**********
*******0.退出系统**********
*******请选择（0—5）**********
*************************************************
*请选择（0-5）:
1.2数据结构设计
根据下面给出的存储结构定义：
#defineMAXSIZE20//定义线性表最大容量
//定义多项式项数据类型
typedefstruct
{
floatcoef;//系数
intexpn;//指数
}term,elemType;
typedefstruct
{
termterms[MAXSIZE];//线性表中数组元素
intlast;//指向线性表中最后一个元素位置
}SeqList;
typedefSeqListpolynomial;
1.3基本操作函数说明
polynomial*Init_Polynomial（）;
//初始化空的多项式
intPloynStatus（polynomial*p）
//判断多项式的状态
intLocation_Element（polynomial*p,termx）
在多项式p中查找与x项指数相同的项是否存在
intInsert_ElementByOrder（polynomial*p,termx）
//在多项式p中插入一个指数项x
intCreatePolyn（polynomial*P,intm）
//输入m项系数和指数，建立表示一元多项式的有序表p
charcompare（termterm1,termterm2）
//比较指数项term1和指数项term2
polynomial*addPloyn（polynomial*p1,polynomial*p2）
//将多项式p1和多项式p2相加，生成一个新的多项式
polynomial*subStractPloyn（polynomial*p1,polynomial*p2）
//多项式p1和多项式p2相减，生成一个新的多项式
polynomial*mulitPloyn（polynomial*p1,polynomial*p2）
//多项式p1和多项式p2相乘，生成一个新的多项式
voidprintPloyn（polynomial*p）
//输出在顺序存储结构的多项式p
1.4程序源代码
#include
#include
#include
#defineNULL0
#defineMAXSIZE20
typedefstruct
{
floatcoef;
intexpn;
}term,elemType;
typedefstruct
{
termterms[MAXSIZE];
intlast;
}SeqList;
typedefSeqListpolynomial;
voidprintPloyn（polynomial*p）;
intPloynStatus（polynomial*p）
{
if（p==NULL）
{
return-1;
}
elseif（p->last==-1）
{
return0;
}
else
{
return1;
}
}
polynomial*Init_Polynomial（）
{
polynomial*P;
P=newpolynomial;
if（P!
=NULL）
{
P->last=-1;
returnP;
}
else
{
returnNULL;
}
}
voidReset_Polynomial（polynomial*p）
{
if（PloynStatus（p）==1）
{
p->last=-1;
}
}
intLocation_Element（polynomial*p,termx）
{
inti=0;
if（PloynStatus（p）==-1）
return0;
while（i<=p->last&&p->terms[i].expn!
=x.expn）
{
i++;
}
if（i>p->last）
{
return0;
}
else
{
return1;
}
}
intInsert_ElementByOrder（polynomial*p,termx）
{
intj;
if（PloynStatus（p）==-1）
return0;
if（p->last==MAXSIZE-1）
{
cout<<"Thepolymisfull!
"<return0;
}
j=p->last;
while（p->terms[j].expn=0）
{
p->terms[j+1]=p->terms[j];
j--;
}
p->terms[j+1]=x;
p->last++;
return1;
}
intCreatePolyn（polynomial*P,intm）
{
floatcoef;
intexpn;
termx;
if（PloynStatus（P）==-1）
return0;
if（m>MAXSIZE）
{
printf（"顺序表溢出\n"）;
return0;
}
else
{
printf（"请依次输入%d对系数和指数...\n",m）;
for（inti=0;i{
scanf（"%f%d",&coef,&expn）;
x.coef=coef;
x.expn=expn;
if（!
Location_Element（P,x））
{
Insert_ElementByOrder（P,x）;
}
}
}
return1;
}
charcompare（termterm1,termterm2）
{
if（term1.expn>term2.expn）
{
return'>';
}
elseif（term1.expn{
return'<';
}
else
{
return'=';
}
}
polynomial*addPloyn（polynomial*p1,polynomial*p2）
{
inti,j,k;
i=0;
j=0;
k=0;
if（（PloynStatus（p1）==-1）||（PloynStatus（p2）==-1））
{
returnNULL;
}
polynomial*p3=Init_Polynomial（）;
while（i<=p1->last&&j<=p2->last）
{
switch（compare（p1->terms[i],p2->terms[j]））
{
case'>':
p3->terms[k++]=p1->terms[i++];
p3->last++;
break;
case'<':
p3->terms[k++]=p2->terms[j++];
p3->last++;
break;
case'=':
if（p1->terms[i].coef+p2->terms[j].coef!
=0）
{
p3->terms[k].coef=p1->terms[i].coef+p2->terms[j].coef;
p3->terms[k].expn=p1->terms[i].expn;
k++;
p3->last++;
}
i++;
j++;
}
}
while（i<=p1->last）
{
p3->terms[k++]=p1->terms[i++];
p3->last++;
}
returnp3;
}
polynomial*subStractPloyn（polynomial*p1,polynomial*p2）
{
inti;
i=0;
if（（PloynStatus（p1）!
=1）||（PloynStatus（p2）!
=1））
{
returnNULL;
}
polynomial*p3=Init_Polynomial（）;
p3->last=p2->last;
for（i=0;i<=p2->last;i++）
{
p3->terms[i].coef=-p2->terms[i].coef;
p3->terms[i].expn=p2->terms[i].expn;
}
p3=addPloyn（p1,p3）;
returnp3;
}
polynomial*mulitPloyn（polynomial*p1,polynomial*p2）
{
inti;
intj;
intk;
i=0;
if（（PloynStatus（p1）!
=1）||（PloynStatus（p2）!
=1））
{
returnNULL;
}
polynomial*p3=Init_Polynomial（）;
polynomial**p=newpolynomial*[p2->last+1];
for（i=0;i<=p2->last;i++）
{
for（k=0;k<=p2->last;k++）
{
p[k]=Init_Polynomial（）;
p[k]->last=p1->last;
for（j=0;j<=p1->last;j++）
{
p[k]->terms[j].coef=p1->terms[j].coef*p2->terms[k].coef;
p[k]->terms[j].expn=p1->terms[j].expn+p2->terms[k].expn;
}
p3=addPloyn（p3,p[k]）;
}
}
returnp3;
}
voidprintPloyn（polynomial*p）
{
inti;
for（i=0;i<=p->last;i++）
{
if（p->terms[i].coef>0&&i>0）
cout<<"+"<terms[i].coef;
else
cout<terms[i].coef;
cout<<"x^"<terms[i].expn;
}
cout<}
voidmenu（）
{
cout<<"\t\t*******数据结构综合性实验*********"<cout<<"\t\t***一、多项式的加、减、乘法运算***"<cout<<"\t\t*******1.多项式创建*********"<cout<<"\t\t*******2.多项式相加*********"<cout<<"\t\t*******3.多项式相减*********"<cout<<"\t\t*******4.多项式相乘*********"<cout<<"\t\t*******5.清空多项式*********"<cout<<"\t\t*******0.退出系统*********"<cout<<"\t\t******请选择（0-5）********"<cout<<"\t\t***********************************"<}
voidmain（）
{
intsel;
polynomial*p1=NULL;
polynomial*p2=NULL;
polynomial*p3=NULL;
while
（1）
{
menu（）;
cout<<"\t\t*请选择（0-5）:
";
cin>>sel;
switch（sel）
{
case1:
p1=Init_Polynomial（）;
p2=Init_Polynomial（）;
intm;
printf（"请输入第一个多项式的项数:
\n"）;
scanf（"%d",&m）;
CreatePolyn（p1,m）;
printf（"第一个多项式的表达式为p1="）;
printPloyn（p1）;
printf（"请输入第二个多项式的项数:
\n"）;
scanf（"%d",&m）;
CreatePolyn（p2,m）;
printf（"第二个多项式的表达式为p2="）;
printPloyn（p2）;
break;
case2:
printf（"p1+p2="）;
if（（p3=subStractPloyn（p1,p2））!
=NULL）
printPloyn（p3）;
break;
case3:
printf（"\np1-p2="）;
if（（p3=subStractPloyn（p1,p2））!
=NULL）
printPloyn（p3）;
break;
case4:
printf（"\np1*p2="）;
if（（p3=mulitPloyn（p1,p2））!
=NULL）
printPloyn（p3）;
case5:
Reset_Polynomial（p1）;
Reset_Polynomial（p2）;
Reset_Polynomial（p3）;
break;
case0:
return;
}
}
return;
}
1.5程序执行结果
2.迷宫问题实现
2.1设计内容及要求
1）设计内容
以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。
设计一个程序，对任意设定的迷宫，求出一条从入口到出口的道路，或得出没有通路的结论。
2）设计要求
（1）用C语言编程实现上述实验内容中的结构定义和算法；
（2）要有main（）函数，并且在main（）函数中使用检测数据调用上述算法；
2.2数据结构设计
根据以上问题给出存储结构定义：
typedefstruct//定义坐标
{
intx;
inty;
}item;
//定义坐标和方向
typedefstruct
{
intx;
inty;
intd;
}dataType;
//定义顺序栈的类型定义
typedefstruct
{
dataTypedata[MAXLEN];
inttop;
}SeqStack;
itemmove[8];//8邻域试探方向数组
intmaze[M+2][N+2]={
{1,1,1,1,1,1,1,1,1,1},
{1,0,1,1,1,0,1,1,1,1},
{1,1,0,1,0,1,1,1,1,1},
{1,0,1,0,0,0,0,0,1,1},
{1,0,1,1,1,0,1,1,1,1},
{1,1,0,0,1,1,0,0,0,1},
{1,0,1,1,0,0,1,1,0,1},
{1,1,1,1,1,1,1,1,1,1},
};//定义迷宫数组，0表示有路径，1表示不存在路径
2.3基本操作函数说明
voidprint_Path（SeqStack*s）;
//输出迷宫路线
SeqStack*InitSeqStack（）
//该函数初始化一个空栈，并返回指向该栈的存储单元首地址
intPush（SeqStack*s,dataTypex）
//将元素x入栈s,若入栈成功返回结果1；否则返回0
intStackEmpty（SeqStack*s）
//该函数判断栈是否为空，若栈空返回结果1；否则返回0
intPop（SeqStack*s,dataType*x）
//将栈顶元素出栈，放入x所指向的存储单元中，若出栈返回结果1；否则返回0
voidinit_move（itemmove[8]）
//初始化8邻域方向
intfind_Path（intmaze[M+2][N+2],itemmove[8]）
//在迷宫maze二维数组中按move的8邻域方向探测迷宫路线，存在返回1，否则返回0
voidprint_Path（SeqStack*s）
//输出栈s中所有迷宫路径
2.4程序源代码
#include
#include
#defineM6
#defineN8
#defineMAXLEN100
typedefstruct
{
intx;
inty;
}item;
typedefstruct
{
intx;
inty;
intd;
}dataType;
typedefstruct
{
dataTypedata[MAXLEN];
inttop;
}SeqStack;
itemmove[8];
intmaze[M+2][N+2]={
{1,1,1,1,1,1,1,1,1,1},
{1,0,1,1,1,0,1,1,1,1},
{1,1,0,1,0,1,1,1,1,1},
{1,0,1,0,0,0,0,0,1,1},
{1,0,1,1,1,0,1,1,1,1},
{1,1,0,0,1,1,0,0,0,1},
{1,0,1,1,0,0,1,1,0,1},
{1,1,1,1,1,1,1,1,1,1},
};
voidprint_Path（SeqStack*s）;
SeqStack*InitSeqStack（）
{
SeqStack*s;
s=newSeqStack;
s->top=-1;
returns;
}
intPush（SeqStack*s,dataTypex）
{
if（s->top==MAXLEN-1）
return0;
else
{
s->top++;
s->data[s->top]=x;
return1;
}
}
intStackEmpty（SeqStack*s）
{
if（s->top==-1）
return1;
else
return0;
}
intPop（SeqStack*s,dataType*x）
{
if（StackEmpty（s））
return0;
else
{
*x=s->data[s->top];
s->top--;
return1;
}
}
voidinit_move（itemmove[8]）
{
move[0].x=0;
move[0].y=1;
move[1].x=1;
move[1].y=1;
move[2].x=1;
move[2].y=0;
move[3].x=1;
move[3].y=-1;
move[4].x=0;
move[4].y=-1;
move[5].x=-1;
move[5].y=-1;
move[6].x=-1;
move[6].y=0;
move[7].x=-1;
move[7].y=1;
}
voidprintS（dataTypetemp）
{
intstatici=0;
printf（"第%d次入栈元素为:
",++i）;
printf（"（%d,%d）%d\n",temp.x,temp.y,temp.d）;
}
intfind_Path（intmaze[M+2][N+2],itemmove[8]）
{
SeqStack*s=InitSeqStack（）;
dataTypetemp;
intx,y,d,i,j;
temp.x=1;
temp.y=1;
temp.d=-1;
Push（s,temp）;
while（!
StackEmpty（s））
{
Pop（s,&temp）;
x=temp.x;
y=temp.y;
d=temp.d+1;
while（d<8）
{
i=x+move[d].x;
j=y+move[d].y;
if（maze[i][j]==0）
{
temp.x=x;
temp.y=y;
temp.d=d;
Push（s,temp）;
printS（temp）;
x=i;
y=j;
maze[x][y]=-1;
if（x==M&&y==N）
{
print_Path（s）;
return1;
}
else
d=0;
}
else
d++;
}
}
return0;
}
voidprint_Path（SeqStack*s）
{
printf（"迷宫路径为:
\n"）;
for（inti=0;itop;i++）
升级会员 