数据结构课程设计之一元多项式加减乘

(2023)数据结构利用链表计算一元多项式课程设计实验报告(一)2023数据结构课程设计实验报告——利用链表计算一元多项式实验背景和目的在本课程设计实验中，我们旨在通过使用链表数据结构，实现对一元多项式的计算功能。

通过本次实验，我们将深入学习和掌握链表的基础知识和应用技能，掌握实现链表操作的代码实现方式，提高编程实践能力和解决问题的能力。

思路和方法首先，我们需要定义链表节点数据结构，包含多项式中的系数和指数两个数据成员。

然后，我们需要实现一元多项式的相加、相减、求导、求值等基本操作。

其中，相加和相减操作需要利用链表遍历的方式，比较两个多项式中的指数，进行对应系数的加减，并将结果存储到新的链表中。

求导操作只需要遍历链表，将每一项的指数减一，系数乘以指数值，再将其插入到新的链表中即可。

求值操作仅需要遍历链表，根据指数和系数计算多项式值即可。

在具体实现过程中，我们需要注意边界条件的判断和处理，如何处理空链表、单项式情况等。

还需要精细设计代码逻辑，避免重复遍历链表，浪费时间和空间资源。

结果分析和展示经过数次测试和调试，我们最终实现了一元多项式的链表计算功能。

我们在终端输入多项式的系数和指数，再根据指令进行相应的操作。

结果能够准确输出，并且经过大量数据测试，程序运行稳定，没有出现崩溃和错误的情况。

总结和反思通过本次实验，我们进一步深入学习了链表数据结构的应用方法和相关算法。

我们学会了如何通过遍历链表实现复杂计算操作，如一元多项式的求导、求值等。

在实现过程中，我们对代码结构和逻辑设计进行反复思考和优化，提高了自己的编程能力和解决问题的能力。

同时，我们也需要进一步加强数据结构的学习，提升自己的算法水平，为后续的专业学习和职业发展打下坚实的基础。

可能的改进和优化方案虽然我们已经实现了一元多项式链表计算功能，但是我们也发现了以下几点可以改进和优化的方案：•异常处理：在用户输入有误或者数据不规范的情况下，程序可能会出现崩溃或者不符合预期的结果。

一、设计题目一元多项式的加法、减法、乘法的实现。

二、主要内容设有一元多项式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等数学软件对一元多项式的计算过程，步骤后。

由于这些软件比较大功能齐全，但是实用性不强。

一元多项式的计算一、 需求分析建立一元多项式并按照指数降序排列输出多项式，将一元多项式输入并存储在内存中，能够完成两个多项式的加减运算并输出结果二、 概要设计存储结构：一元多项式的表示在计算机内可以用链表来表示，为了节省存储空间，只存储多项式中系数非零的项。

链表中的每一个结点存放多项式的一个系数非零项，它包含三个域，分别存放该项的系数、指数以及指向下一个多项式项结点的指针。

创建一元多项式链表，对一元多项式的运算中会出现的各种可能情况进行分析，实现一元多项式的相加、相减操作。

基本算法： 1、输入输出（1）功能：将要进行运算的多项式输入输出。

（2）数据流入：要输入的多项式的系数与指数。

（3）数据流出：合并同类项后的多项式。

（4）程序流程图：多项式输入流程图如图1所示。

（5）测试要点：输入的多项式是否正确，若输入错误则重新输入开始 申请结点空间输入多项式各项的系数 x, 指数 y输出已输入的多项式合并同类项结束否是是否输入正确图表 12、多项式的加法（1）功能：将两多项式相加。

（2）数据流入：输入函数。

（3）数据流出：多项式相加后的结果。

（4）程序流程图：多项式的加法流程图如图2所示。

（5）测试要点：两多项式是否为空，为空则提示重新输入，否则，进行运算。

图表 2开始 定义存储结果的空链 r是否输出存储多项式的和的链r结束 是 否同指数项系数相加后存入r 直接把p 中各项存入r直接把q 中各项存入r存储多项式2的空链Q 是否为空存储多项式1的空链P 是否为空合并同类项3、多项式的减法（1）功能：将两多项式相减。

（2）数据流入：调用输入函数。

（3）数据流出：多项式相减后的结果。

（4）程序流程图：多项式的减法流程图如图3所示。

（5）测试要点：两多项式是否为空，为空则提示重新输入，否则，进行运算。

