数据结构 一元多项式的计算
数据结构课程设计-一元多项式的加法、减法、乘法的实现
数据结构课程设计-一元多项式的加法、减法、乘法的实现一、设计题目一元多项式的加法、减法、乘法的实现。
二、主要内容设有一元多项式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、算法思想根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应指数相加（减），若其和（差）不为零，则构成“和（差）多项式”中的一项；对于两个一元多项式中所有指数不相同的项，则分别写到“和（差）多项式”中去。
因为多项式指数最高项以及项数是不确定的，因此采用线性链表的存储结构便于实现一元多项式的运算。
为了节省空间，我采用两个链表分别存放多项式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. 引言本文档旨在介绍数据结构中一元多项式的运算方法。
一元多项式是指在一个变量上的多项式，其中每一项由一个系数和一个指数组成。
我们将会讨论一元多项式的表示、存储和基本运算，包括多项式的加法、减法、乘法和求导等操作。
2. 一元多项式的表示和存储2.1 一元多项式的定义一元多项式是指在一个变量x上的多项式，每一项由一个系数和一个指数组成，例如：2x^3 - 5x^2 + 3x + 1.其中，2、-5、3和1分别是系数，3、2、1和0分别是指数。
2.2 一元多项式的表示方法一元多项式可以使用数组、链表或其他数据结构来表示。
在本文中，我们选择使用数组来表示一元多项式。
数组的索引代表指数，数组的元素代表系数。
例如，多项式 2x^3 - 5x^2 + 3x + 1 可以表示为 [1, 3, -5, 2]。
2.3 一元多项式的存储结构为了表示一元多项式，我们可以使用一个数组来存储多项式的系数。
数组的长度应该比多项式的最高指数大1.数组的索引代表指数，数组的元素代表系数。
例如，数组 [1, 3, -5, 2] 表示的多项式 2x^3 - 5x^2 + 3x + 1 中，索引0对应指数为3的项，索引1对应指数为2的项，以此类推。
3. 一元多项式的基本运算3.1 一元多项式的加法一元多项式的加法是指将两个多项式相加，并合并同类项。
具体操作如下：- 将两个多项式的系数相加，并将结果存储在一个新的多项式中。
- 遍历新的多项式，将相邻的相同指数的项合并。
3.2 一元多项式的减法一元多项式的减法是指将一个多项式减去另一个多项式，并合并同类项。
具体操作如下：- 将两个多项式的系数相减，并将结果存储在一个新的多项式中。
- 遍历新的多项式，将相邻的相同指数的项合并。
3.3 一元多项式的乘法一元多项式的乘法是指将两个多项式相乘，并合并同类项。
具体操作如下：- 遍历一个多项式的每一项，与另一个多项式的每一项相乘。
数据结构一元多项式的运算
数据结构一元多项式的运算数据结构一元多项式的运算1、引言1.1 研究背景1.2 研究目的2、一元多项式的定义2.1 一元多项式的概念2.2 一元多项式的表示方法2.3 一元多项式的次数和系数2.4 一元多项式的零多项式和常数项2.5 一元多项式的加法运算2.6 一元多项式的减法运算2.7 一元多项式的乘法运算3、一元多项式的特殊运算3.1 一元多项式的乘方运算3.2 一元多项式的取余运算3.3 一元多项式的求导运算3.4 一元多项式的积分运算3.5 一元多项式的复合运算4、一元多项式的应用4.1 一元多项式在数学中的应用4.2 一元多项式在计算机科学中的应用4.3 一元多项式在工程领域中的应用5、实例分析5.1 实例一：一元多项式的相加减5.2 实例二：一元多项式的乘法运算5.3 实例三：一元多项式的特殊运算应用6、结论附件：附件一：一元多项式的代码实现示例法律名词及注释：1.一元多项式: 指仅有一个未知数的多项式。
2.多项式的次数: 多项式中各项最高次幂的次数。
3.多项式的系数: 多项式中各项中未知数的系数。
4.零多项式: 所有系数均为0的多项式。
5.常数项: 多项式中次数为0的项，即常数项。
6.多项式的加法运算: 将两个多项式相同次项的系数相加。
7.多项式的减法运算: 将两个多项式相同次项的系数相减。
8.多项式的乘法运算: 将两个多项式的各项相乘，并根据指数相加合并同类项。
9.多项式的乘方运算: 将一个多项式自乘n次。
10.多项式的取余运算: 两个多项式相除后的余数部分。
11.多项式的求导运算: 对多项式中的每一项进行求导操作。
12.多项式的积分运算: 对多项式中的每一项进行积分操作。
13.多项式的复合运算: 将一个多项式代入另一个多项式中进行运算。
c语言数据结构实现——一元多项式的基本运算
c语言数据结构实现——一元多项式的基本运算在C语言中，一元多项式的表示与运算是常见的数据结构操作之一。
一元多项式由一系列具有相同变量的单项式组成，每个单项式由系数和指数组成。
本文将介绍如何使用C语言实现一元多项式的基本运算，包括多项式的创建、求和、差、乘积等操作。
首先，我们需要定义一个结构体来表示单项式。
每个单项式由一个系数和一个指数组成，我们可以将其定义如下：```cstruct term{float coefficient; // 系数int exponent; // 指数};typedef struct term Term;```接下来，我们可以定义一个结构体来表示一元多项式。
一元多项式由一系列单项式组成，可以使用一个动态数组来存储这些单项式。
```cstruct polynomial{Term* terms; // 单项式数组int num_terms; // 单项式数量};typedef struct polynomial Polynomial;```现在，我们可以开始实现一元多项式的基本运算了。
1. 创建一元多项式要创建一元多项式，我们需要输入每个单项式的系数和指数。
我们可以使用动态内存分配来创建一个适应输入的单项式数组。
```cPolynomial create_polynomial(){Polynomial poly;printf("请输入多项式的项数：");scanf("%d", &poly.num_terms);poly.terms = (Term*)malloc(poly.num_terms * sizeof(Term));for(int i = 0; i < poly.num_terms; i++){printf("请输入第%d个单项式的系数和指数：", i+1);scanf("%f %d", &poly.terms[i].coefficient, &poly.terms[i].exponent);}return poly;}```2. 求两个一元多项式的和两个一元多项式的和等于对应指数相同的单项式系数相加的结果。
数据结构课程设计(一元多项式)
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.1设计题目与要求1.1.1设计题目1）一元多项式计算任务：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减，并将结果输入；基本要求：在上交资料中请写明：存储结构、多项式相加的基本过程的算法（可以使用程序流程图）、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法；本程序关键点是如何将输入的两个多项式相加、相减操作。
①如何将输入的一元多项式按指数的降序排列②如何确定要输入的多项式的项数；③如何将输入的两个一元多项式显示出来。
④如何将输入的两个一元多项式进行相加操作。
⑤如何将输入的两个一元多项式进行相减操作。
本程序是通过链表实现一元多项式的相加减操作。
1.1.2、任务定义此程序需要完成如下的要求：将多项式按照指数降序排列建立并输出，将两个一元多项式进行相加、相减操作，并将结果输入。
a：输入多项式的项数并建立多项式；b：输出多项式，输出形式分别为浮点和整数序列，序列按指数升序排列；c：多项式a和b相加，建立多项式a+b；d：多项式a和b相减，建立多项式a-b。
e：多项式的输出。
1.2 数据结构的选择和概要设计：1.2.1数据结构的选用A:基于链表中的节点可以动态生成的特点，以及链表可以灵活的添加或删除节点的数据结构，为了实现任意多项式的加法，减法，因此选择单链表的结构体，它有一个系数，指数，下一个指针3个元属；例如，图1中的两个线性链表分别表示一元多项式和一元多项式。
从图中可见，每个结点表示多项式中的一项。
图1 多项式表的单链存储结构B：本设计使用了以下数据结构：typedef struct node{int xs; /*系数*/int zs; /*指数*/struct node * next; /*next指针*/}Dnode,* Dnodelist;C：设计本程序需用到八个模块，用到以下八个子函数如下：1.Dnodelist Creat_node(void) /*链表初始化*/2.int Insert_node(Dnodelist D,int xs,int zs) /*插入函数*/3.Dnodelist Creat_Dmeth(int length) /*创建多项式*/4.Dnodelist Addresult(Dnodelist D1,Dnodelist D2) /*多项式相加*/5.Dnodelist Subresult(Dnodelist D1,Dnodelist D2) /*多项式相减*/6.Dnodelist select(Dnodelist D1,Dnodelist D2) /*选择函数*/7void Show(Dnodelist D) /*显示（输出）函数*/8void main()主程序模块调用链一元多项式的各种基本操作模块。
数据结构课程设计——一元多项式计算
数据结构课程设计——一元多项式计算一、课程设计题目及要求二、设计思路和方法三、程序流程图四、程序代码及注释五、测试结果及分析六、结论七、参考文献本次课程设计的题目为“一元多项式计算”，要求设计一个程序，能够实现一元多项式的加、减、乘、求导和求值等操作。
在设计思路和方法上，我们采用了链表的数据结构来存储多项式，同时设计了相应的函数来实现各种操作。
程序的流程图如下所示：插入流程图）程序的代码及注释如下所示：插入代码及注释）在测试结果及分析方面，我们对程序进行了多组测试，并对其进行了详细的分析和比较。
结果表明，我们的程序能够正确地实现各种操作，并且具有较高的效率和稳定性。
综上所述，本次课程设计的目标已经得到了圆满地实现，我们对于所取得的成果感到非常满意。
同时，我们也希望能够通过这次课程设计，加深对于数据结构及其应用的理解和掌握，为今后的研究和工作打下坚实的基础。
设计目标：本课程设计旨在结合理论与实际应用，提高学生组织数据及编写大型程序的能力。
通过掌握数据组织、算法设计和算法性能分析的方法，培养学生良好的程序设计能力。
具体实现是利用单链表表示一元多项式，实现多项式的输入、建立、输出、相加、相减和相乘。
总体设计：2.1 数据结构描述与定义：一元多项式定义系数和指数结构如下：coef，expn和next。
定义多项式的结构为线性链表的存储结构，每个结点包含三个元素：系数coef，指数expn和指向下一个结点的指针*next。
多个单项式通过指针连接起来，形成一个多项式。
2.2 模块设计：从实现多项式运算过程的角度来分析，至少需要以下子功能模块：多项式创建、销毁、输出、相加、相减和相乘。
定义并调用的函数有：Insert、CreatePolyn、DestroyPolyn、PrintPolyn、AddPolyn、SubtractPolyn、XXX和main函数。
注：该文章中没有明显的格式错误和需要删除的段落，因此没有进行小幅度改写。
数据结构一元多项式的计算
课程设计功效学院: 运算机工程学院班级: 13计科一班学生姓名: 学号:设计地址（单位）：设计题目：一元多项式的计算完成日期：年月日成绩(五级记分制): _________________教师签名:_________________________目录1、需求分析成立一元多项式并依照指数降序排列输出多项式，将一元多项式输入并存储在内存中，能够完成两个多项式的加减运算并输出结果。
随着科学技术的进展，运算机领域不断取得新的研究功效。
运算机在代替和延伸脑力劳动方面发挥愈来愈重要的作用，不仅在工业方面而且在日常生活中也愈来愈离不开运算机。
尤其是在学校里，要处置大量的学生数据。
随着科学技术的不断提高,运算机科学日渐成熟,其壮大的功能已为人们深刻熟悉,它已进入人类社会的各个领域并发挥着愈来愈重要的作用.一元多项式在日常生活中应用也比较普遍，在数学领域，咱们看似简单的问题，用程序编码出来其实要考虑很多思想，一元多项式的表示在运算机内能够用链表来表示，为了节省存储空间，只存储多项式中系数非零的项，链表中的每一个结点寄存多项式的一个系数非零项，它包括三个域，别离寄存该项的系数，指数和指向下一个多项式结点的指针，创建一元多项式链表，对一元多项式的运算中会显现的各类可能情形进行分析，实现一元多项式的相加，相减操作。
算法不像咱们平经常使用眼睛直观观看到的，电脑只会运行在逻辑上有层次合理的东西，可不能进行变通，在编写算法时，要认真考虑算法的每一步的运算，以后程序该做什么等问题。
①能够依照多项式变量的指数降序创建一个多项式；②能够对已创建的多项式进行显示；③能够对已创建的多项式之间的加法运算；④能够对已创建的多项式之间的减法运算；⑤能够对已创建的多项式进行删除；⑥能够实现计算器退出操作；2 概要设计2.1一元多项式的成立输入多项式采纳头插法的方式，输入多项式中一个项的系数和指数，就产生一个新的节点，成立起它的右指针，并用头结点指向它；为了判定一个多项式是不是输入终止，概念一个终止标志，当输入非0时就继续，当输入0时，就终止一个多项式的输入。
数据结构一元多项式的运算
数据结构一元多项式的运算第一章引言在计算机科学中，数据结构是研究非原子数据对象的组织、存储和管理的科学和技术。
一元多项式是代数中的基本概念之一，它在计算机科学中有着广泛的应用。
本文将介绍一元多项式的运算，包括多项式的表示、加法、减法、乘法等操作。
第二章多项式的表示1.稀疏数组表示法稀疏数组表示法是一种常用的多项式表示方法。
它通过一个数组来存储多项式中非零项的指数和系数。
数组的下标表示项的指数，数组元素表示项的系数。
对于没有出现的指数，数组元素为零。
2.链表表示法链表表示法是另一种常用的多项式表示方法。
每个节点包含项的指数和系数，并通过指针串接成链表。
链表的节点可以按照指数的升序或降序排列。
第三章多项式的加法多项式的加法是指将两个多项式相加得到一个新的多项式。
具体操作如下：1.根据多项式的表示方法，分别遍历两个多项式的非零项。
2.比较当前项的指数大小，如果两个指数相等，则将系数相加得到新的系数，并将结果加入结果多项式中。
3.如果一个多项式的指数大于另一个多项式的指数，则将该项加入结果多项式中。
4.重复以上操作，直到遍历完所有的非零项。
第四章多项式的减法多项式的减法是指将两个多项式相减得到一个新的多项式。
具体操作如下：1.根据多项式的表示方法，分别遍历被减数和减数的非零项。
2.比较当前项的指数大小，如果两个指数相等，则将被减数的系数减去减数的系数得到新的系数，并将结果加入结果多项式中。
3.如果被减数的指数大于减数的指数，则将该项加入结果多项式中，并将被减数的系数变为相反数。
4.重复以上操作，直到遍历完所有的非零项。
第五章多项式的乘法多项式的乘法是指将两个多项式相乘得到一个新的多项式。
具体操作如下：1.创建一个结果多项式，将其初始化为零多项式。
2.根据多项式的表示方法，分别遍历两个多项式的非零项。
3.将两个项的系数相乘得到新的系数，并将两个项的指数相加得到新的指数。
4.将新的系数和指数合并为一个项，并将该项加入结果多项式中。
数据结构实验-一元多项式的加法运算
一元多项式加法一、实验目的通过实现多项式加法，对链表有更深入的了解二、实验内容问题描述：设计一个一元稀疏多项式简单的加法计算器实现要求：一元稀疏多项式简单计算器的基本功能是：（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指向要比较的下一个结点。
一元多项式的计算,数据结构程序设计图形界面
一元多项式的计算,数据结构程序设计图形界面
对于一元多项式的计算,可以使用链表来存储每一项的系数和指数,然后进行加减乘除等运算。
具体实现的步骤如下：
1. 定义一个多项式节点的结构体,包含两个成员：系数和指数。
2. 定义一个链表结构体,包含两个成员：头节点和尾节点。
3. 实现链表的初始化函数、插入节点函数、删除节点函数、遍历链表函数等基本操作。
4. 实现多项式加法、减法、乘法、除法等运算函数。
对于加减法,可以遍历两个链表,依次将相同指数的项相加或相减；对于乘法,可以使用两个for循环遍历两个链表,将每一项相乘并按照指数相加；对于除法,可以使用辗转相除法,将被除数一部分一部分地减去除数,直到余数小于除数为止,每一部分的商可视为一项。
对于数据结构程序设计图形界面,可以使用Qt等UI框架来实现。
可以使用布局管理器来设计UI界面,使用信号与槽机制来处理用户的操作输入,将用户输入的参数传递给多项式计算函数,最终将计算结果显示在UI界面上。
数据结构一元多项式的运算-无删减范文
数据结构一元多项式的运算数据结构一元多项式的运算简介一元多项式是数学中常见的概念，用于表示一个变量的多项式表达式。
在计算机科学中，经常需要对一元多项式进行各种运算，如加法、减法、乘法等。
为了实现这些运算，可以使用数据结构来存储和操作一元多项式。
本文将介绍一元多项式的数据结构和常见的运算方法，并给出相应的代码示例。
数据结构一元多项式可以用链表来表示。
每个节点包含两个部分：系数（coefficient）和指数（exponent）。
系数表示该项的权重，指数表示该项的幂次。
链表的每个节点按照指数的升序排列。
以下是一个一元多项式的链表表示的示例：```markdown1.2x^2 + 3.7x^4 - 0.5x^3 -2.1x^1 + 4.0``````markdownNode 1: coefficient=1.2, exponent=2Node 2: coefficient=3.7, exponent=4Node 3: coefficient=-0.5, exponent=3Node 4: coefficient=-2.1, exponent=1Node 5: coefficient=4.0, exponent=0```运算方法加法运算两个一元多项式相加可以按照如下步骤进行：1. 遍历两个链表的节点，分别取出当前节点的系数和指数。
2. 如果两个节点的指数相等，将系数相加，并将其作为结果链表的节点。
3. 如果两个节点的指数不相等，将指数较小的节点插入结果链表，并继续遍历指数较大的节点。
4. 当其中一个链表遍历完后，直接将另一个链表的节点插入结果链表。
以下是加法运算的代码示例：```pythondef addPolynomials(p1, p2):result = Nonetl = Nonewhile p1 is not None and p2 is not None:if p1.exponent == p2.exponent:coef_sum = p1.coefficient + p2.coefficient if coef_sum != 0:node = Node(coef_sum, p1.exponent)if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextp2 = p2.nextelif p1.exponent > p2.exponent:node = Node(p1.coefficient, p1.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextelse:node = Node(p2.coefficient, p2.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep2 = p2.nextwhile p1 is not None:node = Node(p1.coefficient, p1.exponent)if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextwhile p2 is not None:node = Node(p2.coefficient, p2.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep2 = p2.nextreturn result```减法运算减法运算可以看作加法运算的特殊情况，即将第二个多项式的系数取负数，再进行加法运算。
一元多项式的计算数据结构专业课程设计
一元多项式的计算数据结构专业课程设计一元多项式的计算—加，减摘要(题目)一元多项式计算任务：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减，并将结果输入；目录一:引言:通过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）功能：将要进行运算的多项式输入输出。
数据结构课程设计《一元多项式的四则运算》
数据结构课程设计《一元多项式的四则运算》一元多项式的四则运算学生姓名：XX 指导老师：XX摘要本课程设计主要解决一元多项式的运算问题，通过链表的使用，实现对一元多项式的构建、录入、存储、打印、以及之间的运算。
在本课程设计中，程序设计语言为C++语言，程序运行平台为Windows/98/2000/XP，程序采用了链表存储方法以及结构化和模块化的设计方法，通过调试运行，可以进行多项式的加、减、乘运算，勉强实现了设计目标，并且经过适当完善后，将可应用到实际中解决某些问题。
关键词程序设计；C++ ；一元多项式；运算1 引言一般来说，我们只知道数学上的一元多项式的运算，这一般都是用笔来进行运算的，然而此课程设计将一元多项式的运算用电脑来进行，只需要将多项式输入，然后就可以出结果，速度快，省去了认为计算的环节，在现实中带来不少方便。
1.1 课题背景一元多项式的运算，虽然无法直接在除数学外的其他领域作出贡献，但是在数学上，它可以为人们解决一些自己动笔动手很难解决的问题，比如说那些很长很长的多项式，用笔算可能要算半天，但是用该程序，只需短短的几秒钟，所以它给人们带来了不少方便，同时相信它也能间接地为其他领域做出贡献。
1.2 课程设计目的个人觉得，该数据结构课程设计一方面可以让自己更加熟悉那些些常用的数据结构，掌握数据结构内在的逻辑关系，以及它们在计算机中的存储表示，和对它们实行的各种运算；另一方面，可以让自己对于整体和局部，以及结构化和模块化编程有一个更深层次的了解。
作为网络工程的学生，虽然之前有过一次Ｃ语言课程设计，但是深知自己编程能力尚为欠缺，所以这一次数据结构课程设计是对我的编程能力和组织能力的又一次考验。
1.3课程设计内容本课程设计是用链表实现一元多项式的存储及运算，其中包括多项式系数及指数的录入（即一元多项式的录入），以及储存、一元多项式的显示、一元多项式之间的加、减、乘法运算。
2 设计思路与方案2.1设计思路该系统使用Ｃ++语言进行开发和实现，程序中的各个功能分别由不同的的函数实现，然后在main 函数中调用实现。
数据结构一元多项式的运算
数据结构一元多项式的运算在计算机科学和数学领域中，数据结构一元多项式的运算具有重要的地位。
一元多项式是指形如＄P(x) ＝ a_n x^n ＋ a_{n-1} x^｛n-1} ＋＼cdots ＋ a_1 x ＋ a_0$ 的表达式，其中＄a_i$ 是系数，＄x$ 是变量，＄n$ 是多项式的次数。
要有效地处理一元多项式，需要选择合适的数据结构来存储它们，并设计相应的算法来进行各种运算，如加法、减法、乘法和除法等。
常见的数据结构用于表示一元多项式有两种：顺序存储结构和链式存储结构。
顺序存储结构通常使用数组来存储多项式的系数。
可以将系数按照多项式的次数从高到低依次存放在数组的相应位置。
这种方式简单直观，但存在一些局限性。
例如，如果多项式的次数很高，但大部分系数为零，会浪费大量的存储空间。
而且，对于多项式的插入和删除操作，效率也比较低。
相比之下，链式存储结构更加灵活。
每个节点可以存储一个系数和对应的指数，然后通过指针将这些节点连接起来。
这样可以有效地节省存储空间，并且对于多项式的动态修改操作更加方便。
接下来，让我们详细探讨一下一元多项式的加法运算。
假设我们有两个一元多项式＄P(x) ＝ 3x^3 ＋ 2x^2 5x ＋ 1$ 和＄Q(x) ＝ 2x^3 4x^2 ＋ 6x 3$ 。
要进行加法运算，我们需要将相同次数的项的系数相加。
首先，比较两个多项式的最高次数。
在这个例子中，都是 3 次。
然后，从高次项开始逐次相加。
对于 3 次项，系数分别为 3 和 2，相加得到 5，所以相加后的多项式的 3 次项系数为 5。
对于 2 次项，系数分别为 2 和－4，相加得到－2。
依此类推，最后得到相加后的多项式为＄5x^3 2x^2 ＋ x 2$ 。
在实现加法运算的算法时，需要考虑两个多项式的长度可能不同的情况。
可以使用两个指针分别遍历两个多项式，当其中一个指针到达末尾时，将另一个多项式剩余的项直接添加到结果多项式中。
数据结构课程设计报告一元多项式的计算
一元多项式的计算一、 需求分析建立一元多项式并按照指数降序排列输出多项式，将一元多项式输入并存储在内存中，能够完成两个多项式的加减运算并输出结果。
二、 概要设计存储结构：一元多项式的表示在计算机内可以用链表来表示，为了节省存储空间，只存储多项式中系数非零的项。
链表中的每一个结点存放多项式的一个系数非零项，它包含三个域，分别存放该项的系数、指数以及指向下一个多项式项结点的指针。
创建一元多项式链表，对一元多项式的运算中会出现的各种可能情况进行分析，实现一元多项式的相加、相减操作。
基本算法： 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是否输出存储多项式的和的链r结束是 否同指数项系数相加后存入r把p 中各项系数改变符号后存入直接把q 中各项存入r存储多项式2的空链Q 是否为空 存储多项式1的空链P 是否为空 合并同类项图表 3三、详细设计#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;}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;}//SubtractPolynint main(){int m,n,flag=0;float x;Polyn pa=0,pb=0,pc,pd,pe,pf;//定义各式的头指针，pa与pb在使用前付初值NULL printf("请输入a的项数:");scanf("%d",&m);pa=CreatePolyn(pa,m);//建立多项式aprintf("请输入b的项数:");scanf("%d",&n);pb=CreatePolyn(pb,n);//建立多项式a//输出菜单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);continue;}if(flag==2){pc=AddPolyn(pa,pb);printf("多项式a+b：");PrintPolyn(pc);DestroyPolyn(pc);continue;}if(flag==3){pd=SubtractPolyn(pa,pb);printf("多项式a-b：");PrintPolyn(pd);DestroyPolyn(pd);continue;}if(flag==4) break;if(flag<1||flag>4) printf("Error!!!\n");continue;}//forDestroyPolyn(pa);DestroyPolyn(pb);return 0;}四、调试结果1.测试的数据及结果2.算法的时间复杂度及改进算法的时间复杂度：一元多项式的加法运算的时间复杂度为O(m+n）,减法运算的时间复杂度为O(m-n)，其中m，n分别表示二个一元多项式的项数。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
项目一一元多项式的计算问题1.1设计题目与要求1.1.1设计题目1）一元多项式计算任务：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减，并将结果输入；基本要求：在上交资料中请写明：存储结构、多项式相加的基本过程的算法（可以使用程序流程图）、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法；本程序关键点是如何将输入的两个多项式相加、相减操作。
①如何将输入的一元多项式按指数的降序排列②如何确定要输入的多项式的项数；③如何将输入的两个一元多项式显示出来。
④如何将输入的两个一元多项式进行相加操作。
⑤如何将输入的两个一元多项式进行相减操作。
本程序是通过链表实现一元多项式的相加减操作。
1.1.2、任务定义此程序需要完成如下的要求：将多项式按照指数降序排列建立并输出，将两个一元多项式进行相加、相减操作，并将结果输入。
a：输入多项式的项数并建立多项式；b：输出多项式，输出形式分别为浮点和整数序列，序列按指数升序排列；c：多项式a和b相加，建立多项式a+b；d：多项式a和b相减，建立多项式a-b。
e：多项式的输出。
1.2 数据结构的选择和概要设计：1.2.1数据结构的选用A:基于链表中的节点可以动态生成的特点，以及链表可以灵活的添加或删除节点的数据结构，为了实现任意多项式的加法，减法，因此选择单链表的结构体，它有一个系数，指数，下一个指针3个元属；例如，图1中的两个线性链表分别表示一元多项式和一元多项式。
从图中可见，每个结点表示多项式中的一项。
图1 多项式表的单链存储结构B：本设计使用了以下数据结构：typedef struct node{int xs; /*系数*/int zs; /*指数*/struct node * next; /*next指针*/}Dnode,* Dnodelist;C：设计本程序需用到八个模块，用到以下八个子函数如下：1.Dnodelist Creat_node(void) /*链表初始化*/2.int Insert_node(Dnodelist D,int xs,int zs) /*插入函数*/3.Dnodelist Creat_Dmeth(int length) /*创建多项式*/4.Dnodelist Addresult(Dnodelist D1,Dnodelist D2) /*多项式相加*/5.Dnodelist Subresult(Dnodelist D1,Dnodelist D2) /*多项式相减*/6.Dnodelist select(Dnodelist D1,Dnodelist D2) /*选择函数*/7void Show(Dnodelist D) /*显示（输出）函数*/8void main()主程序模块调用链一元多项式的各种基本操作模块。
1.2.2 多项式的输入先输入多项式的项数，采用尾插法的方式，输入多项式中一个项的系数和指数，就产生一个新的节点，建立起它的右指针，并用头节点指向它；1.2.3 两个多项式的加法“和多项式”链表中的结点无需另生成，而应该从两个多项式的链表中摘取。
其运算规则如下：假设指针A和B分别指向多项式a和多项式b中当前进行比较的某个结点，则比较两个结点中的指数项，有下列3种情况：①指针A所指结点的指数值<指针B所指结点的指数值，则应摘取A指针所指结点插入到“和多项式”链表中去；②指针A所指结点的指数值>指针B所指结点的指数值，则应摘取指针A所指结点插入到“和多项式”链表中去；③指针A所指结点的指数值=指针B所指结点的指数值，则将两个结点中的系数相加，若和数不为零，则修改A所指结点的系数值，同时释放B所指结点；反之，从多项式A的链表中删除相应结点，并释放指针A和B所指结点。
例如，由图2中的两个链表表示的多项式相加得到的“和多项式”链表如图2所示，图中的长方框表示已被释放的结点。
图2 相加得到的和多项式上述多项式的相加过程归并两个有序表的过程极其类似，不同之处仅在于，后者在比较数据元素时只出现两种情况。
因此，多项式相加的过程也完全可以利用线性链表的基本操作来完成。
1.2.4流程图（1）在主函数中调用函数进行多项式的输入、输出，运用选择语句来选择加法、减法进行操作，流程图如图3：图3 主函数流程图1.3 系统设计1.3.1 功能算法描述与数据结构说明该多项式程序除了main()函数外，主要有以下函数：void Insert(Polyn p,Polyn h)Polyn CreatePolyn(Polyn head,int m)void DestroyPolyn(Polyn p)void PrintPolyn(Polyn P)int compare(Polyn a,Polyn b)Polyn AddPolyn(Polyn pa,Polyn pb)Polyn SubtractPolyn(Polyn pa,Polyn pb)Polyn MultiplyPolyn(Polyn pa,Polyn pb)1.3.2 系统主要功能函数的详细设计1. main（）函数main函数用来实现提示使用者输入、显示功能列表、调用其他运算函数实现运算功能。
在main（）函数中，定义m、n用来保存两个多项式的项数，pa、pb、pc、pd、pf定义程序所需链表的头指针。
在程序开始要求输入两个多项式的项数，随后根据项数创建两个链表以保存多项式，再显示出功能列表后通过if语句来实现功能的选择，从而对整个程序流程进行控制。
2. Polyn CreatePolyn(Polyn head,int m)该函数功能是创建新的多项式链表。
int m保存的多项式的项数，使用for语句，控制输入多项式的每一项。
当创建的链表长度为m时，将不再提示用户继续输入多项式的系数和指数。
在该函数中要用到分配空间的函数malloc()为新建链表分配空间。
3. void DestroyPolyn(Polyn p)该函数的功能是销毁掉创建的两个链表，释放内存。
以辅助退出程序。
4. void Insert(Polyn p,Polyn h)该函数功能：将新的节点p插入到现有链表的后面，并确保多项式的指数exp是升序。
将s 节点插入到head所指向的链表。
在该函数的操作中，要注意指针是如何移动的。
5. Polyn AddPolyn(Polyn pa,Polyn pb)该函数功能：实现两个多项式pa、pb相加，并将计算结果存储于新建立的pc中，它的原理是将指数相同的单项式相加，系数相加后为0，则pa、pb的指针都后移。
在加法计算中要求pa,与pb的幂次序都是升序，否则可能得到错误的结果。
该函数调用了int compare(Polyn a,Polyn b)的结果，用来判断多项式在同一指数下a、b 是否有为系数为0。
同样也使用了malloc()关键字，为新链表创建空间。
6. int compare(Polyn a,Polyn b)该函数功能：判断两个多项式在同一指数下是否有其中一个为系数为0。
用来辅助加法和乘法运算。
7. Polyn SubtractPolyn(Polyn pa,Polyn pb)该函数功能：实现两个多项式pa、pb相减，其原理根加法类似，将指数相同的指数相减。
与加法不同的是在送在减法中，创建了新的链表来存放结果，并返回该链表的头指针。
8. void PrintPolyn(Polyn P)该函数功能：显示多项式链表。
在该函数中较复杂的是如何控制链表的输出，尤其是第一项的输出，同时还有符号的控制。
在输出第一项时要判断是不是常数项，若是，则不要输出字符x。
9. Polyn MultiplyPolyn(Polyn pa,Polyn pb)函数功能：实现两个多项式相乘，A(X) * B(x) 。
计算时运用单项式与多项式相乘的法则，然后再次运用单项式与多项式相乘的法则。
1.4系统实现该程序实现了多项式的创建、多项式的加法、减法、乘法运算以及多项式的清除。
为完成这些功能，还用到了一些辅助函数。
下面讨论重要函数具体实现过程及其参数的意义：（1）链表初始化函数Creat_node()带有头结点的头指针指向空（NULL）。
（2）多项式数据的创建函数Creat_Dmeth()当链表初始化成功后，开始创建多项式。
分别循环输入两个多项式的系数和指数，其中要用到插入函数。
（3）数据的插入函数Insert_node()当创建多项式时，要用到此函数，即利用插入的方式将多项式的数据连接起来。
再输入一组数据后，程序自动调用此函数，插入时也进行着排序，从表头的next开始，一一比较指数大小，直到大于或等于当前指向的数据或遍历完所有数据时停止，然后开始链表中数值的插入，如果相等则直接将指数相加，如果大于就将新数据插入到当前指向的前面，否则将新数据插入到最后。
（4）多项式的显示函数Show()从多项式表头的next开始，直到指向空（NULL），将系数与指数一一显示。
（5）选择运算方式的函数select()三种选择：1为相加，2为相减，每一种选择调用相应的运算函数。
（6）多项式的运算函数：新建链表存储计算后的多项式1、多项式相加Addresult()创建两个指针分别指向两个多项式表头的next，分别使用两个while函数独自循环，遍历各自的每一组数据，每遍历一次都将系数与指数存储到新建多项式的链表中。
因为存储时利用到插入函数，而插入函数中有相同指数的系数相加功能，所以直接将两个多项式的数据依次插入到新的多项式中即可完成多项式相加。
2、多项式相减Subresult()创建两个指针分别指向两个多项式表头的next，以两个指针同时不为空为条件循环遍历，如果当前多项式1的指数小于多项式2，则将当前多项式2的系数置负，指数不变，存入新建多项式中，指向多项式2的指针指向下一个；如果如果当前多项式1的指数大于多项式2，则将当前多项式1的系数指数不变，存入新建多项式中，指向多项式1的指针指向下一个；否则将多项式1的系数减去2的系数后存入新建多项式中，指数不变存入，再将两个指针同时指向下一个。
结束循环后判断是哪一个多项式遍历完了，将未遍历完的多项式剩下的数据全部插入到新建多项式中。
（7）主函数main()创建两个多项式的链表并且初始化，分别调用相应的多项式创建函数，创建成功后选择运算方式，再将运算结果输出显示。
5. 其它函数的介绍请参见附录Ⅰ中详细代码1.5 调试及运行结果该程序在VC6.0中调试通过，没有错误和警告，运行结果经过检验为正确。
下图即为该程序运行结果效果图。
图中采用的是计算多项式2x^2+3x^1和3x^2+2x^3的加减两种运算进行演示：1.6源程序详见附录Ⅰ附录Ⅰ一元多项式计算源代码#include<stdio.h>#include<stdlib.h>typedef struct node{int xs;int zs;struct node * next;}Dnode,* Dnodelist; /*定义结构体*/Dnodelist Creat_node(void) /*链表初始化*/{Dnodelist D;D=(Dnodelist)malloc(sizeof(Dnode));if(D)D->next=NULL;return D;}int Insert_node(Dnodelist D,int xs,int zs) /*插入函数*/{Dnodelist p;Dnodelist q;Dnodelist r;p=D;while(p->next){r=p;p=p->next;if(zs==p->zs) /*指数相等，系数直接相加，结束*/{p->xs=p->xs+xs;return 1;}else if(zs>p->zs) /*指数大于当前数据的，将数据插入当前数据之前，结束*/ {q=Creat_node();q->xs=xs;q->zs=zs;r->next=q;q->next=p;return 1;}}/*while(p->next)*/q=Creat_node(); /*要插入的数据指数最小，直接插入至链表最后*/ q->xs=xs;q->zs=zs;q->next=p->next;p->next=q;return 1;free(p);free(q);free(r);}Dnodelist Creat_Dmeth(int length) /*创建多项式*/{int i,m,n;Dnodelist D;D=Creat_node();for(i=0;i<length;i++) /*以三组数据为例*/{scanf("%d,%d",&m,&n);Insert_node(D,m,n); /*调用插入函数，将输入的系数指数插入链表*/ }return D;}Dnodelist Addresult(Dnodelist D1,Dnodelist D2) /*多项式相加*/{Dnodelist D;Dnodelist p,q;int x,z;D=Creat_node();p=D1->next;q=D2->next;while(q){x=q->xs;z=q->zs;Insert_node(D,x,z);q=q->next;}while(p){x=p->xs;z=p->zs;Insert_node(D,x,z);p=p->next; /*直接插入数据，利用插入函数可完成该功能*/ }return D;}Dnodelist Subresult(Dnodelist D1,Dnodelist D2) /*多项式相减*/{Dnodelist D;Dnodelist p,q;int x,z;D=Creat_node();p=D1->next;q=D2->next;while(p&&q){if((p->zs)<(q->zs)) /*指数小（1的数据在2中不存在），直接插入*/{x=-(q->xs); /*由于是式1减式2，所以系数置负*/z=q->zs;Insert_node(D,x,z);q=q->next;}else if((p->zs)>(q->zs)) /*指数大（2的数据在1中不存在），直接插入*/{x=p->xs;z=p->zs;Insert_node(D,x,z);p=p->next;}else /*指数相同的先将系数相减，再插入*/{z=q->zs;x=(p->xs)-(q->xs);Insert_node(D,x,z);p=p->next;q=q->next;}}/*while(p&&q)*/while(p){x=p->xs;z=p->zs;Insert_node(D,x,z);p=p->next;}while(q){x=-(q->zs);z=q->zs;Insert_node(D,x,z);q=q->next;} /*将未遍历完的数据直接插入*/ return D;}Dnodelist select(Dnodelist D1,Dnodelist D2) /*选择函数*/{Dnodelist D;int s;printf(" 一元多项式的计算 \n");printf("**********************Menu******************\n");printf("* 1 多项式相加 2 多项式相减 *\n");printf("********************************************\n");scanf("%d",&s);switch(s){case 1:D=Addresult(D1,D2); /*调用相加函数*/printf("相加结果(系数,指数):\n");break;case 2: D=Subresult(D1,D2); /*调用相减函数*/printf("相减结果(系数,指数):\n");break;}return D;}void Show(Dnodelist D) /*显示（输出）函数*/{Dnodelist r;r=D->next;while(r){printf("(%d,%d)+",r->xs,r->zs);r=r->next;}printf("\n");}void main(){Dnodelist D1,D2,D;int length;D1=Creat_node();D2=Creat_node(); /*D1为多项式1，D2为多项式2，初始化*/printf("输入多项式1的组数：\n");scanf("%d",&length);printf("输入多项式1系数,指数：(%d组)\n",length);D1=Creat_Dmeth(length); /*创建多项式1*/ printf("输入多项式2的组数：\n");scanf("%d",&length);printf("输入多项式2系数,指数：(%d组)\n",length);D2=Creat_Dmeth(length); /*创建多项式2*/ D=select(D1,D2); /*选择运算方式*/ Show(D); /*输出显示*/}。