数据结构一元多项式的计算
数据结构课程设计-一元多项式的加法、减法、乘法的实现
一、设计题目一元多项式的加法、减法、乘法的实现。
二、主要内容设有一元多项式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语言数据结构实现——一元多项式的基本运算
文章标题：深入理解C语言中的数据结构实现——一元多项式的基本运算在C语言中，数据结构是非常重要的一个概念，它为我们处理各种复杂的数据提供了便利。
其中，一元多项式的基本运算是数据结构中的一个重要内容，它涉及到多种数据结构的操作和算法，是我们学习C 语言中数据结构的一个重要入口。
在本文中，我们将深入探讨C语言中一元多项式的基本运算，帮助读者更深入地理解这一重要的概念。
一、一元多项式的表示方式在C语言中，一元多项式可以使用数组来表示。
每个数组元素对应一个项，数组的下标对应每一项的次数，数组的值对应该项的系数。
一个一元多项式可以表示为：```cfloat polynomial[10] = {0, 1, 2, 0, 4}; // 表示多项式 1 + 2x + 4x^4 ```二、一元多项式的基本运算1. 一元多项式的加法有两个多项式 A 和 B，它们分别表示为 `float polynomialA[10]` 和`float polynomialB[10]`，那么它们的加法运算可以表示为：```cfor (int i = 0; i < 10; i++) {polynomialC[i] = polynomialA[i] + polynomialB[i];}```2. 一元多项式的减法一元多项式的减法是指将两个多项式相减得到一个新的多项式。
与加法类似，多项式 A 和 B 的减法运算可以表示为：```cfor (int i = 0; i < 10; i++) {polynomialC[i] = polynomialA[i] - polynomialB[i];}```3. 一元多项式的乘法式 A 和 B 的乘法运算可以表示为：```cfor (int i = 0; i < 10; i++) {for (int j = 0; j < 10; j++) {polynomialC[i+j] += polynomialA[i] * polynomialB[j];}}```4. 一元多项式的除法一元多项式的除法涉及到较为复杂的算法，需要考虑余数和商的处理。
数据结构一元多项式的运算
数据结构一元多项式的运算数据结构一元多项式的运算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.多项式的复合运算: 将一个多项式代入另一个多项式中进行运算。
数据结构一元多项式的运算
数据结构一元多项式的运算第一章引言在计算机科学中，数据结构是指一组数据和数据之间的关系，以及在这组数据上定义的一组操作。
数据结构是计算机算法的基础，它能够提高数据的组织和处理效率。
本文将详细介绍一元多项式的运算，包括多项式的表示方式以及常见的运算操作。
第二章多项式的表示方式多项式可表示为一系列项的和，其中每一项由系数和指数组成。
常见的表示方式有两种：________1.数组表示法：________将多项式的每一项按照指数从小到大的顺序存储在一个数组中。
数组的下标表示项的指数，数组的元素存储项的系数。
例如，多项式 P(x) = 2x^3 + 3x^2 ●4x + 1 可表示为数组 1, -4, 3, 2。
2.链表表示法：________将多项式的每一项作为链表的一个节点，节点包含指数和系数两个属性，通过链表的方式连接起来。
例如，多项式 P(x) = 2x^3 + 3x^2 ●4x + 1 可表示为链表的形式：________2 ->3 -> -4 -> 1---● ---● ---● ----x^3 x^2 x 1第三章多项式的基本运算多项式的基本运算包括多项式的加法、减法、乘法和求导。
1.多项式的加法：________将两个多项式相加，实际上是将对应指数的系数相加。
例如，多项式 P(x) = 2x^3 + 3x^2 ●4x + 1和多项式 Q(x) = x^2 + 2x + 3 相加得到多项式 R(x) = 2x^3 +4x^2 ●2x + 4。
2.多项式的减法：________将一个多项式减去另一个多项式，实际上是将对应指数的系数相减。
例如，将多项式 P(x) 减去多项式 Q(x) 得到多项式 R(x) = 2x^3 + 2x^2 ●6x ●2。
3.多项式的乘法：________将两个多项式相乘，实际上是将一个多项式的每一项与另一个多项式的每一项相乘，然后将结果相加。
例如，将多项式 P(x) = 2x^3 + 3x^2 ●4x + 1 与多项式 Q(x) =x^2 + 2x + 3 相乘得到多项式 R(x) = 2x^5 + 7x^4 ●4x^3 +9x^2 ●5x + 3。
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()主程序模块调用链一元多项式的各种基本操作模块。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
课程设计成果学院: 计算机工程学院班级: 13计科一班学生姓名: 学号:设计地点（单位）：设计题目：一元多项式的计算完成日期：年月日成绩(五级记分制): _________________教师签名:_________________________目录1 需求分析 ......................................................................... 错误!未定义书签。
2 概要设计 ......................................................................... 错误!未定义书签。
2.1一元多项式的建立 ............................................................... 错误!未定义书签。
2.2显示一元多项式 ................................................................... 错误!未定义书签。
2.3一元多项式减法运算 ........................................................... 错误!未定义书签。
2.4一元多项式加法运算 ........................................................... 错误!未定义书签。
2.5 设计优缺点.......................................................................... 错误!未定义书签。
3详细设计 .......................................................................... 错误!未定义书签。
3.1一元多项式的输入输出流程图........................................... 错误!未定义书签。
3.2一元多项式的加法流程图................................................... 错误!未定义书签。
3.3一元多项式的减法流程图.................................................. 错误!未定义书签。
3.4用户操作函数....................................................................... 错误!未定义书签。
4编码 .................................................................................. 错误!未定义书签。
5调试分析 .......................................................................... 错误!未定义书签。
4测试结果及运行效果...................................................... 错误!未定义书签。
5系统开发所用到的技术.................................................. 错误!未定义书签。
参考文献 ............................................................................. 错误!未定义书签。
附录全部代码................................................................... 错误!未定义书签。
1、需求分析建立一元多项式并按照指数降序排列输出多项式，将一元多项式输入并存储在内存中，能够完成两个多项式的加减运算并输出结果。
随着科学技术的发展，计算机领域不断取得新的研究成果。
计算机在代替和延伸脑力劳动方面发挥越来越重要的作用，不仅在工业方面而且在日常生活中也越来越离不开计算机。
尤其是在学校里，要处理大量的学生数据。
随着科学技术的不断提高,计算机科学日渐成熟,其强大的功能已为人们深刻认识,它已进入人类社会的各个领域并发挥着越来越重要的作用.一元多项式在日常生活中应用也比较广泛，在数学领域，我们看似简单的问题，用程序编码出来其实要考虑很多思想，一元多项式的表示在计算机内可以用链表来表示，为了节省存储空间，只存储多项式中系数非零的项，链表中的每一个结点存放多项式的一个系数非零项，它包含三个域，分别存放该项的系数，指数以及指向下一个多项式结点的指针，创建一元多项式链表，对一元多项式的运算中会出现的各种可能情况进行分析，实现一元多项式的相加，相减操作。
算法不像我们平时用眼睛直观观察到的，电脑只会运行在逻辑上有条理合理的东西，不会进行变通，在编写算法时，要认真考虑算法的每一步的运算，之后程序该做什么等问题。
①能够按照多项式变量的指数降序创建一个多项式；②能够对已创建的多项式进行显示；③能够对已创建的多项式之间的加法运算；④能够对已创建的多项式之间的减法运算；⑤能够对已创建的多项式进行删除；⑥能够实现计算器退出操作；2 概要设计2.1一元多项式的建立输入多项式采用头插法的方式，输入多项式中一个项的系数和指数，就产生一个新的节点，建立起它的右指针，并用头结点指向它；为了判断一个多项式是否输入结束，定义一个结束标志，当输入非0时就继续，当输入0时，就结束一个多项式的输入。
2.2显示一元多项式如果系数是大于0的话就直接输出系数，如果系数是正的话前面就要加+号，如果系数是1的话就直接输出+x，如果系数是-1的话就直接输出-x号，如果系数是大于0的话就输出+系数x^指数的形式，如果系数小于0的话就输出系数x^指数的形式。
2.3一元多项式减法运算它从两个多项式的头部开始，两个多项式的某一项都不为空时，如果指数相等的话，系数就相减；相加的和不为零的话，用头插法建立一个新的节点，p的指数小于q的指数的话，就应该复制q的节点到多项式中，p的指数大于q的指数的话就应该复制p的节点到多项式中，并且建立的节点的系数为原来的相反数，当第二个多项式空，第一个多项式不为空时，将第一个多项式用新节点产生，当第一个多项式空，第二个多项式不为空时，将第二个多项式用新节点产生，并且建立的节点的系数为原来的相反数。
2.4一元多项式加法运算它从两个多项式的头部开始，两个多项式的某一项都不为空时，如果指数相等的话，系数就相加；相加的和不为零的话，用头插法建立一个新的节点，p的指数小于q的指数的话，就应该复制q的节点到多项式中，p的指数大于q的指数的话就应该复制p的节点到多项式中，当第二个多项式空，第一个多项式不为空时，将第一个多项式用新节点产生，当第一个多项式空，第二个多项式不为空时，将第二个多项式用新节点产生。
2.5 设计优缺点优点：1.能够实现一元多项式的加，减运算，算法也不是很复杂，容易理解，在空间复杂度上比较节省存储空间。
2.所有的操作大多是在内存中实现，增加操作的速度，在操作的时候我们可以利用链表来实现随机的操作，十分的方便。
缺点：1.这个算法具有一般性，对于有些特殊的一元多项式采用顺序存储会比较方便，在时间复杂度上可以节省很多算法的时间。
2.在最坏的情况下，即n+1个系数都不为零，则比只存储系数的方法（顺序存储）多存储一倍的数据，对于非零系数多的多项式则不宜采用这种表示。
3详细设计3.1一元多项式的输入输出流程图1、输入输出（1）功能：将要进行运算的多项式输入输出。
（2）数据流入：要输入的多项式的系数与指数。
（3）数据流出：合并同类项后的多项式。
程序流程图：多项式输入流程图如图3-1所示。
（4）测试要点：输入的多项式是否正确，若输入错误则从新输入。
图3-1 多项式输入流程图3.2一元多项式的加法流程图2、一元多项式的加法（1）功能：将两多项式相加。
（2）数据流入：输入函数。
（3）数据流出：多项式相加后的结果。
（4）程序流程图：多项式的加法流程图如图3-2所示。
测试要点：两多项式是否为空，为空则提示重新输入，否则，进行运算图3-2 多项式的加法流程图3.3一元多项式的减法流程图3、一元多项式的减法（5）功能：将两多项式相减。
（6）数据流入：输入函数。
（7）数据流出：多项式相减后的结果。
（8）程序流程图：多项式的减法流程图如图3-3所示。
测试要点：两多项式是否为空，为空则提示重新输入，否则，进行运算图3-3 多项式的减法流程图3.4用户操作函数Typedef struct pnode{//项的表示，多项式的项作为pnode的数据元素Float xishu; //系数Int zhishu；//指数/*用头插法生成一个多项式，系数和指数输入0时退出输入*/pnode *creat()/*调整多项式*/void tiaozhen(pnode *head)/*输出一元多项式函数：*/void shuchu(pnode *head)/*两个多项式的加法运算*/pnode*add(pnode*heada,pnode*headb)/*相加的函数*/void add_main()/*减法函数*/void sub_main()4编码函数流程：pnode L=NULL; //定义一个链表，即我们所操作的链表信息都可从这个变量获得void main(){//初始化链表InitList(L );//调用用户界面，接受用户的操作选择switch();}创建链表(程序开始)—>初始化链表—>调用用户界面，接受用户的操作选择—>错误提示，请用户重新操作->#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<conio.h>5调试分析主要的调试过程有三个：1.对一元多项式的输出，输出函数void shuchu(pnode *head)，在开始界面上调整，字段的布局，刚开始时由于换行没有加上，界面如下图5-1 调试之前经过修改之后，界面变得整洁一点，用户更能接受一点，修改之后的图如下：图5-2 调试之后测试输入“1“页面正常，说明逻辑设计正确。
2. 链表的调试。
总得来说链表的调试是相对简单的，毕竟都是在内存里运行的，记录和显示数据的。
调试阶段最重要的还是耐性和细心。