开始定义存储结果的空链是否合并同类项结束是 否同指数项系数相加后存入r把p 中各项系数改变符号后存入直接把q 中各项存入r存储多项式2的空链Q 是否为空 存储多项式1的空链P 是否为空输出存储多项式图表 3三、详细设计#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct Polynomial{float coef;int expn;struct Polynomial *next;}*Polyn,Polynomial;/**************合并同类项********************/ void Insert(Polyn p,Polyn h){if(p->coef==0) //系数为0的话释放结点free(p);else //如果系数不为0{Polyn q1,q2;q1=h;q2=h->next;while(q2&&p->expn<q2->expn)//查找插入位置{q1=q2;q2=q2->next;}if(q2&&p->expn==q2->expn)//将指数相同相合并{q2->coef+=p->coef;free(p);if(!q2->coef) //系数为0的话释放结点{q1->next=q2->next;free(q2);}}else{ //指数为新时将结点插入p->next=q2;q1->next=p;}}}/*****************合并同类项，并按升幂排序*****************/ Polyn HeBing(Polyn &L){Polyn p1,p2,p3,p4,p5,p6;float t1;int t2;p1=L->next;while(p1!=NULL) //非递减顺序排列{p2=p1->next;while(p2!=NULL){if(p1->expn>p2->expn){t1=p1->coef;t2=p1->expn;p1->coef=p2->coef;p1->expn=p2->expn;p2->coef=t1;p2->expn=t2;}p2=p2->next;}p1=p1->next;}p3=L->next;while(p3!=NULL) //合并同类项{p4=p3->next;while(p4!=NULL){if(p3->expn==p4->expn){p3->coef=p3->coef+p4->coef;p3->next=p4->next;free(p4);p4=p3->next;}elsep4=p4->next;}p3=p3->next;}p5=L;while(p5->next!=NULL) //删除零项{p6=p5->next;if(p6->coef==0){p5->next=p6->next;free(p6);}p5=p5->next;}return L;}/*****************建立一个多项式****************/ Polyn CreatPolyn(Polyn &p){Polyn h,s;p=(Polyn)malloc(sizeof(struct Polynomial));if(!p)exit(1);p->coef=0;p->expn=-1;p->next=NULL;h=p;scanf("%f%d",&p->coef,&p->expn);while(p->coef!=0||p->expn!=0)//输入数据{s=(Polyn)malloc(sizeof(struct Polynomial));if(!s)exit(1);s->coef=p->coef;s->expn=p->expn;h->next=s;h=s;scanf("%f%d",&p->coef,&p->expn);}h->next=NULL;HeBing(p);return p;}/******************多项式的销毁***************/ void DestroyPolyn(Polyn p){Polyn q1,q2;q1=p->next;q2=q1->next;while(q1->next){free(q1);q1=q2;q2=q2->next;}}/*************输出多项式**************/void PrintPolyn(Polyn P){Polyn q=P->next;int flag=1;if(!q){putchar('0');printf("\n");return;} //若多项式为空，输出0while (q){if(q->coef>0&&flag!=1) putchar('+'); //系数大于0且不是第一项if(q->coef!=1&&q->coef!=-1)//系数非1或-1的普通情况{printf("%g",q->coef);if(q->expn==1) putchar('X');else if(q->expn) printf("X^%d",q->expn);}else{if(q->coef==1){if(!q->expn) putchar('1');elseif(q->expn==1) putchar('X');else printf("X^%d",q->expn);}if(q->coef==-1){if(!q->expn) printf("-1");elseif(q->expn==1) printf("-X");else printf("-X^%d",q->expn);}}q=q->next;flag++;}printf("\n");}/************辅助乘法和加法运算*************/int compare(Polyn a,Polyn b){if(a&&b){if(!b||a->expn>b->expn)return 1;elseif(!a||a->expn<b->expn)return -1;elsereturn 0;}elseif(!a&&b)return -1;//a多项式已空，但b多项式非空elsereturn 1;//b多项式已空，但a多项式非空}/*************多项式的加法*********************/ Polyn AddPolyn(Polyn pa,Polyn pb){Polyn qa=pa->next;Polyn qb=pb->next;Polyn headc,hc,qc;hc=(Polyn)malloc(sizeof(struct Polynomial));hc->next=NULL;headc=hc;while(qa||qb){qc=(Polyn)malloc(sizeof(struct Polynomial));switch(compare(qa,qb)){case 1:{qc->coef=qa->coef;qc->expn=qa->expn;qa=qa->next;break;}case 0:{qc->coef=qa->coef+qb->coef;qc->expn=qa->expn;qa=qa->next;qb=qb->next;break;}case -1:{qc->coef=qb->coef;qc->expn=qb->expn;qb=qb->next;break;}}if(qc->coef!=0){qc->next=hc->next;hc->next=qc;hc=qc;}else free(qc);//当相加系数为0时，释放该结点}HeBing(headc);return headc;}/************多项式的减法*****************/Polyn SubstractPolyn(Polyn pa,Polyn pb){Polyn h=pb;Polyn p=pb->next;Polyn pd;while(p) //将pb的系数取反{p->coef*=-1;p=p->next;}pd=AddPolyn(pa,h);for(p=h->next;p;p=p->next) //恢复pb的系数p->coef*=-1;HeBing(pd);return pd;}/*****************多项式的乘法*********************/Polyn MultiplyPolyn(Polyn pa,Polyn pb){Polyn hf,pf;Polyn qa=pa->next;Polyn qb=pb->next;hf=(Polyn)malloc(sizeof(struct Polynomial));hf->next=NULL;for(;qa;qa=qa->next){for(qb=pb->next;qb;qb=qb->next){pf=(Polyn)malloc(sizeof(struct Polynomial));pf->coef=qa->coef*qb->coef;pf->expn=qa->expn+qb->expn;Insert(pf,hf);//调用Insert函数以合并指数相同的项}}HeBing(hf);return hf;}/*******************主函数*******************/void main(){Polyn p1, p2, p3, p4, p5;CreatPolyn(p1);CreatPolyn(p2);PrintPolyn(p1);PrintPolyn(p2);p3=AddPolyn(p1, p2);PrintPolyn(p3);p4=SubstractPolyn(p1, p2);PrintPolyn(p4);p5=MultiplyPolyn(p1, p2);PrintPolyn(p5);DestroyPolyn(p1);DestroyPolyn(p2);DestroyPolyn(p3);DestroyPolyn(p4);DestroyPolyn(p5);}四、调试结果1.测试的数据及结果2.算法的时间复杂度及改进算法的时间复杂度：一元多项式的加法运算的时间复杂度为O(m+n）,减法运算的时间复杂度为O(m-n)，其中m，n分别表示二个一元多项式的项数。

