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

一、设计题目一元多项式的加法、减法、乘法的实现。
二、主要内容设有一元多项式A m(x)和B n(x).A m(x)=A0+A1x1+A2x2+A3x3+… +A m x mB n(x)=B0+B1x1+B2x2+B3x3+… +B n x n请实现求M(x)= A m(x)+B n(x)、M(x)= A m(x)-B n(x)和M(x)= A m(x)×B n(x)。
要求:1) 首先判定多项式是否稀疏2) 采用动态存储结构实现;3) 结果M(x)中无重复阶项和无零系数项;4) 要求输出结果的升幂和降幂两种排列情况三、具体要求及应提交的材料1.每个同学以自己的学号和姓名建一个文件夹,如:“312009*********张三”。
里面应包括:学生按照课程设计的具体要求所开发的所有源程序(应该放到一个文件夹中)、任务书和课程设计说明书的电子文档。
2.打印的课程设计说明书(注意:在封面后夹入打印的“任务书”以后再装订)。
四、主要技术路线提示为把多个小功能结合成一个完整的小软件,需使用“菜单设计”技术(可以是控制台方式下的命令行形式,若能做成图形方式则更好)。
五、进度安排共计两周时间,建议进度安排如下:选题,应该在上机实验之前完成需求分析、概要设计可分配4学时完成详细设计可分配4学时调试和分析可分配10学时。
2学时的机动,可用于答辩及按教师要求修改课程设计说明书。
注:只用课内上机时间一般不能完成设计任务,所以需要学生自行安排时间做补充。
六、推荐参考资料(不少于3篇)[1]苏仕华等编著,数据结构课程设计,机械工业出版社,2007[2]严蔚敏等编著,数据结构(C语言版),清华大学出版社,2003[3]严蔚敏等编著,数据结构题集(C语言版),清华大学出版社,2003指导教师签名日期年月日系主任审核日期年月日摘要分析了matlab,mathmatic,maple等数学软件对一元多项式的计算过程,步骤后。
由于这些软件比较大功能齐全,但是实用性不强。
数据结构课程设计_n元多项式乘法

数据结构课程设计_n元多项式乘法1. 引言在数据结构课程设计中,我们将探讨n元多项式乘法问题。
多项式乘法是代数学中的基本运算之一,它在计算机科学和工程领域有着广泛的应用。
本文将介绍n元多项式的定义、表示方法以及实现多项式乘法的算法。
2. 多项式的定义多项式是由一系列项组成的代数式。
每一项由系数和指数构成,系数表示该项的权重,指数表示该项的次数。
n元多项式是包含n个变量的多项式,例如,对于二元多项式 f(x,y) = 3x^2y + 2xy^2 + 5xy + 1,其中x和y是变量,3、2、5和1是系数,2、1和0是指数。
3. 多项式的表示方法为了在计算机中表示多项式,我们可以使用数组或链表等数据结构。
在本设计中,我们选择使用链表作为多项式的表示方法。
每个节点包含一个项的系数和指数,并使用指针连接各个节点。
4. 多项式的输入与输出为了方便用户输入和输出多项式,我们可以使用字符串作为输入和输出的形式。
例如,用户可以输入"3x^2y + 2xy^2 + 5xy + 1"来表示二元多项式。
在程序中,我们需要将字符串解析为多项式的链表表示,并且将计算结果转换为字符串输出给用户。
5. 多项式乘法的算法多项式乘法的算法可以通过两个多项式的每一项进行相乘,并将结果相加得到最终的乘积多项式。
具体的算法步骤如下:- 遍历第一个多项式的每一项- 遍历第二个多项式的每一项- 将两个项的系数相乘,指数相加得到新的项- 将新的项插入到结果多项式中- 如果结果多项式中已存在相同指数的项,则将系数相加- 返回结果多项式6. 算法的实现为了实现多项式乘法算法,我们可以定义一个多项式类,其中包含插入项、相乘项、相加项等方法。
具体的实现细节可以根据编程语言的特性进行调整。
在实现过程中,我们需要考虑多项式的排序和合并等问题,以保证算法的正确性和效率。
7. 算法的复杂度分析多项式乘法的复杂度取决于多项式的项数和次数。
数据结构课程设计-多项式计算

