数据结构课程设计一元多项式的加减法运算汇总
数据结构课程设计-一元多项式的加法、减法、乘法的实现
一、设计题目一元多项式的加法、减法、乘法的实现。
二、主要内容设有一元多项式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分别表示二个一元多项式的项数。
一元多项式的计算问题-数据结构与算法课程设计报告
合肥学院计算机科学与技术系课程设计报告2009 ～2010 学年第 2 学期课程数据结构与算法课程设计名称一元多项式的计算问题学生姓名周维学号**********专业班级08计科(2)指导教师王昆仑教授2010年6月题目：（一元多项式的计算问题）要求能够按照指数降序排列建立并输出一元多项式；能够完成两个一元多项式的相加、相减，并将结果输入。
一、问题分析和任务定义1.问题分析本程序关键点是如何将输入的两个多项式相加、相减操作。
①如何将输入的一元多项式按指数的降序排列②如何确定要输入的多项式的项数；③如何将输入的两个一元多项式显示出来。
④如何将输入的两个一元多项式进行相加操作。
⑤如何将输入的两个一元多项式进行相减操作。
本程序是通过链表实现一元多项式的相加减操作。
2、任务定义此程序需要完成如下的要求：将多项式按照指数降序排列建立并输出，将两个一元多项式进行相加、相减操作，并将结果输入。
a：输入多项式的项数并建立多项式；b：输出多项式，输出形式分别为浮点和整数序列，序列按指数升序排列；c：多项式a和b相加，建立多项式a+b；d：多项式a和b相减，建立多项式a-b。
e：多项式的输出。
二、数据结构的选择和概要设计：（1）数据结构的选用A:基于链表中的节点可以动态生成的特点，以及链表可以灵活的添加或删除节点的数据结构，为了实现任意多项式的加法，减法，因此选择单链表的结构体，它有一个系数，指数，下一个指针3个元属；例如，图1中的两个线性链表分别表示一元多项式和一元多项式。
从图中可见，每个结点表示多项式中的一项。
图1 多项式表的单链存储结构B：本设计使用了以下数据结构：t ypedef struct {float coef; //系数int expn; //指数} ElemType；typedef struct LNode{ElemType data;struct LNode *next;}LNode;C：设计本程序需用到九个模块，用到以下九个子函数如下：1、void Menu()//建立菜单2、LNode *InitList() // 创建链表3、void ChaLNode(LNode *L,ElemType x)//插入链表4、LNode *AddPolyn(LNode *A,LNode *B)//多项式相加5、void Invert(LNode *L)//逆序输出链表6、void Print(LNode *L)//输出多项式7、main()//主程序模块调用链一元多项式的各种基本操作模块。
一元多项式计算(数据结构课程设计)
一元多项式计算(数据结构课程设计)一、系统设计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 问题描述.................................................... -2 -2 功能描述.................................................... - 2 -2.1课题要求 (2)2.2软件格式规定 (2)3 设计........................................................ - 2 -3.1相关函数介绍说明 (2)3.2主程序的流程基函数调用说明 (3)4 程序设计.................................................... -5 -4.1多项式存储的实现 (5)4.2加减乘除算法 (5)4.2.1加法运算的实现................................................... - 5 - 4.2.2减法运算的实现................................................... - 6 - 4.2.3乘法运算的实现................................................... - 7 - 4.2.4除法运算的实现................................................... - 7 - 4.3函数调用关系图 (8)5 运行测试.................................................... - 9 -6 设计小结................................................... - 12 -参考文献..................................................... - 12 -谢辞....................................................... - 13 -附录：程序清单............................................... - 14 -1 问题描述1.1首先是确定结构化程序设计的流程图，利用已学过的数据结构来构造二个存储多项式的结构，接着把输入，加，减，乘，除运算分成四个主要的模块：实现多项式输入模块、实现加法的模块、实现减法的模块、实现乘法的模块、实现除法的模块，然后各个模块里面还要分成若干种情况来考虑并通过函数的嵌套调用来实现其功能。
数据结构一元多项式加、减乘运算设计报告
韶关学院计算机科学学院数据结构课程设计题目：多项式运算学生姓名：学号：专业：班级：指导教师姓名及职称：讲师起止时间：年月——年月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问题解决的思路概述首先是确定结构化程序设计的流程图，利用已存在的数据结构来构造一个存储一元多项式的结构，接着把三则运算分成五个主要的模块：实现加法的模块、实现减法的模块、实现乘法的模块、实现合并同类项模块、删除结点模块，然后各个模块里面还要分成若干种情况来考虑并通过函数的嵌套调用来实现其功能。
数据结构 线性结 一元多项式的加法乘法实现
求解思路
1.多项式表示 2. 程序框架 3. 读多项式 4. 加法实现 5. 乘法实现 6. 多项式输出
多项式的表示
仅表示非零项
数组： 编程简单、调试容易
需要事先确定数组大小
一种比较好的实现方法是: 动态数组
链表：
动态性强 编程略为复杂、调试比较困难
while (t1 && t2) {
if (t1->expon == t2->expon) {
…..
}
else if (t1->expon > t2->expon) {
……
}
else {
……
}
}
while (t1) {
return 0; }
如何读入多项式
Polynomial ReadPoly() {
…… scanf("%d", &N); …… while ( N-- ) {
scanf("%d %d", &c, &e); Attach(c, e, &Rear); } ….. return P; }
4 3 4 -5 2 6 1 -2 0
两种处理方法： 1. Rear初值为NULL
在Attach函数中根据Rear是 否为NULL做不同处理
Attach
ce
Rear (当前结果表达式尾项指针)
Rear
如何读入多项式
Polynomial ReadPoly() {
…… scanf("%d", &N); …… while ( N-- ) {
多项式的乘积: (a+b)(c+d) = ac+ad+bc+bd
数据结构课程设计——《一元多项式的表达及其运算_集合的表达与运算》
目录1. 一元多项式的表示及其运算 (1)1.1 问题描述 (1)1.2 设计方案与概要设计 (1)1.3 详细设计 (2)1.4 程序运行说明与结果 (11)2. 集合的表示与运算 (12)2.1 问题描述 (12)2.2 设计方案与概要设计 (12)2.3 详细设计 (13)2.4 程序运行说明与结果 (18)3.总结与分析 (19)1. 一元多项式的表示及其运算1.1 问题描述（1）输入并建立一元多项式（2）输出一元多项式（3）多项式实现相加、相减及相乘（4）输入多项式中的未知数，计算多项式的结果（5）退出程序1.2 设计方案与概要设计程序以用户和计算机的对话方式执行，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运算命令；相应的输入数据和运算结果显示在其后。
程序执行的命令包括：（1）多项式的项作为LinkList的数据元素，coef为系数，浮点型，expn 为指数，整型（2）构造一个表示一元多项式链表La，存储多项式的项数、系数和指数等数据（3）利用两个多项式的结点构成"和多项式"，AddPolyn(&Pa,&Pb),一元多项式Pa和Pb已存在，完成多项式相加运算，即：Pa = Pa+Pb,并销毁一元多项式Pb。
（4）利用两个多项式的结点构成"差多项式"，利用两个多项式的结点构成"和多项式"，SubtractPolyn(&Pa,&Pb),一元多项式Pa和Pb已存在，完成多项式相减运算，即：Pa = Pa-Pb,并销毁一元多项式Pb。
（5）利用两个多项式的结点构成"积多项式"，利用两个多项式的结点构成"和多项式"，MultiplyPolyn(&Pa,&Pb),一元多项式Pa和Pb已存在，完成多项式相乘运算，即：Pa = Pa×Pb,并销毁一元多项式Pb（6）制作标题栏（7）使用switch语句实行多分支选择操作，当case中的常量表达式的值都没有与表达式的值匹配的，就执行default后面的语句，输出提示用户出错，并重新输入1.3 详细设计#include<stdlib.h>#include<stdio.h>#include<ctype.h>typedef struct LNode {float coef;int expn;struct LNode *next;}LNode;LNode* InitPolyn(LNode *La,int n) {if(n <= 0) return NULL;LNode *h = La = (LNode*)malloc(sizeof(LNode)), *Lb;La->coef = 0.0;int i;printf("依次输入%d个非零项（每项前一个为系数，后一个为指数）\n",n); for (i = 1; i <= n; ++i) {scanf("%f%d",&La->coef,&La->expn);if(La->coef)Lb = La;La = La->next = (LNode*)malloc(sizeof(LNode));}Lb->next = NULL;free(La);return h;}LNode* selsort(LNode *h) {LNode *g, *La, *Lb;if(!h) return NULL;float f;int i, fini = 1;for(g = h;g->next&&fini;g = g->next) {fini = 0;for(La = h,Lb = h->next;Lb;La = La->next,Lb = Lb->next) if (La->expn < Lb->expn) {f = La->coef;i = La->expn;La->coef = Lb->coef;La->expn = Lb->expn;Lb->coef = f;Lb->expn = i;fini = 1;}}for(g = h,La = g->next;La;)if(g->expn==La->expn) {g->coef += La->coef;g->next = La->next;Lb = La;La = La->next;free(Lb);}else if(g->next) {g = g->next;La = La->next;}return h;}void PrintfPoly(LNode *La) {LNode *Lb = La;if(!Lb) {putchar('0');return;}if(Lb->coef!=1) {printf("%g",Lb->coef);if(Lb->expn==1) putchar('X');else if(Lb->expn) printf("X^%d",Lb->expn); }else if(!Lb->expn) putchar('1');else if(Lb->expn==1) putchar('X');else printf("X^%d",Lb->expn);Lb = Lb->next;while (Lb) {if(Lb->coef > 0) putchar('+');if(Lb->coef!=1) {printf("%g",Lb->coef);if(Lb->expn==1) putchar('X');else if(Lb->expn) printf("X^%d",Lb->expn); }else if(!Lb->expn) putchar('1');else if(Lb->expn==1) putchar('X');else printf("X^%d",Lb->expn);Lb = Lb->next;}}Compare(LNode *a, LNode *b) {if (a->expn < b->expn) return -1;if (a->expn > b->expn) return 1;return 0;}LNode* AddPolyn(LNode *Pa, LNode *Pb) { LNode *h, *qa = Pa, *qb = Pb, *La, *Lb; float sum;h = La = (LNode*)malloc(sizeof(LNode)); La->next = NULL;while (qa && qb) {switch (Compare(qa,qb)) {case -1:La->next = qb;La = qb;qb = qb->next;break;case 0:sum = qa->coef + qb->coef;if (sum != 0.0) {La->next = qa;qa->coef = sum;La = qa;qa = qa->next;}else {Lb = qa;qa = qa->next;free(Lb);}Lb = qb;qb = qb->next;free(Lb);break;case 1:La->next = qa;La = qa;qa = qa->next;break;}}if (Pa) La->next = qa;if (Pb) La->next = qb;Lb = h;h = h->next;free(Lb);return h;}LNode* Add(LNode *Pa, LNode *Pb) { int n;puts("再输入1个一元多项式的项数"); scanf("%d",&n);Pb = InitPolyn(Pb,n);PrintfPoly(Pa);if(Pb && Pb->coef>0) printf(" + ");PrintfPoly(Pb);Pa = AddPolyn(Pa,Pb);printf(" = ");Pa = selsort(Pa);PrintfPoly(Pa);return Pa;}LNode* SubtractPolyn(LNode *Pa, LNode *Pb) { LNode *La = Pb;while(La) {La->coef *= -1;La = La->next;}return AddPolyn(Pa,Pb);}LNode* Subtract(LNode *Pa, LNode *Pb) {int n;puts("\n再输入1个一元多项式的项数"); scanf("%d",&n);Pb = InitPolyn(Pb,n);Pb = selsort(Pb);PrintfPoly(Pa);printf(" - ");putchar('(');PrintfPoly(Pb);putchar(')');Pa = SubtractPolyn(Pa,Pb);printf(" = ");PrintfPoly(Pa);return Pa;}LNode* MultiplyPolyn(LNode *Pa, LNode *Pb) { if(!Pb) return NULL;LNode *pa = Pa, *p, *q, *r, *s, *t;r = p = (LNode*)malloc(sizeof(LNode));while(pa) {p->coef = pa->coef;p->expn = pa->expn;q = p;p = p->next = (LNode*)malloc(sizeof(LNode)); pa = pa->next;}q->next = NULL;free(p);pa = Pa;t = s = (LNode*)malloc(sizeof(LNode));while(pa) {q = s;s = s->next = (LNode*)malloc(sizeof(LNode)); pa = pa->next;}q->next = NULL;free(s);pa = Pa;while(pa) {pa->coef *= Pb->coef;pa->expn += Pb->expn;}Pb = Pb->next;while(Pb) {p = r;s = t;while(p) {s->coef = p->coef * Pb->coef;s->expn = p->expn + Pb->expn;p = p->next;s = s->next;}Pa = AddPolyn(Pa,t);Pb = Pb->next;}return Pa;}LNode* Multiply(LNode *Pa, LNode *Pb) { int n;puts("\n再输入1个一元多项式的项数"); scanf("%d",&n);Pb = InitPolyn(Pb,n);Pb = selsort(Pb);putchar('(');PrintfPoly(Pa);putchar(')'); printf("×");putchar('(');PrintfPoly(Pb);putchar(')'); printf(" = ");Pa = MultiplyPolyn(Pa,Pb);Pa = selsort(Pa);PrintfPoly(Pa);return Pa;}void main() {LNode *A,*B;char s[2];int i,n;printf("\t\t\t------------------------------\n");printf("\t\t\t 一元多项式的表达与运算\n "); printf("\t\t\t------------------------------\n");printf("\t\t\t ****Made by Huangruiting****\n"); puts("\n输入1个一元多项式的项数");scanf("%d",&n);A = InitPolyn(A,n);A = selsort(A);PrintfPoly(A);p: puts("\n1:加\n2:减\n3:乘\n4:退出");getchar();q: gets(s);if(s[1]!='\0' || !isdigit(*s)) {puts("Error，请重新输入！");goto q;}i = *s-48;switch(i) {case 1:A = Add(A,B);goto p;;case 2:A = Subtract(A,B);goto p;;case 3:A = Multiply(A,B);goto p;case 4:break;default:puts("Error,请重新输入!");goto q;}}1.4 程序运行说明与结果例：x2 +3x（1）按照需要操作的多项式输入第1个多项式的项数例中多项式项数为2，输入2，回车；（2）依次输入两个非零项，两个项之间用空格间开即可，每项输入，前一个为系数，后一个为指数，例中多项式第一项系数为1，输入1，空格，指数为2，输入2，空格，第二项系数为3，输入3，空格，指数为1，输入1，回车；即显示x^2+3x(x^2表示x的2次方)。
数据结构课程设计报告一元多项式加减乘除精
数据结构课程设计报告一元多项式加减乘除精多项式想加减与乘与升降序学院计算机科学与技术专业信息安全学号 12070学生姓名陶宝中辅导教师姓名12月 22 日一、设计目的与内容了解数据结构的与算法的设计方法，独立分析和设计一元多项式加减与乘除的程序编码，经过程序编写掌握软件开发过程的问题分析，系统设计，程序编码，测试等基本方法和技能，提高综合运用所学理论知识和方法独立分析和解决问题的能力，经过这次实践将实验问题中的所涉及的对象在计算机中表示出来并对她们进行处理，掌握线除。
任务与分析本课题主要的目的是分别采用顺序和动态存储结构实现一元多项式的加法、减法和乘法。
并将操作结果分别按升序和降序输出程序的主要功能一元多项式创立建立一元多项式的顺序表和链式表，按程序提示输入每个项数据结束创立。
借助元素在存储器中的相对位置来表示数据元素之间的关系，顺序表中第i个位置表示一元多项式的第i项的系数为第i个位置存放的内容，指数为i-1。
创立一个一元多项式顺序表，对一元多项式的运算中会出现的各种情况进行分析，实现一元多项式的相加、相减、相乘操作。
用链表来表示只存储多项式中系数非零的项。
链表中的每一个结点存放多项式的一个term项结构和指向下一个节点的指针域，term又包括系数和指数两个域分别存放该项的系数、。
创立一元多项式链表，对一元多项式的运算中会出现的各种可能情况进行分析，实现一元多项式的相加、相减、相乘操作。
一元多项式的加法对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项；对于两个一元多项式中所有指数不相同的项，则分别复抄到和多项式中去。
一元多项式的减法对于两个一元多项式中所有指数相同的项，对应系数相减，若其差不为零，则构成“和多项式”中的一项；对于两个一元多项式中所有指数不相同的项，将其按减法规则复抄到差多项式中去。
一元多项式的乘法将乘法运算分解为一系列的加法运算利用两个一元多项式相加的算法实现。
最新数据结构一元多项式课程设计报告
q=q->next;｝ //如果多项式 a 的指数小于多项式 b 的指数，q 后移
这个模块主要是比较两个多项式的指数大小
D、两个一元多项式的相加
while(p&&q)//判断 q,p 是不是为空，如果不为空则继续往下进行
{
a=p->data.expn;b=q->data.expn;
if(a<b)
{
pre=p;p=p->next;//p 后移
①指针 A 所指结点的指数值<指针 B 所指结点的指数值，则应摘取 A 指针所指结点插 入到“和多项式”链表中去；
②指针 A 所指结点的指数值>指针 B 所指结点的指数值，则应摘取指针 A 所指结点插 入到“和多项式”链表中去；
③指针 A 所指结点的指数值=指针 B 所指结点的指数值，则将两个结点中的系数相加， 若和数不为零，则修改 A 所指结点的系数值，同时释放 B 所指结点；反之，从多项式 A 的 链表中删除相应结点，并释放指针 A 和 B 所指结点。例如，由图 2 中的两个链表表示的多 项式相加得到的“和多项式”链表如图 2 所示，图中的长方框表示已被释放的结点。
4
printf("+X^%-2f", p->data.expn);
else printf("+X");
}
if (p->data.expn == 0)
printf("+%.2f", i);
}
}
if (!flag)
//是第一项
{
if (p->data.coef!=1)
{
if (p->data.expn != 0)
数据结构课程设计报告顺序结构动态链表结构下的一元多项式的加法减法乘法的实现。
山东理工大学计算机学院课程设计（数据结构）级班名姓号学指导教师二○一二年一月十日课程设计任务书及成绩评定顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的课题名称实现。
Ⅰ、题目的目的和要求：1. 巩固和加深对数据结构的理解，通过上机实验、调试程序，加深对课本知识的理解，最终使学生能够熟练应用数据结构的知识写程序。
1）通过本课程的学习，能熟练掌握几种基本数据结构的基本操作。
2）能针对给定题目，选择相应的数据结构，分析并设计算法，进而给出问题的正确求解过程并编写代码实现。
2．设计题目要求：1)首先判定多项式是否稀疏2)分别采用顺序和动态存储结构实现；结果M(x)3)中无重复阶项和无零系数项；要求输出结果的升幂和降幂两种排列情况； 4)Ⅱ、设计进度及完成情况Ⅲ、主要参考文献及资料[1] 严蔚敏数据结构（C语言版）清华大学出版社 1999[2] 严蔚敏数据结构题集（C语言版）清华大学出版社 1999[3] 谭浩强 C语言程序设计清华大学出版社[4] 与所用编程环境相配套的C语言或C++相关的资料Ⅳ、成绩评定：设计成绩：（教师填写）（签字）指导老师：日十月一年二○一二目录第一章概述 (1)第二章系统分析 (2)第三章概要设计 (3)第四章详细设计 (4)第五章运行与测试 (17)第六章总结与心得 (19)20参考文献………………………………………………………………．第一章概述课程设计是实践性教学中的一个重要环节，它以某一课程为基础，可以涉及和课程相关的各个方面，是一门独立于课程之外的特殊课程。
课程设计是让同学们对所学的课程更全面的学习和应用，理解和掌握课程的相关知识。
《数据结构》是一门重要的专业基础课，是计算机理论和应用的核心基础课程。
数据结构课程设计，要求学生在数据结构的逻辑特性和物理表示、数据结构的选择和应用、算法的设计及其实现等方面，加深对课程基本内容的理解。
同时，在程序设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练。
数据结构课程设计一元多项式的加减法运算
武汉理工大学华夏学院课程设计报告书课程名称：数据结构与算法分析题目：用C语言实现一元多项式的加减法运算系名：信息工程系专业班级：物联网工程1122班姓名：隋明超学号： 10213312201 指导教师:司晓梅2014年 1 月 3 日武汉理工大学华夏学院信息工程系课程设计任务书课程名称：数据结构与算法分析指导教师：司晓梅班级名称：物联网1121-2 开课系、教研室：信息系计算机一、课程设计目的与任务《数据结构》课程设计是为训练学生的数据组织能力和提高程序设计能力而设置的增强实践能力的课程。
目的：学习数据结构课程，旨在使学生学会分析研究数据对象的特性，学会数据的组织方法，以便选择合适的数据的逻辑结构和存储结构以及相应操作，把现实世界中的问题转换为计算机内部的表示和处理，这就是一个良好的程序设计技能训练的过程。
提高学生的程序设计能力、掌握基本知识、基本技能，提高算法设计质量与程序设计素质的培养就是本门课程的课程设计的目的。
任务：根据题目要求，完成算法设计与程序实现，并按规定写出课程设计报告。
二、课程设计的内容与基本要求设计题目：用C语言实现一元多项式的加减法计算〔问题描述〕输入并建立两个多项式并输出多项式设计一个程序：对两个多项式进行加、减法运算，建立一个新多项式并输出。
〔实现提示〕：选择单链表存储多项式具体要完成的任务是：A. 编制完成上述问题的C语言程序、进行程序调试并能得出正确的运行结果。
B. 写出规范的课程设计报告书；三、课程设计步骤及时间进度和场地安排时间：本课程设计安排在第18周地点：现代教育中心具体时间安排如下：第一天：布置题目，确定任务、查找相关资料第二天～第四天：功能分析，编写程序，调试程序、运行系统；第五天上午：撰写设计报告；第五天下午：程序验收、答辩。
四、课程设计考核及评分标准课程设计考核将综合考虑学生的系统设计方案、运行结果、课程设计报告书的质量、态度、考勤、答辩情况等各因素。
数据结构课程设计——一元多项式计算
数据结构课程设计——一元多项式计算一、课程设计题目及要求二、设计思路和方法三、程序流程图四、程序代码及注释五、测试结果及分析六、结论七、参考文献本次课程设计的题目为“一元多项式计算”，要求设计一个程序，能够实现一元多项式的加、减、乘、求导和求值等操作。
在设计思路和方法上，我们采用了链表的数据结构来存储多项式，同时设计了相应的函数来实现各种操作。
程序的流程图如下所示：插入流程图）程序的代码及注释如下所示：插入代码及注释）在测试结果及分析方面，我们对程序进行了多组测试，并对其进行了详细的分析和比较。
结果表明，我们的程序能够正确地实现各种操作，并且具有较高的效率和稳定性。
综上所述，本次课程设计的目标已经得到了圆满地实现，我们对于所取得的成果感到非常满意。
同时，我们也希望能够通过这次课程设计，加深对于数据结构及其应用的理解和掌握，为今后的研究和工作打下坚实的基础。
设计目标：本课程设计旨在结合理论与实际应用，提高学生组织数据及编写大型程序的能力。
通过掌握数据组织、算法设计和算法性能分析的方法，培养学生良好的程序设计能力。
具体实现是利用单链表表示一元多项式，实现多项式的输入、建立、输出、相加、相减和相乘。
总体设计：2.1 数据结构描述与定义：一元多项式定义系数和指数结构如下：coef，expn和next。
定义多项式的结构为线性链表的存储结构，每个结点包含三个元素：系数coef，指数expn和指向下一个结点的指针*next。
多个单项式通过指针连接起来，形成一个多项式。
2.2 模块设计：从实现多项式运算过程的角度来分析，至少需要以下子功能模块：多项式创建、销毁、输出、相加、相减和相乘。
定义并调用的函数有：Insert、CreatePolyn、DestroyPolyn、PrintPolyn、AddPolyn、SubtractPolyn、XXX和main函数。
注：该文章中没有明显的格式错误和需要删除的段落，因此没有进行小幅度改写。
数据结构课程设计报告顺序结构动态链表结构下的一元多项式的加法减法乘法的实现
数据结构课程设计报告顺序结构动态链表结构下的一元多项式的加法减法乘法的实现山东理工大学计算机学院课程设计（数据结构）班级姓名学号指导教师二○一二年一月十日课程设计任务书及成绩评定课题名称顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现。
Ⅰ、题目的目的和要求：1. 巩固和加深对数据结构的理解，通过上机实验、调试程序，加深对课本知识的理解，最终使学生能够熟练应用数据结构的知识写程序。
1）通过本课程的学习，能熟练掌握几种基本数据结构的基本操作。
2）能针对给定题目，选择相应的数据结构，分析并设计算法，进而给出问题的正确求解过程并编写代码实现。
2．设计题目要求：1)首先判定多项式是否稀疏2)分别采用顺序和动态存储结构实现；3)结果M(x)中无重复阶项和无零系数项；4)要求输出结果的升幂和降幂两种排列情况；Ⅱ、设计进度及完成情况日期内容1.2-1.3 选取参考书，查阅有关文献资料，完成资料搜集和系统分析工作。
1.4~1.5 创建相关数据结构,录入源程序。
1.6~1.7 调试程序并记录调试中的问题，初步完成课程设计报告。
1.9 上交课程设计报告打印版并进行课程设计答辩，要求每个同学针对自己的设计回答指导教师3-4个问题。
考核结束后将课程设计报告和源程序的电子版交班长统一刻光盘上交。
Ⅲ、主要参考文献及资料[1] 严蔚敏数据结构（C语言版）清华大学出版社 1999[2] 严蔚敏数据结构题集（C语言版）清华大学出版社 1999[3] 谭浩强 C语言程序设计清华大学出版社[4] 与所用编程环境相配套的C语言或C++相关的资料Ⅳ、成绩评定：设计成绩：（教师填写）指导老师：（签字）二○一二年一月十日目录第一章概述 (1)第二章系统分析 (2)第三章概要设计 (3)第四章详细设计 (4)第五章运行与测试 (17)第六章总结与心得 (19)参考文献 (20)第一章概述课程设计是实践性教学中的一个重要环节，它以某一课程为基础，可以涉及和课程相关的各个方面，是一门独立于课程之外的特殊课程。
一元多项式的计算数据结构专业课程设计
一元多项式的计算数据结构专业课程设计一元多项式的计算—加，减摘要(题目)一元多项式计算任务：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减，并将结果输入；目录一:引言:通过C语言使用链式存储结构实现一元多项式加法、减法和乘法的运算。
按指数降序排列。
二：需求分析建立一元多项式并按照指数降序排列输出多项式，将一元多项式输入并存储在内存中，能够完成两个多项式的加减运算并输出结果三：概要设计存储结构：一元多项式的表示在计算机内可以用链表来表示，为了节省存储空间，只存储多项式中系数非零的项。
链表中的每一个结点存放多项式的一个系数非零项，它包含三个域，分别存放该项的系数、指数以及指向下一个多项式项结点的指针。
创建一元多项式链表，对一元多项式的运算中会出现的各种可能情况进行分析，实现一元多项式的相加、相减操作。
1．单连表的抽象数据类型定义：ADT List{ 数据对象：D={ai|ai∈ElemSet,i=1,2,…,n,n≥0} 数据关系：R1={<ai-1,ai>| ai-1, ai∈D,i=2,…,n}基本操作：InitList（＆L）//操作结果：构造一个空的线性表CreatPolyn(&L)//操作结果：构造一个以单连表存储的多项试DispPolyn(L)//操作结果：显示多项试Polyn(&pa,&pb)//操作结果：显示两个多项试相加，相减的结果} ADT List2．本程序包含模块： typedef struct LNode //定义单链表{}LNode,*LinkList;void InitList(LinkList &L) //定义一个空表{ }void CreatPolyn(LinkList &L) //用单链表定义一个多项式{ }void DispPolyn(LinkList L) //显示输入的多项式{ }void Polyn(LinkList &pa,LinkList &pb){}void main(){//定义一个单连表；cout<<endl<<" *****************欢迎来到一元多项式计算程序 *************** "<<endl;LNode *L1,*L2;Polyn(L1,L2); }加，减操作模块——实现加减操作各模块之间的调用关系如下：主程序模块加法操作模块 减法操作模块基本算法：1、输入输出（1）功能：将要进行运算的多项式输入输出。
一元多项式的加减求导运算算法(数据结构算法)
if(expo1==0)
{
i=1;
cout<<coef1;
}
else if(expo1==1)
{
i=1;
if(coef1==1)
cout<<"X";
else if(coef1==-1)
cout<<"-X";
else
cout<<coef1<<"X";
}
else
{
i=1;
if(coef1==1) cout<<"XA"<<expo1;
temp=h;
h->next =NULL;〃头结点
cout<<"多项式"<<o<<"的项数:";cin»num;
for(i nt i=1;i<=nu m;i++)
{
cout<<"请输入第"<<i<<"项"<<endl; cout<<"系数:";
cin> >coef1;
cout<<"指数:";
cin> >expo1; data=new polyno de; data->coef=coef1;
(2)计算多项式A与B的和，即建立多项式A+B
(3)按照指数升序次序，输出多项式AB、A+B
(4)计算多项式A与B的差，即建立多项式A-B;
(5)计算多项式A的导函数A，。
数据结构课程设计《一元多项式的四则运算》
一元多项式的四则运算学生姓名：阳超指导老师：易禹摘要本课程设计主要解决一元多项式的运算问题，通过链表的使用，实现对一元多项式的构建、录入、存储、打印、以及之间的运算。
在本课程设计中，程序设计语言为C++语言，程序运行平台为Windows/98/2000/XP，程序采用了链表存储方法以及结构化和模块化的设计方法，通过调试运行，可以进行多项式的加、减、乘运算，勉强实现了设计目标，并且经过适当完善后，将可应用到实际中解决某些问题。
关键词程序设计；C++ ；一元多项式；运算1 引言一般来说，我们只知道数学上的一元多项式的运算，这一般都是用笔来进行运算的，然而此课程设计将一元多项式的运算用电脑来进行，只需要将多项式输入，然后就可以出结果，速度快，省去了认为计算的环节，在现实中带来不少方便。
1.1 课题背景一元多项式的运算，虽然无法直接在除数学外的其他领域作出贡献，但是在数学上，它可以为人们解决一些自己动笔动手很难解决的问题，比如说那些很长很长的多项式，用笔算可能要算半天，但是用该程序，只需短短的几秒钟，所以它给人们带来了不少方便，同时相信它也能间接地为其他领域做出贡献。
1.2 课程设计目的个人觉得，该数据结构课程设计一方面可以让自己更加熟悉那些些常用的数据结构，掌握数据结构内在的逻辑关系，以及它们在计算机中的存储表示，和对它们实行的各种运算；另一方面，可以让自己对于整体和局部，以及结构化和模块化编程有一个更深层次的了解。
作为网络工程的学生，虽然之前有过一次Ｃ语言课程设计，但是深知自己编程能力尚为欠缺，所以这一次数据结构课程设计是对我的编程能力和组织能力的又一次考验。
1.3课程设计内容本课程设计是用链表实现一元多项式的存储及运算，其中包括多项式系数及指数的录入（即一元多项式的录入），以及储存、一元多项式的显示、一元多项式之间的加、减、乘法运算。
2 设计思路与方案2.1设计思路该系统使用Ｃ++语言进行开发和实现，程序中的各个功能分别由不同的的函数实现，然后在main 函数中调用实现。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
武汉理工大学华夏学院课程设计报告书课程名称：数据结构与算法分析题目：用C语言实现一元多项式的加减法运算系名：信息工程系专业班级：物联网工程1122班姓名：隋明超学号：10213312201指导教师:司晓梅2014年1 月 3 日武汉理工大学华夏学院信息工程系课程设计任务书课程名称：数据结构与算法分析指导教师：司晓梅班级名称：物联网1121-2 开课系、教研室：信息系计算机一、课程设计目的与任务《数据结构》课程设计是为训练学生的数据组织能力和提高程序设计能力而设置的增强实践能力的课程。
目的：学习数据结构课程，旨在使学生学会分析研究数据对象的特性，学会数据的组织方法，以便选择合适的数据的逻辑结构和存储结构以及相应操作，把现实世界中的问题转换为计算机内部的表示和处理，这就是一个良好的程序设计技能训练的过程。
提高学生的程序设计能力、掌握基本知识、基本技能，提高算法设计质量与程序设计素质的培养就是本门课程的课程设计的目的。
任务：根据题目要求，完成算法设计与程序实现，并按规定写出课程设计报告。
二、课程设计的内容与基本要求设计题目：用C语言实现一元多项式的加减法计算〔问题描述〕输入并建立两个多项式并输出多项式设计一个程序：对两个多项式进行加、减法运算，建立一个新多项式并输出。
〔实现提示〕：选择单链表存储多项式具体要完成的任务是：A. 编制完成上述问题的C语言程序、进行程序调试并能得出正确的运行结果。
B. 写出规范的课程设计报告书；三、课程设计步骤及时间进度和场地安排时间：本课程设计安排在第18周地点：现代教育中心具体时间安排如下：第一天：布置题目，确定任务、查找相关资料第二天～第四天：功能分析，编写程序，调试程序、运行系统；第五天上午：撰写设计报告；第五天下午：程序验收、答辩。
四、课程设计考核及评分标准课程设计考核将综合考虑学生的系统设计方案、运行结果、课程设计报告书的质量、态度、考勤、答辩情况等各因素。
具体评分标准如下：（1）设计方案正确，具有可行性、创新性； 30分（2）系统开发效果较好； 20分（3）设计报告规范、课程设计报告质量高； 20分（4）课程设计答辩时，问题回答正确； 20分（5）态度认真、刻苦钻研、遵守纪律； 10分按上述五项分别记分后求和，总分按五级制记载最后成绩。
优秀（100～90分），良好（80～89分），中等（70～79分），及格（60～69分），不及格（0～59分）1.设计题目：用C语言实现一元多项式的加减法运算2.开发环境、采用的语言：(1)Windows XP 中文操作系统(2) Visual C++ 6.03.设计思想（对你的整个设计思路作出说明）：3.1问题描述：输入并建立两个多项式并输出多项式，对两个多项式进行加、减法运算，建立一个新多项式并输出。
3.2问题思考：用C语言编写一段程序，该程序的功能相当于一个一元多项式的计算器，能够实现按照指数降幂建立并输出多项式，并且能够完成多个多项式的相加、相减运算及结果输出的功能。
此程序的数据结构是选择用带表头结点的单链表存储多项式。
虽然一元多项式可以用顺序和链表存储结果表示，但顺序结构的最大长度很难确定。
比如当多项式的系数较大时，此时就会浪费存储空间，所以应该选用链表结构来存储一元多项式。
但链表的结构体可以用来存储多项式的系数、指数、下一个指针3个元素，这样便于实现任意多项式的加法、减法运算。
3.3功能设计：（1）多项式建立：提示用户输入两个多项式A和B，输入形式为：1)先输入多项式A的项数，回车2)输入多项式A第一项的系数，空格隔开输入多项式A第一项的指数，3)继续输入多项式A的其他项，输入方式与上同；4)再建立多项式B，数据输入方式与建立多项式A相同。
（2）功能项：设计一个功能项，分别为1.输出多项式a和b2.输出多项式a+b3.输出多项式a-b4.退出（3）执行操作：此时用户可以根据需要选择功能项中四项进行输出。
4.程序总的流程图：通过设计思想，可设计出如图4-1所示的一元多项式总流程图：图4.1一元多项式总流程图5. 数据结构说明及模块算法说明（或流程图）：、5.1存储结构：一元多项式的表示在计算机内可以用链表来表示，为了节省存储空间，只存储多项式中系数非零的项。
链表中的每一个结点存放多项式的一个系数非零项，它包含三个域，分别存放该项的系数、指数以及指向下一个多项式项结点的指针。
创建一元多项式链表，对一元多项式的运算中会出现的各种可能情况进行分析，实现一元多项式的相加、相减操作。
5.2基本算法：（1）一元多项式的建立：输入多项式采用头插法的方式，输入多项式中的一个项的系数和指数，就产生一个新开始 申请结点空间 输入多项式的项数输入多项式各项的系数 M, 指数 N输出已输入的多项式进行多项式的输出、加法、减法运算结束否是是否输入正确的结点，建立起它的右指针，并用头结点指向它；为了判断一个多项式是否输入结束，定义一个结束标志，当输入非0时就继续；输入为0时，就结束一个多项式的输入。
（2）显示一元多项式：如果系数是大于0的话就输出<+系数M^指数>的形式；如果系数是小于0的话就输出<系数x^指数>的形式；如果指数为0的话就直接输出<系数>；如果指数是1的话就直接输出<+M>；如果指数是-1的话，就直接输出<-M>。
（3）一元多项式加法运算：从两个多项式的头部开始判断，当两个多项式的某一项度不为空时，假设P、Q分别指向多项式A和多项式B中当前进行比较的结点，然后比较两个结点中的指数项，有三种情况：1、当P所指结点的指数小于Q的话，就应该复制P的结点到多项式链中。
2、P所指结点的指数如果大于Q的指数的话，就应该复制Q的结点到多项式链中。
3、当P所指结点的指数等于Q所指结点的指数时，则将两个结点中的系数相加，若和不为0，则修改P所指结点的系数值，同时释放Q所指结点；若和为0，从多项式A的链表中删除相应结点，并释放P、Q所指结点。
加法流程图如图5.2-1所示：图5.2-1一元多项式加法运算流程图（4）一元多项式的减法从两个多项式的头部开始判断，当两个多项式的某一项度不为空时，假设P 、Q 分别指向多项式A 和多项式B 中当前进行比较的结点，然后比较两个结点中的指数项，有三种情况：1、当P 所指结点的指数小于Q 的话，就应该复制P 的结点到多项式链中。
2、P 所指结点的指数如果大于Q 的指数的话，就应该复制Q 的结点到多项式链中，并将建立的结点系数变为相反数。
3、当P 所指结点的指数等于Q 所指结点的指数时，并将Q 的结点系数变为相反数，并将两个结点中的系数相加，若和不为0，则修改P 所指结点的系数值，同时释放Q开始定义存储结果的空链 r是否输出存储多项式的和的链r 结束是否同指数项系数相加后存入r把p 中各项系数改变符号后存入r直接把q 中各项存入r存储多项式2的空链Q 是否为空存储多项式1的空链P 是否为空 合并同类项所指结点；若和为0，从多项式A 的链表中删除相应结点，并释放P 、Q 所指结点。
减法流程图如图5.2-2所示：图5.2-2 一元多项式减法运算流程图6. 程序运行说明及结果截图：6.1欢迎界面：开始定义存储结果的空链 r是否输出存储多项式的和的链r结束是否同指数项系数相加后存入r 中把p 中各项系数改变符号后存入r 中直接把q 中各项存入r存储多项式2的空链Q 是否为空存储多项式1的空链P 是否为空合并同类项程序打开，首先显示上的是欢迎界面，在欢迎界面下方有第一个多项式的输入模块。
图 6.1欢迎界面6.2输入界面：看到输入界面后，输入第一个多项式的项数，接下来输入这个多项式第一项的系数，空格继续输入这个多项式的指数。
回车继续输入下一项，输入完后回车输入下一个多项式图6.2输入界面6.3功能选项：当数据输入完成后进入功能选项，在功能选项可以选择自己想要实现的功能进行操作。
图6.3功能选项6.4多项式输出：在执行操作中选择1，输出多项式a和b。
图6.4多项式输出6.5多项式相加：在执行操作中选择2，输出多项式a+b。
图6.5多项式相加6.6多项式相减：在执行操作中选择3，输出多项式a-b。
图6.6多项式相减7. 程序调试及测试过程记载：本次课程设计中，经过反复调试，程序已经可以正常运行。
在设计该算法时，出现了一些问题，例如在建立链表时头指针的设立导致了之后运用到相关的指针时没能很好的移动指针出现了数据重复输出或是输出系统缺省值，不能实现算法。
实现加法时该链表并没有向通常那样通过建立第三个链表来存放运算结果，而是再度利用了链表之一来进行节点的比较插入删除等操作。
为了使输入数据按指数降序排列，可在数据的输入后先做一个节点的排序函数，通过对链表排序后再进行之后加减运算。
8.总结及心得体会：在这次课程设计中，我遇到了不少困难，但是在我的坚持和虚心请教中都得到顺利解决。
在这次课程设计中，我发现理论必须和实践相结合，才能真正学会程序设计，才能完成一个课题。
在这次设计中我参考了不少书籍，从中学到了课堂中无法学到的许多东西，对此我感到很兴奋。
原来不断的学习，不断的探索是苦中带着甜，虽然经历了不少弯路，经历了不少挫折，但当程序调试成功后，当运行能达到要求后，我感到十二分成就感。
面对课题，要展现自信出来，这是成功的一半，在这个设计过程中，不懂的可以虚心向老师请教，与同学交流经验。
态度是成功的基石！在我这课题中，关键在于对一元多项式的表示及相加的操作。
这个实际问题，在学习过的知识中找到一种合适的模型来模拟，数据结构的选择是主要，而对于编写代码，所涉及的并不是很复杂，对于链表数据存储访问方式，在C语言的学习过程中已经有过很多讲解，为了进一步了解，我还阅读了一些数据结构中关于链表的叙述。
对于这个课题，运用C语言简单一点的结构化程序设计已足能满足要求而不至于结构过于复杂，为了简便的实现插入操作，我选择了一个带表头结点的链表。
在写源代码时要注意指针使用的正确性，为产生的新结点需及时分配存储空间。
在设计中将问题抽象化，而完成后在运行时，可以说是用抽象的数据模型来解决实际问题。
我的这个课题相比较于其他同学来说，是相对简单的一点的。
在现实中，很多功能现在都没法实现，还有不少操作需进一步完善，这次程序设计有很多不足处，可能是因为经验不足，对问题预期不够等一些不可预见的原因所致，这些都是我以后要汲取的教训。
9. 附录：源代码（注意要加上详细的注释）#include<stdio.h>#include<malloc.h>typedef struct Polynomial{float coef;int expn;struct Polynomial *next;}*Polyn,Polynomial; //Polyn为结点指针类型void Insert(Polyn p,Polyn h){if(p->coef==0) free(p); //系数为0的话释放结点else{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;}}}//InsertPolyn CreatePolyn(Polyn head,int m){//建立一个头指针为head、项数为m的一元多项式int i;Polyn p;p=head=(Polyn)malloc(sizeof(struct Polynomial));head->next=NULL;for(i=0;i<m;i++){p=(Polyn)malloc(sizeof(struct Polynomial));//建立新结点以接收数据 printf("请输入第%d项的系数与指数:",i+1);scanf("%f %d",&p->coef,&p->expn);Insert(p,head); //调用Insert函数插入结点}return head;}//CreatePolynvoid DestroyPolyn(Polyn p){//销毁多项式pPolyn 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) { //若多项式为空，输出0putchar('0');printf("\n");return;}while (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');else if(q->expn==1) putchar('X');else printf("X^%d",q->expn);}if(q->coef==-1){if(!q->expn) printf("-1");else if(q->expn==1) printf("-X");else printf("-X^%d",q->expn);}}q=q->next;flag++;}//whileprintf("\n");}//PrintPolynint compare(Polyn a,Polyn b){if(a&&b){if(!b||a->expn>b->expn) return 1;else if(!a||a->expn<b->expn) return -1;else return 0;}else if(!a&&b) return -1;//a多项式已空，但b多项式非空else return 1;//b多项式已空，但a多项式非空}//comparePolyn AddPolyn(Polyn pa,Polyn pb){//求解并建立多项式a+b，返回其头指针 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;}}//switchif(qc->coef!=0){qc->next=hc->next;hc->next=qc;hc=qc;}else free(qc);//当相加系数为0时，释放该结点 }//whilereturn headc;}//AddPolynPolyn SubtractPolyn(Polyn pa,Polyn pb){//求解并建立多项式a+b，返回其头指针 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;return pd;}//SubtractPolynint main(){int m,n,flag=0;float x;Polyn pa=0,pb=0,pc,pd,pe,pf;//定义各式的头指针，pa与pb在使用前付初值NULL printf("***************************欢迎您的使用**************************\n");printf("请输入多项式a的项数:");scanf("%d",&m);pa=CreatePolyn(pa,m);//建立多项式aprintf("*****************************************************************\n");printf("请输入多项式b的项数:");scanf("%d",&n);pb=CreatePolyn(pb,n);//建立多项式b//输出菜单printf("*****************************************************************\n");printf("功能项：\n\t1.输出多项式a和b\n\t2.建立多项式a+b\n\t3.建立多项式a-b\n");printf("\t4.退出\n**************************请输入功能项编号***********************\n");for(;;flag=0){printf("执行操作：");scanf("%d",&flag);if(flag==1){printf("多项式a：");PrintPolyn(pa);printf("多项式b：");PrintPolyn(pb);printf("*************************请输入功能项编号************************\n");continue;}if(flag==2){pc=AddPolyn(pa,pb);printf("多项式a+b：");PrintPolyn(pc);DestroyPolyn(pc);printf("*************************请输入功能项编号************************\n");continue;}if(flag==3){pd=SubtractPolyn(pa,pb);printf("多项式a-b：");PrintPolyn(pd);DestroyPolyn(pd);printf("**************************请输入功能项编号***********************\n");continue;}if(flag==4) break;if(flag<1||flag>4) printf("Error!!!\n");continue;}//forDestroyPolyn(pa);DestroyPolyn(pb);return 0;}设计过程中质疑（或答辩）记载：1.如何创建一个多项式？创建一个新的一元多项式，是创建一个单链表，然后用do循环输入一元多项式从高幂项到低幂项的顺序输入各项的系数和幂，以“系数，指数”的格式输入数据，当系数与指数两项同时为零时停止输入。