一元多项式计算(数据结构课程设计)一、系统设计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环境中调试运行。

韶关学院计算机科学学院数据结构课程设计题目：多项式运算学生姓名：学号：专业：班级：指导教师姓名及职称：讲师起止时间：年月——年月1.课题分析1.1课题背景及意义《数据结构课程设计》是一门实践性的计算机课程，为了学好这门课程，必须在掌握理论知识的同时，加强上机实践。

通过这次课程设计，要求掌握较大程序的设计方法，相应数据结构的选择应用、算法的设计及其实现和性能分析等方面中加深对课程基本内容的理解。

同时，在设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练。

1.2程序功能本程序的功能是建立按照指数降序排列的两个一元多项式，并能够完成加、减和乘运算，最后将结果按照指数降序排列显示出来。

输入和输出值范围：系数精确到小数点6位，指数以整数表示。

输入形式：系数指数系数指数……0 0 //以0 0作为结束输出形式：fk(x)=系数x^指数+系数x^指数+……+0 x^01.3测试数据：1）加法操作:请输入第一个要操作的多项式：请按多项式指数由高到低输入系数和指数：（以0 0结束）8 64 5-2 4-123 3-1 110 00 0fa(x)=(8.000000x^6)+(4.000000x^5)+(-2.000000x^4)+(-123.000000x^3)+(-1.000000x ^1)+(10.000000x^0)请输入第二个要操作的多项式：请按多项式指数由高到低输入系数和指数：（以0 0结束）2 3-5 21 10 0fb(x)=(2.000000x^3)+(-5.000000x^2)+(1.000000x^1)请选择你要进行的操作:1.多项式相加2.多项式相减3.多项式相乘1fa(x)+f(b)=(8.000000x^6)+(4.000000x^5)+(-2.000000x^4)+(-121.000000x^3)+(-5.000 000x^2)+(10.000000x^0)2）减法操作:请输入第一个要操作的多项式：请按多项式指数由高到低输入系数和指数：（以0 0结束）8 64 5-2 4-123 3-1 110 00 0fa(x)=(8.000000x^6)+(4.000000x^5)+(-2.000000x^4)+(-123.000000x^3)+(-1.000000x ^1)+(10.000000x^0)fa(x)=(3.000000x^3)+(2.000000x^2)请输入第二个要操作的多项式：请按多项式指数由高到低输入系数和指数：（以0 0结束）2 3-5 21 10 0fb(x)=(2.000000x^3)+(-5.000000x^2)+(1.000000x^1)请选择你要进行的操作:1.多项式相加2.多项式相减3.多项式相乘2fa(x)-fb(x)=(8.000000x^6)+(4.00000x^5)+(-2.000000x^4)+(-125.000000x^3)+(-5.0000 00x^2)+(-2.000000x^1)+(10.000000x^0)3）乘法操作:请输入第一个要操作的多项式：请按多项式指数由高到低输入系数和指数：（以0 0结束）8 64 5-2 4-123 3-1 110 00 0fa(x)=(8.000000x^6)+(4.000000x^5)+(-2.000000x^4)+(-123.000000x^3)+(-1.000000x ^1)+(10.000000x^0)fa(x)=(3.000000x^3)+(2.000000x^2)请输入第二个要操作的多项式：请按多项式指数由高到低输入系数和指数：（以0 0结束）2 3-5 21 10 0fb(x)=(2.000000x^3)+(-5.000000x^2)+(1.000000x^1)请选择你要进行的操作:1. 多项式相加2. 多项式相减3. 多项式相乘3fa(x)*fb(x)=(16.000000x^9)+(-32.000000x^8)+(-16.000000x^7)+(-232.000000x^6)+(6 13.000000x^5)+(-125.000000x^4)+(25.000000x^3)+(-51.000000x^2)+(10.000000x^1) 2.概要设计2.1本程序包含的模块typedefstructLinkNode //定义单向链表{}linknode;voidcreatelink(linknode *head){ }；//构建一个以单链表存储的多项式void show(linknode *head){ }；//显示多项式voidaddtion(linknode *fa,linknode *fb,linknode *fc){ }；//加法操作void subtraction(linknode *fa,linknode *fb,linknode *fc){ } ；//减法操作void multiply(linknode *fa,linknode *fb,linknode *fc){ }；//乘法操作voidsortion(linknode *fc){ }；//将乘法所得的结果合并同类项void deletion(linknode *head,linknode *s);{ }；//删除结点操作voidmian(){ }；//主程序2.2问题解决的思路概述首先是确定结构化程序设计的流程图，利用已存在的数据结构来构造一个存储一元多项式的结构，接着把三则运算分成五个主要的模块：实现加法的模块、实现减法的模块、实现乘法的模块、实现合并同类项模块、删除结点模块，然后各个模块里面还要分成若干种情况来考虑并通过函数的嵌套调用来实现其功能。