一需求分析1 该程序的功能相当于一个一元多项式计算器。
它能够实现按照指数升序排列建立并输出多项式,并且能够完成两个多项式的相加,相减,相乘,求导,求积分的运算的功能。
2 输入是从键盘输入的,输入的内容为多项式的项数,系数和指数,为任意的数;指数为大于等于0的整数从屏幕输出,显示用户输入的多项式,并显示运算以后的多项式的表达式。
3 一元多项式的建立,、先输入多项式的项数,每输入一个多项式的项就判断此项的指数是否与之前输入项的指数相同,如果相同就将将两项的系数相加;如果不相同就产生一个新的节点。
当达到输入项的项数就结束一个多项式的输入。
4 显示一元多项式,如果系数是大于0的话就输出+系数x指数的形式;如果系数是小于0的话就输出系数X指数的形式;如果指数是0的话直接输出系数;如果系数是1的话就直接输出+X;如果系数是-1的话就直接输出-X。
5 一元多项式的加法运算,设两指针qa与qb分别遍历Pa与Pb,若均不空则比较当前两项,分三种情况:其一,Pa中项的指数小,则qa后移一项; 其二,两者指数相等,若系数相加和为零,此时从和多项式Pa中将该项删除(需事先设指针prea),同时释放Pb中的当前项(事先设指针preb);若指数相等系数和不为0,则修改Pa中当前项的系数值,同时释放Pb的当前结点; 其三,Pb中指数小,则将Pb中当前项拿走,插入到Pa中当前项前边。
6 一元多项式的减法,设两指针qa与qb分别遍历Pa与Pb,若均不空则比较当前两项,分三种情况:其一,Pa中项的指数小,则qa后移一项; 其二,两者指数相等,若系数相减差为零,此时从和多项式Pa中将该项删除(需事先设指针prea),同时释放Pb中的当前项(事先设指针preb);若指数相等系数和不为0,则修改Pa中当前项的系数值,同时释放Pb的当前结点; 其三,Pb中指数小,则将Pb中当前项拿走,插入到Pa中当前项前边。
7 一元多项式的乘法,使用多项式,多项式Pa和Pb相乘,多项式Pc则用于保存Pa和Pb相乘的结果。
一元多项式计算(数据结构课程设计)

