数据结构课程设计—一元多项式加法、减法、乘法运算的实现Word版

1.一元多项式加法、减法、乘法运算的实现

1.1设计内容及要求

1)设计内容

（1）使用顺序存储结构实现多项式加、减、乘运算。

例如：

10321058)(2456+-+-+=x x x x x x f ,x x x x x x g +--+=23451020107)(

求和结果：102220128)()(2356++-+=+x x x x x g x f

（2）使用链式存储结构实现多项式加、减、乘运算，

10305100)(1050100+-+=x x x x f ，x x x x x x g 320405150)(10205090+++-=

求和结果：1031040150100)()(102090100++-++=+x x x x x x g x f

2）设计要求

（1）用C 语言编程实现上述实验内容中的结构定义和算法。

（2）要有main()函数，并且在main()函数中使用检测数据调用上述算法。

（3）用switch 语句设计如下选择式菜单。

***************数据结构综合性实验****************

*******一、多项式的加法、减法、乘法运算**********

******* 1.多项式创建 **********

******* 2.多项式相加 **********

******* 3.多项式相减 **********

******* 4.多项式相乘 **********

******* 5.清空多项式 **********

******* 0.退出系统 **********

******* 请选择（0—5） **********

*************************************************

*请选择（0-5）:

1.2数据结构设计

根据下面给出的存储结构定义：

#define MAXSIZE 20 //定义线性表最大容量

//定义多项式项数据类型

typedef struct

{

float coef; //系数

int expn; //指数

}term,elemType;

typedef struct

{

term terms[MAXSIZE]; //线性表中数组元素

int last; //指向线性表中最后一个元素位置}SeqList;

typedef SeqList polynomial;

1.3基本操作函数说明

polynomial*Init_Polynomial();

//初始化空的多项式

int PloynStatus(polynomial*p)

//判断多项式的状态

int Location_Element(polynomial*p,term x)

在多项式p中查找与x项指数相同的项是否存在

int Insert_ElementByOrder(polynomial*p,term x)

//在多项式p中插入一个指数项x

int CreatePolyn(polynomial*P,int m)

//输入m项系数和指数，建立表示一元多项式的有序表p

char compare(term term1,term term2)

//比较指数项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相乘，生成一个新的多项式

void printPloyn(polynomial*p)

//输出在顺序存储结构的多项式p

1.4程序源代码

#include

#include

#include

#define NULL 0

#define MAXSIZE 20

typedef struct

{

float coef;

int expn;

}term,elemType;

typedef struct

{

term terms[MAXSIZE];

int last;

}SeqList;

typedef SeqList polynomial;

void printPloyn(polynomial*p);

int PloynStatus(polynomial*p)

{

if(p==NULL)

{

return -1;

}

else if(p->last==-1)

{

return 0;

}

else

{

return 1;

}

}

polynomial*Init_Polynomial()

{

polynomial*P;

P=new polynomial;

if(P!=NULL)

{

P->last=-1;

return P;

}

else

{

return NULL;

}

}

void Reset_Polynomial(polynomial*p)

{

if(PloynStatus(p)==1)

{

p->last=-1;

}

}

int Location_Element(polynomial*p,term x)

{

int i=0;

if(PloynStatus(p)==-1)

return 0;

while(i<=p->last && p->terms[i].expn!=x.expn) {

i++;

}

if(i>p->last)

{

return 0;

}

else

{

return 1;

}

}

int Insert_ElementByOrder(polynomial*p,term x) {

int j;

if(PloynStatus(p)==-1)

return 0;

if(p->last==MAXSIZE-1)

{

cout<<"The polym is full!"<

return 0;

}

j=p->last;

while(p->terms[j].expn=0)

{

p->terms[j+1]=p->terms[j];

j--;

}

p->terms[j+1]=x;

p->last++;

return 1;

}

int CreatePolyn(polynomial*P,int m)

{

float coef;

int expn;

term x;

if(PloynStatus(P)==-1)

return 0;

if(m>MAXSIZE)

{

printf("顺序表溢出\n");

return 0;

}

else

{

printf("请依次输入%d对系数和指数...\n",m);

for(int i=0;i

{

scanf("%f%d",&coef,&expn);

x.coef=coef;

x.expn=expn;

if(!Location_Element(P,x))

{

Insert_ElementByOrder(P,x);

}

}

}

return 1;

}

char compare(term term1,term term2)

{

if(term1.expn>term2.expn)

{

return'>';

}

else if(term1.expn

{

return'<';

}

else

{

return'=';

}

}

polynomial*addPloyn(polynomial*p1,polynomial*p2)

{

int i,j,k;

i=0;

j=0;

k=0;

if((PloynStatus(p1)==-1)||(PloynStatus(p2)==-1))

{

return NULL;

}

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++;

}

return p3;

}

polynomial*subStractPloyn(polynomial*p1,polynomial*p2)

{

int i;

i=0;

if((PloynStatus(p1)!=1)||(PloynStatus(p2)!=1))

{

return NULL;

}

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);

return p3;

}

polynomial*mulitPloyn(polynomial*p1,polynomial*p2)

{

int i;

int j;

int k;

i=0;

if((PloynStatus(p1)!=1)||(PloynStatus(p2)!=1))

{

return NULL;

}

polynomial*p3=Init_Polynomial();

polynomial**p=new polynomial*[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]);

}

}

return p3;

}

void printPloyn(polynomial*p)

{

int i;

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<

}

void menu()

{

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***********************************"<

void main()

{

int sel;

polynomial*p1=NULL;

polynomial*p2=NULL;

polynomial*p3=NULL;

while(1)

{

menu();

cout<<"\t\t*请选择(0-5):";

cin>>sel;

switch(sel)

{

case 1:

p1=Init_Polynomial();

p2=Init_Polynomial();

int m;

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;

case 2:

printf("p1+p2=");

if((p3=subStractPloyn(p1,p2))!=NULL)

printPloyn(p3);

break;

case 3:

printf("\np1-p2=");

if((p3=subStractPloyn(p1,p2))!=NULL)

printPloyn(p3);

break;

case 4:

printf("\np1*p2=");

if((p3=mulitPloyn(p1,p2))!=NULL)

printPloyn(p3);

case 5:

Reset_Polynomial(p1);

Reset_Polynomial(p2);

Reset_Polynomial(p3);

break;

case 0:

return;

}

}

return;

}

1.5程序执行结果