数据结构课程设计设计题目：基于链式表实现一元多项式的加减乘运算目录问题分析11.1 问题描述设计一个n元多项式程序，并完成多项式的乘法运算。

从实际的角度出发，这里设计的程序是基于一元n次多项式的数学模型。

1.2 问题的数学模型在数学上，一个一元多项式Pn(x>可按升幂写成：Pn(x>=a 0+a1 x+a2 x^2 +…+a n x^n-1.它由n+1个系数惟一确定，因此，在计算机里，它可用一个线性表P来表示：Pn=(a0,a1,a2,…,an>每一项的指数i隐含在其系数ai的序号里。

多项式的乘法规则：多次运用单项式与多项式相乘的法则得到的．计算时(a+b>(m+n>，先把(m+n>看成一个单项式，(a+b>是一个多项式，运用单项式与多项式相乘的法则，得到(a+b>(m+n>=a(m+n>+b(m+n>,然后再次运用单项式与多项式相乘的法则。

1.3 构造数据结构通过分析多项式的特征，不难看出多项式是由单项式构成的，而每个单项式都具有系数和指数，当系数为0时，该项就失去了意义，在计算机内要表示一个多项式，至少以下数据信息：系数信息、指数信息和指向下一个单项式的指针。

通过指针，我们就可以把多个单项式连接起来，形式一个多项式，需要说明的是从广义的角度讲，单项式也是一个多项式。

基于以上的分析，我们定义多项式的数据结构为如下结构体形式：typedef struct Polynomial{float coef。

//系数int expn。

//指数struct Polynomial *next。

//指向下一个结点}*Polyn,Polynomial。

//Polyn为结点指针类型2 系统分析2.1 可行性研究该程序主要从技术的角度来分析可行性。

技术上的可行性研究主要分析技术条件能否顺利完成开发工作，硬、软件能否满足开发者的需要等。

该系统采用了Windows XP操作系统结合Visual C++ 6.0,TC 2.0等软件开发平台已成熟可行。

##大学数据结构课程设计报告题目：顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现院（系）：计算机工程学院学生姓名:班级：学号:起迄日期: 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已存在。

数据结构课程设计题目：一元多项式简单计算一、实验题目：一元多项式简单计算二、实验目的熟悉掌握一元多项式在链式存储结构上的实现，能够按照指数降序排列建立并输出多项式。

能够完成两个多项式的相加、相减，并将结果输出。

体会链式存储结构的优缺点和适用性。

三、实验内容1、需求分析建立一元多项式并按照指数降序排列输出多项式，将一元多项式输入并存储在内存中，能够完成两个多项式的加减运算并输出结果2、概要设计存储结构：一元多项式的表示在计算机内可以用链表来表示，为了节省存储空间，只存储多项式中系数非零的项。

链表中的每一个结点存放多项式的一个系数非零项，它包含三个域，分别存放该项的系数、指数以及指向下一个多项式项结点的指针。

创建一元多项式链表，对一元多项式的运算中会出现的各种可能情况进行分析，实现一元多项式的相加、相减操作。

基本算法：1、输入输出（1）功能：将要进行运算的多项式输入输出。

（2）数据流入：要输入的多项式的系数与指数。

（3）数据流出：合并同类项后的多项式。

（4）程序流程图：多项式输入流程图如图1所示。

（5）测试要点：输入的多项式是否正确，若输入错误则重新输入2、多项式的加法（1）功能：将两多项式相加。

（2）数据流入：输入函数。

（3）数据流出：多项式相加后的结果。

（4）程序流程图：多项式的加法流程图如图2所示。

（5）测试要点：两多项式是否为空，为空则提示重新输入，否则，进行运算。

3、详细设计#include <stdio.h>#include <malloc.h>typedef struct polynode {int coef;int expn;struct polynode *next;} *pnode;pnode createpoly(){int a,n,i=1;pnode head,s,p;printf("输入多元一项式（以0,0标志结束）\n");printf("要求：1、按幂从大到小次序输入各结点\n"); printf(" 2、没有两个结点具有相同的幂:\n"); head=(pnode)malloc(sizeof(struct polynode));head->next=NULL;p=head;do{printf("第%d次->系数,幂:",i++);scanf("%d,%d",&a,&n);if (a!=0 || n!=0){s=(pnode)malloc(sizeof(struct polynode));s->coef=a;s->expn=n;s->next=NULL;p->next=s;p=s;}} while (a!=0 || n!=0);printf("\n");return(head);}void printpoly(pnode head){int first=1;head=head->next;while (head!=NULL){if (first){if (head->expn==1)printf("%dx",head->coef);else if (head->expn==0)printf("%d",head->coef);elseprintf("%dx^%d",head->coef,head->expn);first=0;}else{if (head->expn==1)printf("%+dx",head->coef);else if (head->expn==0)printf("%+d",head->coef);elseprintf("%+dx^%d",head->coef,head->expn);}head=head->next;}printf("\n");}pnode addpoly(pnode pa,pnode pb){int n;pnode pc,s,p;pa=pa->next;pb=pb->next;pc=(pnode)malloc(sizeof(struct polynode));pc->next=NULL;p=pc;while (pa!=NULL && pb!=NULL){if (pa->expn>pb->expn){s=(pnode)malloc(sizeof(struct polynode));s->coef=pa->coef;s->expn=pa->expn;s->next=NULL;p->next=s;p=s;pa=pa->next;}else if (pa->expn<pb->expn){s=(pnode)malloc(sizeof(struct polynode));s->coef=pb->coef;s->expn=pb->expn;s->next=NULL;p->next=s;p=s;pb=pb->next;}else{n=pa->coef+pb->coef;if (n!=0){s=(pnode)malloc(sizeof(struct polynode));s->coef=n;s->expn=pb->expn;s->next=NULL;p->next=s;p=s;}pa=pa->next;pb=pb->next;}}while (pa!=NULL){s=(pnode)malloc(sizeof(struct polynode)); s->coef=pa->coef;s->expn=pa->expn;s->next=NULL;p->next=s;p=s;pa=pa->next;}while (pb!=NULL){s=(pnode)malloc(sizeof(struct polynode)); s->coef=pb->coef;s->expn=pb->expn;s->next=NULL;p->next=s;p=s;pb=pb->next;}return(pc);}main(){ printf(“题目：一元多项式简单运算\n”);printf(“姓名：何琴\n”);printf(“学号：1041011109\n”);pnode poly1,poly2,poly3;printf("建立第一个一元多项式=>\n");poly1=createpoly();printf("建立第二个多元多项式=>\n");poly2=createpoly();poly3=addpoly(poly1,poly2);printf("第一个一元多项式为:");printpoly(poly1);printf("第二个一元多项式为:");printpoly(poly2);printf("相加后一元多项式为:");printpoly(poly3);}4、运行结果四、实验体会通过这一周的课程设计，我感觉到要真正做出一个程序并不很容易,但只要用心去做，总会有收获,特别是当我遇到问题,问老师，问同学，想尽办法去解决,最后终于找到方法时,心里的那份喜悦之情真是难以形容.编写程序中遇到问题再所难免,应耐心探究其中的原因,从出现问题的地方起,并联系前后程序,仔细推敲,逐个排查.直到最终搞清为止。

cout<<" ~~~~~~~~~~~~~~~~0.退出~~~~~~~~~~~~~~~\n";
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
{

武汉理工大学华夏学院课程设计报告书课程名称：数据结构与算法分析题目：用C语言实现一元多项式的加减法运算系名：信息工程系专业班级：物联网工程1122班姓名：隋明超学号： 10213312201 指导教师:司晓梅2014年 1 月 3 日武汉理工大学华夏学院信息工程系课程设计任务书课程名称：数据结构与算法分析指导教师：司晓梅班级名称：物联网1121-2 开课系、教研室：信息系计算机一、课程设计目的与任务《数据结构》课程设计是为训练学生的数据组织能力和提高程序设计能力而设置的增强实践能力的课程。

目的：学习数据结构课程，旨在使学生学会分析研究数据对象的特性，学会数据的组织方法，以便选择合适的数据的逻辑结构和存储结构以及相应操作，把现实世界中的问题转换为计算机内部的表示和处理，这就是一个良好的程序设计技能训练的过程。

提高学生的程序设计能力、掌握基本知识、基本技能，提高算法设计质量与程序设计素质的培养就是本门课程的课程设计的目的。

任务：根据题目要求，完成算法设计与程序实现，并按规定写出课程设计报告。

二、课程设计的内容与基本要求设计题目：用C语言实现一元多项式的加减法计算〔问题描述〕输入并建立两个多项式并输出多项式设计一个程序：对两个多项式进行加、减法运算，建立一个新多项式并输出。

〔实现提示〕：选择单链表存储多项式具体要完成的任务是：A. 编制完成上述问题的C语言程序、进行程序调试并能得出正确的运行结果。

B. 写出规范的课程设计报告书；三、课程设计步骤及时间进度和场地安排时间：本课程设计安排在第18周地点：现代教育中心具体时间安排如下：第一天：布置题目，确定任务、查找相关资料第二天～第四天：功能分析，编写程序，调试程序、运行系统；第五天上午：撰写设计报告；第五天下午：程序验收、答辩。

四、课程设计考核及评分标准课程设计考核将综合考虑学生的系统设计方案、运行结果、课程设计报告书的质量、态度、考勤、答辩情况等各因素。

《数据结构》课程设计多项式计算班级：学号：姓名：指导老师：多项式计算1、问题描述能够按照指数降序排列建立多项式；能够完成两个多项式的相加、相减和相乘，并将结果输出。

2、设计思路这个程序的关键是多项式的创建和排列，以及相乘时系数相乘和指数相加、相加时相同指数的系数相加、相减时相同指数的系数相减。

由于多项式拥有指数和系数（假设基数已定），所以可以定义一个包含指数系数的结构体，用单链表存储多项式的数据，所以结构体包含next指针。

数据插入时比较两数的指数，按照降序排序，从表头的next开始，直至找到合适的位置，然后开始链表中数值的插入，如果相等则直接将指数相加，如果大于就将新数据插入到当前指向的前面，否则将新数据插入到最后。

输入完数据后选择计算方式（相乘、相加、相减），多项式运算时要循环遍历整个多项式，多项式的每一组数据都要和另一个多项式整组数据相运算（每一个运算值都存储到新建的“多项式”链表中），直到两个多项式都遍历完结束。

3、数据结构设计在模拟多项式对象时，为了简化处理，只取最核心的两个数据：多项式的系数和指数。

前面提到，要用单链表操作，所以要加上个next指针，再由该结构体定义一个结点类型和指针类型。

具体数据结构定义如下：typedef struct node{int xs; /*系数*/int zs; /*指数*/struct node * next; /*next指针*/}Dnode,* Dnodelist;4、功能函数设计（1）链表初始化函数Creat_node()带有头结点的头指针指向空（NULL）。

（2）多项式数据的创建函数Creat_Dmeth()当链表初始化成功后，开始创建多项式。

分别循环输入两个多项式的系数和指数，其中要用到插入函数。

（3）数据的插入函数Insert_node()当创建多项式时，要用到此函数，即利用插入的方式将多项式的数据连接起来。

再输入一组数据后，程序自动调用此函数，插入时也进行着排序，从表头的next开始，一一比较指数大小，直到大于或等于当前指向的数据或遍历完所有数据时停止，然后开始链表中数值的插入，如果相等则直接将指数相加，如果大于就将新数据插入到当前指向的前面，否则将新数据插入到最后。

数学与计算机学院课程设计说明书课程名称: 数据结构课程设计课程代码: 8404181题目:一元多项式运算的实现年级/专业/班: 2009-计科-3学生姓名:学号: 312009*********开始时间:2011 年06 月13日完成时间:2011 年06月21 日课程设计成绩：学习态度及平时成绩（30）技术水平与实际能力（20）创新（5）说明书撰写质量（45）总分（100）指导教师签名：年月日目录1 引言 (1)1.1问题的提出 (1)1.2国内外研究的现状 (1)1.3任务与分析 (1)2程序的主要功能 (2)2.1一元多项式创建 (2)2.2一元多项式的加法 (2)2.3一元多项式的减法 (2)2.4一元多项式的乘法 (2)2.5一元多项式项的指数比较 (2)2.6一元多项式运算结果升降排序 (2)2.7一元多项式的输出 (3)2.8一元多项式的销毁 (3)3 程序运行平台 (4)4 总体设计 (5)5 程序类的说明 (6)6 模块分析 (7)6.1创建模块 (8)6.2一元多项式的加法 (10)6.3一元多项式相减 (12)6.4一元多项式相乘 (15)6.5一元多项式输出结果按项的指数排序 (17)6.6一元多项式运算系统实现 (21)7系统测试 (32)8 结论 (38)摘要随着计算机的普及，对数学中一元多项式的研究也逐渐普及，计算机程序员通过对其结构的分析，针对其特殊的结构，利用不同的计算机设计语言编程利用计算机系统实现了对一元多项式的一系列操作。

本课程设计中主要利用C、C++语言编写程序实现了稀疏一元多项式的简单运算系统，该系统具有一元多项式顺序和动态两种存储结构，实现了一元多项式的加法、减法、乘法运算等功能。

关键词：计算机; 一元多项式; C；C++;顺序存储；动态存储1 引言1.1 问题的提出随着计算机的不断发展，计算机的线性表的应用越来越广泛，如今线性表在计算器程序上的应用已达非常成熟的阶段。

HUNAN CITY UNIVERSITY 数据结构课程设计报告设计题目：一元多项式的加法、减法、乘法的实现专业：计算机科学与技术（嵌入式）学生姓名：班级学号：分组成员：指导教师：陈强老师2012 年 6月 8日1006402《数据结构》课程设计报告一、设计时间2011年6月4日——6月8日二、设计地点湖南城市学院实验楼计算机房407三、设计目的《数据结构》主要介绍最常用的数据结构，阐明各种数据结构内在的逻辑关系，讨论其在计算机中的存储表示，以及在其上进行各种运算时的实现算法，并对算法的效率进行简单的分析和讨论，是介于数学、计算机软件和计算机硬件之间的一门计算机专业的核心课程，它是计算机程序设计、数据库、操作系统、编译原理及人工智能等的重要基础，广泛的应用于信息学、系统工程等各种领域。

该课程的特点是实践性较强，为了学好这门课程，需要在掌握理论知识的同时，加强上机实践。

本课程设计的目的就是要达到理论与实际应用相结合，使同学们能够根据数据对象的特性，学会数据组织的方法，能把现实世界中的实际问题在计算机内部表示出来，并培养基本的、良好的程序设计技能。

具体要求如下：1.了解并掌握数据结构与算法的设计方法，具备初步的独立分析和设计能力；2.初步掌握软件开发过程的问题分析、系统设计、程序编码测试等基本方法和技能;3.提高综合运用所学的理论知识和方法独立分析和解决问题的能力;4.训练用系统的观点和软件开发一般规范进行软件开发，培养软件工作者所应具备的科学的工作方法和作风。

四、设计小组成员五、指导教师：六、设计课题：顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现设有一元多项式Am(x)和Bn(x).Am(x)=A0+A1x1+A2x2+A3x3+…+A m x mBn(x)=B0+B1x1+B2x2+B3x3+…+B n x n请实现求M(x)=Am(x)+Bn(x)、M(x)=Am(x)-Bn(x)和M(x)=Am(x)×Bn(x)。

福建农林大学计算机与信息学院课程设计报告课程名称：数据结构课程设计题目：一元多项式的加法减法乘法的实现姓名：系：软件工程系专业：软件工程专业年级：2014学号：指导教师：***职称：副教授完成起止日期：2016.6.5 - 2016.7.12016年07月1日福建农林大学计算机与信息学院课程设计结果评定目录一、问题分析和任务定义 (1)二、程序设计内容 (1)三、程序调试与测试 (7)四、实验心得 (9)五、程序编码 (9)一、问题分析及任务定义顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现。

【问题描述和基本要求】设有一元多项式Am(x)和Bn(x).Am(x)=A0+A1x1+A2x2+A3x3+… +AmxmBn(x)=B0+B1x1+B2x2+B3x3+… +Bnxn请实现求M(x)= Am(x)+Bn(x)、M(x)= Am(x)-Bn(x)和M(x)= Am(x)×Bn(x)。

要求：1) 首先判定多项式是否稀疏2) 分别采用顺序和动态存储结构实现；3) 结果M(x)中无重复阶项和无零系数项；4) 要求输出结果的升幂和降幂两种排列情况二、课程设计的内容2.1函数多项式创建函数PolyNode *Creatpoly()多项式输出函数void Prin_poly(PolyNode *h)多项式升序排列函数void Insortup(PolyNode *h)多项式降序排列函数void Insortdown(PolyNode *h)多项式合并函数void UnitePoly(PolyNode *h)多项式相乘函数PolyNode *polymuti(PolyNode *h1,PolyNode *h2)多项式相加函数PolyNode *addition(PolyNode *ha, PolyNode *hb)多项式相减函数PolyNode *subduction (PolyNode *ha, PolyNode *hb)2.2设计各个模块的流程图（1）main()(3)void Insortdown(PolyNode *h)(4) PolyNode *polymuti(PolyNode *h1,PolyNode *h2)（5）void UnitePoly(PolyNode *h)(6) PolyNode *addition(PolyNode *ha, PolyNode *hb)开始三、程序调试与测试相加结果相减结果相乘结果四、实验心得在本次课程设计中，我明白了理论应与实际相结合，上机练习是提高编程能力最有效的办法，这次实验提高了我编写大型程序的能力以及查阅资料并从中获得有效资料的能力。

一元多项式加法一、实验目的通过实现多项式加法，对链表有更深入的了解二、实验内容问题描述：设计一个一元稀疏多项式简单的加法计算器实现要求：一元稀疏多项式简单计算器的基本功能是：（1）输入并建立多项式：1785937)(x x x x A +++=；879228)(x x x x B -+=（2）输出多项式（3）多项式A 和B 相加，建立多项式C ＝A ＋B ，并输出相加的结果多项式C（4）选作：多项式A 和B 相减，建立多项式C ＝A －B ，并输出相减的结果多项式D 方法说明：（1）多项式的输入与存储用带表头结点的单链表存储多项式，链表中的每个节点分别存储多项式各项的系数和指数，即每从键盘输入多项式的一对数（系数，指数），可对应建立链表的一个结点。

每个节点的结构为：建立两个链表，其中pa 和pb 分别为它们的头指针：pb结果链表Pa(或者是Pc)Pc（2）多项式数据类型的定义struct tagNode{float coef;int exp;struct tagNode *next;typedef struct tagNode Node;typedef struct tagNode* pNode;（3）主要算法①创建两个链表，分别存放多项式1和多项式2，这两个链表中的节点是按指数降序或者升序排列的②多项式相加，下面给出多项式相加的部分实现/*下面的函数实现两个多项式的相加，要相加的链表分别由pa和pb指向（其中，pa，pb都是分配了空间的头结点）。

相加的结果直接由pa指向的链表保存，即是在pa链表中添加或删除（当系数因为相加为0的情况下）一些结点，构成结果。

相加的链表中指数按从小到大的顺序排列好的，是升序链表。

*/void add_poly(Node *pa,Node *pb){Node *p=pa->pNext;//链表1，将来的结果也放在此Node *q=pb->pNext;//链表2Node *pre=pa;Node *u;//临时用float x;while (p!=NULL && q!=NULL)//当两个链表都不为空{if (p->exp<q->exp)//比较链表1跟链表2当前节点的指数大小，链表1也是存放结果的地方{pre=p;p=p->pNext;//p指向要比较的下一个结点。

数据结构课程设计报告题目：一元多项式相加学号：姓名：指导老师：时间： 2011年10月18日星期二程序建立的过程及步骤：1首先建立一个定义多项式的结构体duoxiangshi，其中包括一个指数（int型），一个系数（float型），还有一个指向下一项的指针，具体编译代码如下：typedef struct duoxiangshi//定义一个多项式{float coef;//多项式系数int exp;//多项式指数struct duoxiangshi *next;};2在定义一个函数（1），用来指导用户输入程序运行时所需要的必须得数据，两个一元多项式的项数、系数、指数。

具体的代码如下：void creatDuoX(Polynomial &Px,int n)//定义一个多项式函数{initDuoX(Px);duoxiangshi *p,*q;p=Px;for(int i=1;i<=n;i++){q=new duoxiangshi;cout<<"第"<<i<<"项的系数：";cin>>q->coef;//输入系数cout<<"第"<<i<<"项的指数：";cin>>q->exp;//输入指数q->next=NULL;p->next=q;p=q;}}3定义一个计算合并后的多项式的项数的函数（2），此函数的主要作用是用来最后输出合并后的多项式的时候起到作用。

具体代码如下：int lengthDuoX(Polynomial &Px)//计算多项式项数的函数，返回值是这个合并后的多项式的项数{duoxiangshi *p;int count;//定义一个变量，用来计算多项式的长度p=Px->next;count=0;while(p!=NULL){p=p->next;count++;//自加最后得出总项数并返回}return count;}4定义一个输出合并后的多项式的函数（3），主要作用为主函数调用后可以输出一元多项式，具体代码如下：void outputDuoX(Polynomial &Px)//输出合并后的多项式{ duoxiangshi *p;p=Px->next;int i;for(i=0;i<lengthDuoX(Px);i++)//调用上一个计算项数的函数，逐项的输出合并后的项{cout<<p->coef<<"*X^ "<<p->exp<<" +";p=p->next;}cout<<"0"<<endl;}5, 最重要的核心部分，程序的逻辑中心，让两个多项式相加，其中要考虑的情况如下一：两个多项式A、B 都为0二：其中一个多项式A 为0，B不为0三：其中一个多项式B为0，A不为0四：A与B 都不为0而在程序中我将二与三这两种情况，通过IF语句将其嵌到四的情况中，这样可以节省代码的复杂度。

数据结构课程设计《一元多项式的四则运算》一元多项式的四则运算学生姓名：XX 指导老师：XX摘要本课程设计主要解决一元多项式的运算问题，通过链表的使用，实现对一元多项式的构建、录入、存储、打印、以及之间的运算。

在本课程设计中，程序设计语言为C++语言，程序运行平台为Windows/98/2000/XP，程序采用了链表存储方法以及结构化和模块化的设计方法，通过调试运行，可以进行多项式的加、减、乘运算，勉强实现了设计目标，并且经过适当完善后，将可应用到实际中解决某些问题。

关键词程序设计；C++ ；一元多项式；运算1 引言一般来说，我们只知道数学上的一元多项式的运算，这一般都是用笔来进行运算的，然而此课程设计将一元多项式的运算用电脑来进行，只需要将多项式输入，然后就可以出结果，速度快，省去了认为计算的环节，在现实中带来不少方便。

1.1 课题背景一元多项式的运算，虽然无法直接在除数学外的其他领域作出贡献，但是在数学上，它可以为人们解决一些自己动笔动手很难解决的问题，比如说那些很长很长的多项式，用笔算可能要算半天，但是用该程序，只需短短的几秒钟，所以它给人们带来了不少方便，同时相信它也能间接地为其他领域做出贡献。

1.2 课程设计目的个人觉得，该数据结构课程设计一方面可以让自己更加熟悉那些些常用的数据结构，掌握数据结构内在的逻辑关系，以及它们在计算机中的存储表示，和对它们实行的各种运算；另一方面，可以让自己对于整体和局部，以及结构化和模块化编程有一个更深层次的了解。

作为网络工程的学生，虽然之前有过一次Ｃ语言课程设计，但是深知自己编程能力尚为欠缺，所以这一次数据结构课程设计是对我的编程能力和组织能力的又一次考验。

1.3课程设计内容本课程设计是用链表实现一元多项式的存储及运算，其中包括多项式系数及指数的录入（即一元多项式的录入），以及储存、一元多项式的显示、一元多项式之间的加、减、乘法运算。

2 设计思路与方案2.1设计思路该系统使用Ｃ++语言进行开发和实现，程序中的各个功能分别由不同的的函数实现，然后在main 函数中调用实现。