一元多项式计算(数据结构课程设计)一、系统设计1、算法思想根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相同的项,对应指数相加(减),若其和(差)不为零,则构成“和(差)多项式”中的一项;对于两个一元多项式中所有指数不相同的项,则分别写到“和(差)多项式”中去。
因为多项式指数最高项以及项数是不确定的,因此采用线性链表的存储结构便于实现一元多项式的运算。
为了节省空间,我采用两个链表分别存放多项式a 和多项式b,对于最后计算所得的多项式则利用多项式a进行存储。
主要用到了单链表的插入和删除操作。
(1)一元多项式加法运算它从两个多项式的头部开始,两个多项式的某一项都不为空时,如果指数相等的话,系数就应该相加;相加的和不为零的话,用头插法建立一个新的节点。
P 的指数小于q的指数的话就应该复制q的节点到多项式中。
P的指数大于q的指数的话,就应该复制p节点到多项式中。
当第二个多项式空,第一个多项式不为空时,将第一个多项式用新节点产生。
当第一个多项式空,第二个多项式不为空时,将第二个多项式用新节点产生。
(2)一元多项式的减法运算它从两个多项式的头部开始,两个多项式的某一项都不为空时,如果指数相等的话,系数就相减;相加的和不为零的话,用头插法建立一个新的节点。
p的指数小于q的指数的话,就应该复制q的节点到多项式中。
P的指数大于q的指数的话就应该复制p的节点到多项式中,并且建立的节点的系数为原来的相反数;当第二个多项式空,第一个多项式不为空时,将第一个多项式用新节点产生。
当第一个多项式空,第二个多项式不为空时,将第二个多项式用新节点产生,并且建立的节点的系数为原来的相反数。
2、概要设计(1)主函数流程图:(注:a代表第一个一元二次方程,b代表第二个一元二次方程)(2)一元多项式计算算法用类C语言表示:Typedef struct00{ //项的表示,多项式的项作为LinkList的数据元素Float coef;//细数Int expn;//指数}term,ElemType;//两个类型名:term用于本ADT,ElemType为LinkList的数据对象名Typedef LinkList polynomial://用带表头的节点的有序链表表示多项式//基本操作的函数原型说明Void CreatePolyn(polynomail&P);//输入n的系数和指数,建立表示一元多项式的有序链表P 销毁一元多项式P Void DestroyPolyn(polynomailP);销毁一元多项式PvoidPrintPoly(polynomail P);//打印输入一元多项式PIntPolynLength(polynnomail P);//返回一元多项式P中的项数void CreatPolyn(polynomail&Pa.polunomail&Pb);//完成多项式相加运算,即:Pa=Pa+Pb,并贤惠一元多项式Pb voidSubtractPolyn(polunomail&Papolunomail&Pb);//完成多项式相减运算,即:Pa=Pa-Pb,并销毁一元多项式Pb//基本操作的算法描述Int cmp(tem a,temp b);//依a的指数值<(或=)(或>b的住数值,分别返回-1、0和+1Void CreatePolyn(polynomail&P,int m){//输入m项的系数和指数,建立表示一元多项式的有序链表PInitList(P);h=GetHead(P);E.coef=0.0; e.expn=-1;S erCurElem(h,e);//设置头结点的数据元素For (i=1;i<=m;++i){ //依次输入m个非零项Scanf(e.coef,e.epn);If(!LocateElem(P,e,q,(*cmp)())){//当前链表中不存在该指数项If(MakeNode(s,e))InsFirst(q,s);//生成节点并插入链表}}}//CreatPolun二、详细设计1、算法实现(1)输入一元多项式函数:void shuchu(pnode *head){pnode *p;int one_time=1;p=head;while(p!=NULL) /*如果不为空*/{if(one_time==1){if(p->zhishu==0) /*如果指数为0的话,直接输出系数*/printf("%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/else if(p->xishu==1||p->xishu==-1)printf("X^%d",p->zhishu); /*如果系数是1的话就直接输出+x*//*如果系数是-1的话就直接输出-x号*/else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);one_time=0;}else{if(p->zhishu==0) /*如果指数为0的话,直接输出系数*/{if(p->xishu>0)printf("+%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/}else if(p->xishu==1) /*如果系数是1的话就直接输出+x号*/printf("+X^%d",p->zhishu);else if(p->xishu==-1) /*如果系数是-1的话就直接输出-x号*/printf("X^%d",p->zhishu);else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("+%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/printf("%5.2fX^%d",p->xishu,p->zhishu);}p=p->next; /*指向下一个指针*/}printf("\n");}(2)加法函数/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针,r,s为临时指针,p指向第1个多项式并向右移动,q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话,就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话,就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空,第1个数不为空时,将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空,第1个数不为空时,将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}(3)减法函数/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针,r,s为临时指针,p指向第1个多项式并向右移动,q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话,就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话,就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空,第1个数不为空时,将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空,第1个数不为空时,将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}2、程序代码/*一元多项式计算*//*程序功能:能够按照指数降序排列建立并输出多项式;能够完成两个多项式的相加、相减,并将结果输出;*//*提示:输入完一元多项式之后,输入“0 0”结束本一元多项式的输入*//*注意:系数只精确到百分位,最大系数只能为999.99,指数为整数.如果需要输入更大的系数,可以对程序中5.2%f进行相应的修改*/#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<conio.h>/*建立结构体*/typedef struct pnode{float xishu; /*系数*/int zhishu; /*指数*/struct pnode *next; /*下一个指针*/}pnode;/*用头插法生成一个多项式,系数和指数输入0时退出输入*/pnode * creat()int m;float n;pnode *head,*rear,*s; /*head为头指针,rear和s为临时指针*/ head=(pnode *)malloc(sizeof(pnode));rear=head; /*指向头*/scanf("%f",&n); /*系数*/scanf("%d",&m); /*输入指数*/while(n!=0) /*输入0退出*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=n;s->zhishu=m;s->next=NULL;rear->next=s; /*头插法*/rear=s;scanf("%f",&n); /*输入系数*/scanf("%d",&m); /*输入指数*/}head=head->next; /*第一个头没有用到*/return head;}/*调整多项式*/void tiaozhen(pnode *head){pnode *p,*q,*t;float temp;p=head;while(p!=NULL){q=p;t=q->next;while(t!=NULL){if(t->zhishu>q->zhishu)q=t;t=t->next;}temp=p->xishu;p->xishu=q->xishu;q->xishu=temp;temp=p->zhishu;p->zhishu=q->zhishu;q->zhishu=temp;p=p->next;}/*显示一个多项式*/void shuchu(pnode *head){pnode *p;int one_time=1;p=head;while(p!=NULL) /*如果不为空*/{if(one_time==1){if(p->zhishu==0) /*如果指数为0的话,直接输出系数*/printf("%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/else if(p->xishu==1||p->xishu==-1)printf("X^%d",p->zhishu); /*如果系数是1的话就直接输出+x*//*如果系数是-1的话就直接输出-x号*/else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);one_time=0;}else{if(p->zhishu==0) /*如果指数为0的话,直接输出系数*/{if(p->xishu>0)printf("+%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/}else if(p->xishu==1) /*如果系数是1的话就直接输出+x号*/printf("+X^%d",p->zhishu);else if(p->xishu==-1) /*如果系数是-1的话就直接输出-x号*/printf("X^%d",p->zhishu);else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("+%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);}p=p->next; /*指向下一个指针*/}printf("\n");/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针,r,s为临时指针,p指向第1个多项式并向右移动,q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话,就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话,就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空,第1个数不为空时,将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空,第1个数不为空时,将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}/*两个多项式的减法运算*/pnode * sub(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r;float x; /*x为系数相减*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*两个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu-q->xishu; /*系数相减*/if(x!=0) /*相减的差不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=-q->xishu; /*建立的节点的系数为原来的相反数*/s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}else{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}while(p!=NULL) /*当第2个多项式空,第1个数不为空时,将第一个数剩下的全用新节点产生*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}while(q!=NULL) /*当第1个多项式空,第1个数不为空时,将第2个数剩下的全用新节点产生*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=-q->xishu; /*建立的节点的系数为原来的相反数*/ s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}void add_main(){pnode * a,*b,*c;printf("\n输入第一个一元多项式:\n系数指数\n");a=creat();tiaozhen(a);printf("\n输入第二个一元多项式:\n系数指数\n");b=creat();tiaozhen(b);c=add(a,b);printf("第一个一元多项式如下:");shuchu(a);printf("第二个一元多项式如下:");shuchu(b);printf("两式相加如下:");shuchu(c);}void sub_main(){pnode * a,*b,*c;printf("\n输入第一个一元多项式:\n系数指数\n");a=creat();tiaozhen(a);printf("\n输入第二个一元多项式:\n系数指数\n");b=creat();tiaozhen(b);c=sub(a,b);printf("第一个一元多项式如下:");shuchu(a);printf("第二个一元多项式如下:");shuchu(b);printf("两式相减如下:");shuchu(c);}void open(){printf("\n****************************************************\n");printf(" 功能项: * 1 两个一元多项式相加;2 两个一元多项式相减;0 退出*\n");printf("****************************************************\n\n请选择操作: ");}void main(){int choose;open();while(choose!=0){scanf("%d",&choose);getchar();switch(choose){case 0:return;case 1:printf("\n 两个一元多项式相加\n");add_main();choose=-1;open();break;case 2:printf("\n 两个一元多项式相减\n");sub_main();choose=-1;open();break;default:printf("没有该选项!请重新选择操作!\n\n");open();}}}三、测试方案及结果1、测试方案在Visual C++ 6.0环境中调试运行。
数据结构课程设计--一元多项式计算问题(C语言)

长沙学院课程设计说明书题目一元多项式计算问题系(部)计算机科学与技术系专业(班级)12软件4班姓名谢仲蛟学号2012022411指导教师邱建雄起止日期2013.12.9~2013.12.20课程设计任务书课程名称:数据结构与算法设计题目:一元多项式计算问题已知技术参数和设计要求:问题描述:设计一个稀疏多项式简单计算器基本要求:(1)输入并分别建立多项式A和B(2)输入输出多项式,输出形式为整数序列:n,c1,e1,c2,e2……,其中n是多项式的项数,ci和ei 是第i项的系数和指数,序列按指数降序排列(3)完成两个多项式的相加、相减,并将结果输出;测试数据:(1) A+B A= 3x14-8x8+6x2+2 B=2x10+4x8+-6x2(2) A-B A=11x14+3x10+2x8+10x6+5 B=2x14+3x8+5x6+7(3) A+B A=x3+x1 B=-x3-x1(4) A+B A=0 B=x7+x5+x3+x1(5) A-B A=100x100+50x50+20x20+x B=10x100+10x50+10x20+x选作内容:(1).多项式在x=1时的运算结果(2)求多项式A和B的乘积设计工作量:40课时工作计划:指导教师签名:日期:教研室主任签名:日期:系主任签名:日期:长沙学院课程设计鉴定表摘要本次课程设计是在《数据结构》基础上设计以C语言来实现的,它的目的是帮助同学更深入的了解《数据结构》这门课程并熟练运用C语言,使同学达到熟练掌握的程度。
课程设计一个稀疏多项式简单计算器。
其基本要求有六:其一,输入建立两个多项式;其二,输出多项式,输出形式为整数序列:n,c1,e1,c2,e2……,其中n是多项式的项数,ci和ei是第i项的系数和指数,序列按指数的降序序列排列;其三,多项式排序,多项式按指数的降序序列排列;其四,多项式相加,指数相同系数相加,指数不同则把此项加进去;其五,多项式相减,指数相同系数相加,指数不同则把此项取反再加进去;其六,返回多项式的项数。
数据结构课程设计—一元多项式加法、减法、乘法运算的实现

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〕:根据下面给出的存储结构定义:#define MAXSIZE 20 //定义线性表最大容量 //定义多项式项数据类型 typedef struct{float coef; //系数int expn; //指数}term,elemType;typedef struct{term terms[MAXSIZE]; //线性表中数组元素int last; //指向线性表中最后一个元素位置}SeqList;typedef SeqList polynomial;根本操作函数说明polynomial*Init_Polynomial();//初始化空的多项式int PloynStatus(polynomial*p)//推断多项式的状态int Location_Element(polynomial*p,term x)在多项式p中查找与x项指数相同的项是否存在int Insert_ElementByOrder(polynomial*p,term x)//在多项式p中插入一个指数项xint CreatePolyn(polynomial*P,int m)//输入m项系数和指数,建立表示一元多项式的有序表pchar compare(term term1,term term2)//比拟指数项term1和指数项term2polynomial*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#include<stdlib.h>#include<stdio.h>#include<iostream.h>#define NULL 0#define MAXSIZE 20typedef 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!"<<endl;return 0;}j=p->last;while(p->terms[j].expn<x.expn && j>=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<m;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<term2.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<<"+"<<p->terms[i].coef;elsecout<<p->terms[i].coef;cout<<"x^"<<p->terms[i].expn;}cout<<endl;}void menu(){cout<<"\t\t*******数据结构综合性实验*********"<<endl;cout<<"\t\t***一、多项式的加、减、乘法运算***"<<endl;cout<<"\t\t******* 1.多项式创立 *********"<<endl;cout<<"\t\t******* 2.多项式相加 *********"<<endl;cout<<"\t\t******* 3.多项式相减 *********"<<endl;cout<<"\t\t******* 4.多项式相乘 *********"<<endl;cout<<"\t\t******* 5.清空多项式 *********"<<endl;cout<<"\t\t******* 0.退出系统 *********"<<endl;cout<<"\t\t****** 请选择(0-5) ********"<<endl;cout<<"\t\t***********************************"<<endl; }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〕设计内容以一个m*n的长方阵表示迷宫,0和1分别表示迷宫中的通路和障碍。
数据结构课程设计之一元多项式加减乘

##大学数据结构课程设计报告题目:顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现院(系):计算机工程学院学生姓名:班级:学号:起迄日期: 2011.06.20-06.30指导教师:2010—2011年度第 2 学期一、需求分析1、顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现。
可以分为几个模块:输入模块、输出模块(升幂降幂)、数据处理模块(多项式的加减乘)、主程序模块。
2、在程序过程中加入汉字提示符,让读者清楚明白的操作该程序。
运行程序时看起来简洁有序,操作简单明了3、程序执行时的命令:①选择创建两个一元多项式②输入第一个一元多项式的项数③依次输入一元多项式的系数和指数④以相同方式输入第二个一元多项式⑤选择操作方式⑥选择降幂或升幂排序⑦输出结果⑧是否退出。
4、测试数据。
输入的一元多项式系数指数分别为7 0,3 1,9 8,5 17和8 1,22 7,-9 8。
加法结果为;升幂降幂减法结果为:升幂降幂乘法结果为:升幂降幂二、概要设计1、设计思路:在该程序中分别分为顺序存储和链式存储结构。
2、数据结构设计:一元多项式抽象数据类型的定义:ADT Polynomial{数据对象:D={ai|ai∈TermSet,i=1,2…,m,m>=0TermSet中的每一个元素包含一个表示系数的实数和表示指数的整数}数据关系:R1={<ai-1,ai>|ai-1,ai∈D, 且ai-1中的指数值<ai中的指数值,i=2,…,n} 基本操作:CreatPolyn(&P,m)操作结果:输入m项的系数和指数,建立一元多项式P.DesteoyPolyn(&P)初始条件:一元多项式P已存在。
操作结果:销毁一元多项式P。
PrintfPolyn(P)初始条件:一元多项式P已存在。
操作结果:打印输出一元多项式P。
PolynLength(P)初始条件:一元多项式P已存在。
数据结构课程设计(一元多项式)

cout<<" ********1.两个一元多项式相加*********\n";
cout<<" ********2.两个一元多项式相乘*********\n";
cout<<" ********3.两个一元多项式相减*********\n";
cout<<p->coef;//其余情况都得打印
if(p->expn!=0) printf("x^%d",p->expn);//如果指数为"0"不打印指数项
else if((p->coef==1)||(p->coef==-1))
cout<<"1";
if(p->next==NULL)
flag=1;//如果现在的链节没有下一个就结束
(6)NODE *multi(NODE *pa,NODE *pb),函数功能是实现多项式的相乘。创建新链表,生成新结点,第一个式子中的每一项都与第二个式子中每一项系数相乘指数相加,直到两个式子中的结点都运算完毕,返回新链表;
(7)void output(NODE *f),函数功能是输出多项式。把运算完毕的新的多项式按结点依次输出,其中,若结点系数为正数则用+连接前后两个结点,若为负数则用-连接,系数为0则不输出指数;
{
if(q->next==NULL)
{
q->next=pb;
flag=1;
}
else
{
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
p->next=q->next;
free(q);q=NULL;
}
free(p);p=NULL;
}
void PrintPolyn(Polyn P)//输出多项式
{
Polyn q=next;
int flag=1; //项数计数器,用来判别第一项
if(!q)
{ //如果多项式为空链表,输出零
putchar('0');
}
printf("\n");
}
Status AddPolyn(Polyn &pc,Polyn pa,Polyn pb){ //求解并建立多项式a+b,并用pc带回多项式的和
Polyn qa=pa->next;
Polyn qb=pb->next;
Polyn hc,qc;
int j;
pc=(Polyn)malloc(sizeof(Polynomial)); //建立头结点
printf("\n");
return;
}
while(q)
{
if(q->data.coef>0&& flag!=1) putchar('+'); //多项式系数大于0且不是第一项
if(q->data.coef!=1&&q->data.coef!=-1)
{ //多项式系数不是+1和-1的普通情况
printf("%g",q->data.coef);
if(!pc)exit(OVERFLOW);
pc->next=NULL;
hc=pc;
while(qa||qb)//(while(qa&&qb)退出循环可以用hc=qa?qa:qb;),使用时对后面的减法造成影响
{
if(qa&&qb)
{
if(qa->data.exp>qb->data.exp) j=1; //a多项式某项指数大于b多项式某项指数
if(q->data.exp==1) putchar('X'); //多项式系数不是1且指数为1时,输出X
else if(q->data.exp) printf("X^%d",q->data.exp); //多项式系数不是1且指数不为1,输出X的指数次幂
}
else
{
if(q->data.coef==1) //多项式系数为1时
{ /*将新的结点插入链表,如果系数为零,则释放该结点;
如果指数为新时将结点直接插入;否则查找插入位置,
方法:比较该结点指数与首元结点及其他结点的指数,
直到该结点指数大于等于链表内某结点的指数,相等则合并这两项;大于则插入到其前驱*/
if(p->data.coef==0) {free(p);p=NULL;} //如果插入项的系数为零时,释放其结点将其删除
float coef; //多项式系数
int exp; //多项式指数
}ElemType;//数据类型
typedef struct Polynomial{
ElemType data;
struct Polynomial *next;
}*Polyn,Polynomial;//多项式结构体
void Insert(Polyn p,Polyn head)
if(!L)exit(OVERFLOW);
L->next=NULL;
for(i=1;i<=m;++i)
{
p=(Polyn)malloc(sizeof(Polynomial)); //建立新结点以接收数据
if(!p)exit(OVERFLOW);
p->next=NULL;
printf("请输入第%d项的系数与指数<中间用空格隔开>:",i);
{ //将多项式指数相同相进行合并
q2->data.coef += p->data.coef;
free(p);
if(!q2->data.coef)
{ //如果多项式的系数为零的话,将其删除即释放期结点
q1->next=q2->next;
free(q2);
}
}
else
{ //如果是新建的多项式,指数为新时将结点插入
{
if(!q->data.exp) printf("-1"); //多项式指数为零时,直接输出-1
else if(q->data.exp==1) printf("-X"); //多项式指数为1时,输出X
else printf("-X^%d",q->data.exp);
}
}
q=q->next;
flag++;
else
{
Polyn q1,q2;
q1=head;
q2=head->next;
while(q2&& p->data.exp < q2->data.exp)
{ //查找多项式某项的插入位置,使多项式按指数降幂排列
q1=q2;
q2=q2->next;
}
if(q2&& p->data.exp == q2->data.exp)
else if(qa->data.exp<qb->data.exp) j=-1; //b多项式某项指数大于a多项式某项指数
scanf("%f %d",&p->data.coef,&p->data.exp);
getchar();
Insert(p,L); //调用Insert函数插入新建的结点
}
return OK;
}
void DestroyPolyn(Polyn p){ //销毁多项式p
Polyn q;
while(q=p->next)
p->next=q2;
q1->next=p;
}
}
}
Status CreatePolyn(Polyn &L,int m)
{ /*建立一个头指针为L,项数为m的一元多项式;
先建立一个头指针,再建立新结点来接收数据,
然后再调用Insert函数插入结点*/
int i;
Polyn p;
L=(Polyn)malloc(sizeof(Polynomial));
{
if(!q->data.exp) putchar('1'); //多项式指数为零时,直接输出1
else if(q->data.exp==1) putchar('X'); //多项式指数为1时,输出X
else printf("X^%d",q->data.exp);
}
if(q->data.coef==-1) //多项式系数为-1时
#include<stdio.h>
#include<stdlib.h>
#include"malloc.h"
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define NULL 0
typedef int Status;
typedef struct ElemType{