数据结构——一元多项式的建立与相加

合集下载

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

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

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

数据结构C语言实现之一元多项式的表示及相加(2)

以单链表作为存储结构并且和多项式中的结点无需另生成则可看成是将多项式b加到多项式a中由此得到下列运算规则设pq分别指向多项式ab的一项比较结点的指数项若pexpqexp则结点p所指的结点应是和多项式中的一项令指针p后移
数据结构 C 语言实现之一元多项式的表示及相加（2）
一元多项式的表示及相加对于符号多项式的各种操作，实际上都可以利用线性表来处理。比较典型的是关于一元多项式的处理。在
} } e>next; /*将 q 结点加入到和多项式中*/ q =q->next; } }
} if(p!=NULL)/*多项式 A 中还有剩余，则将剩余的结点加入到和多项式中*/
pre->next=p;
else /*否则，将 B 中的结点加入到和多项式中*/ pre->next=q; }
算法 2.24 多项式相加假设 A 多项式有 M 项，B 多项式有 N 项，则上述算法的时间复杂度为 O(M+N) 图 2.20 所示为图 2.19 中两个多项式的和，其中孤立的结点代表被释放的结点。
通过对多项式加法的介绍，我们可以将其推广到实现两个多项式的相乘，因为乘法可以分解为一系列的加法运算。
“中的结点无需另生成，则可看成是将多项式 B 加到多项式 A 中，由此得到下列运算规则（设 p、q 分别指向多项式 A，B 的一项，比较结点的指数项）
若 p->exp< q->exp，则结点 p 所指的结点应是“和多项式”中的一项，令指针 p 后移；若 p>exp>q->exp，则结点 q 所指的结点应是“和多项式”中的一项，将结点 q 插入在结点 p 之前，且令指针 q 在原来的链表上后移；
（1）用单链表存储多项式的结点结构如下： struct Polynode { int coef; int exp; Polynode *next; } Polynode , * Polylist;

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. 引言本文档旨在介绍数据结构中一元多项式的运算方法。

一元多项式是指在一个变量上的多项式，其中每一项由一个系数和一个指数组成。

我们将会讨论一元多项式的表示、存储和基本运算，包括多项式的加法、减法、乘法和求导等操作。

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.复习并熟练掌握数据结构所使用的程序设计语言——C语言；2.学会单步跟踪、调试自己的程序；3.加深对线性表特别是链表知识的理解和掌握，并能够运用相关知识来解决相关的具体问题，如一元多项式相加等；程序流程：1.定义一元多项式链表结构体类型；2.输入多项式项数以分配存储空间；3.输入多项式每项的系数和指数，将其插入当前多项式链表。

同时判断是否有与当前节点指数相同的项，若存在，则将两项系数相加合并。

此外，若存在系数为0的项，将其存储空间释放；4.进行多项数加法时，新建一个存储结果的链表，分别将两多项式各项依次插入结果多项式即完成多项式相加运算；5.进行多项数加法时，将减项多项式各项系数化为相反数后进行加法操作，即完成多项式相减运算；6.对x赋值后，将x值代入多项式进行运算得到多项式的值；7.输出多项式。

注意：进行完一次运算以后，应该及时销毁无用多项式以释放空间以便再次应用。

算法及注释：1）定义一元多项式链表结构体类型typedef struct Lnode{float cof; //定义系数int exp; //定义指数struct Lnode *next; //定义指针变量指向下一个节点}Lnode ,*Linklist; //定义新的变量类型2）建立多项式存储线性链表头结点void makehead(Linklist &head){ head=(Linklist)malloc(sizeof(Lnode)); //建立新的节点head->exp=-1; head->next=NULL; //指针赋空head->cof=1; }3）将输入的多项式信息存储于节点中void makelnode(Lnode *&p){ p=(Lnode*)malloc(sizeof(Lnode)); //建立新的节点printf(Input the cof and exp\n); scanf(%fx%d,&p->cof,&p->exp); //输入多项式底数指数信息p->next=NULL; //指针赋空}4）清除系数为零的多项式节点void clear(Linklist la){ Lnode *p,*q; //定义两个指向结构体的指针p=la; q=p->next; while (q){ if (fabs(q->cof)<=0.000001) { //判断系数为零p->next=q->next; //指针指向相隔的下一个节点free(q); //销毁系数为零的节点q=p->next; //指针后移一位} else { p=p->next; //p q分别后移一位q=q->next;} } }5）找到多项式中与当前节点同指数项位置int locate(Linklist l,Lnode *&p,Lnode*e){ p=l;//标记表头if (!l->next)return(0); while(p&&e->exp!=p->exp){//当p存在且指数不相等时指针后移p=p->next; } if(p) return(p);//当p存在时，返回p地址else {//没找到时寻找出插入位置p=l; while (p->next&&e->exp<=p->next->exp) p=p->next; if (!p->next){ p=p;return(0); } return(0); } }6）将多项式节点插入已有多项式链表中，同时完成系数运算void caseinsert(Linklist &l,Lnode *e){ Lnode *p;if (locate(l,p,e)){//指数相同项系数相加p->cof += e->cof; free(e); } else{//插入新的项e->next=p->next; p->next=e; } }7）创建新的多项式链表void creat(Linklist &head,int m){ Lnode *p;int i; makehead(head);//建立头结点for (i=1;i<=m;i++){ p=(Linklist)malloc(sizeof(Linklist));//建立新的多项式单个节点空间makelnode(p);//建立赋值caseinsert(head,p);//将多项式节点插入已有多项式链表中，同时完成系数运算} clear(head); }8）输入多项式项数并创建节点进行存储void input(Linklist &l){ int m; printf(Input the Poly numbers\n); scanf(%d,&m); creat(l,m);//建立一个l 指向的头指针有m项的多项式链表}9）输出多项式void print(Linklist l){ Lnode *p; p=l->next;printf(Poly：ox^%d,p->cof,p->exp); p=p->next; while (p){ if(p->cof>0) printf(+);//系数正负号if (fabs(p->cof)<=0.000001); break;//不输出系数为零的项printf(ox^%d,p->cof,p->exp); p=p->next;//指针后移} printf(\n); }10）进行多项式加法运算void add(Linklist la,Linklist lb,Linklist &lc) { Lnode *p,*q,*q1,*p1; p=la->next; q=lb->next; makehead(lc);//建立一个新的表头while(p){ p1=p->next; caseinsert(lc,p);//将多项式节点p插入已有多项式链表lc中，同时完成系数运算p=p1;//指针后移} while(q){ q1=q->next; caseinsert(lc,q);//将多项式节点q插入已有多项式链表lc中，同时完成系数运算q=q1; } }11）将减项多项式转化为系数为相反数的多项式便于转化为加法运算void reverse(Linklist &l){ Linklist p; p=l->next; while(p){ p->cof*=-1;//系数自乘-1p=p->next; } }12）进行多项式减法运算void sub(Linklist la,Linklist lb,Linklist &lc){ reverse(lb); add(la,lb,lc);clear(lc);//清除头结点}13）对x赋值进行多项式赋值运算float value(Linklist l,float x){ float sum=0,t; int i; Linklist p=l->next; while(p){t=1;for (i=p->exp;i>0;i--) t*=x; sum=sum+t*p->cof; p=p->next; } return(sum); }14）销毁已有多项式，清除已有多项式占用的存储空间void destroy(Linklist la){ Lnode *p,*q; p=la; while(p){ q=p; p=p->next; free(q); } }15）创建主程序即菜单界面void main(){ Linklist l[10]; int c,n,m,i; float a; printf(Choose the number to operate：\n); printf( 1：Creat a Poly\n); printf( 2：Poly Addition\n); printf( 3：Poly Substraction\n); printf( 4：Evaluation\n); printf( 5：Destroy a Poly\n); printf( 6：Print a Poly\n); printf( 0：Exit\n); printf(\nDestroy the Polys after used.\n); printf(\n*use ',' to separate\n);scanf(%d,&c); while (c){ switch (c){ case 1: printf(Input the Poly number 1~9\n);scanf(%d,&n); input(l[n]);break; case 2: printf( Input the Poly number to add,and the Poly number stored in\n); scanf(%d,%d,%d,&n,&m,&i); add(l[n],l[m],l[i]);break; case 3: printf( Input the Poly number to subtract,and the Poly number stored in\n); scanf(%d,%d,%d,&n,&m,&i);sub(l[n],l[m],l[i]);break; case 4: printf(Input the number to operate and the value of x:\n);scanf(%d,%f,&n,&a); printf(%f\n,value(l[n],a));break; case 5: printf(Input the Poly number:\n); scanf(%d,&n); destroy(l[n]);break; case 6: printf( Input the Poly number:\n); scanf(%d,&n); print(l[n]); case 0: n=0;break; default:printf(ERROR!); } printf(Choose the number to operate:\n); scanf(%d,&c); }printf(OK!\n);程序运行截图：实验总结：这次实验室数据结构第一次上机实验，由于与C语言课程的学习相隔已经一个学期，对C语言有些生疏和遗忘，在编程过程中出现很多错误。

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. 求两个一元多项式的和两个一元多项式的和等于对应指数相同的单项式系数相加的结果。

数据结构——链表实现一元多项式的表示和加法

数据结构——链表实现⼀元多项式的表⽰和加法⼀元多项式的链式结构：Typedef struct Lnode{float coef;///系数int expn;///指数struct Lnode *next;} PLnode, *PLinkList;基本思想：（1）若pa->expn⼩于pb->expn,则pa继续向前扫描；(2）若pa->expn等于pb->expn,将其系数相加，若相加结果不为0，将结果放⼊pa->coef中，并删除pb所指的结点，否则同时删除pa和pb所指的结点，然后pa和pb继续向前扫描；（3）若pa->expn⼤于pb->expn,则将pb所指的结点插⼊pa所指的结点之前，然后pb继续向前扫描；（4）重复上述过程直到pa或pb有⼀个为空为⽌，最后将剩余结点的链表接在结果链表上。

PLinklist Add(PLinklist pa,PLinklist pb){PLinklist p,q,r,s; /*两个多项式相加*/int cmp,x;p=pa->next; /*指向pa的第⼀个元素*/q=pb->next; /*指向pb的第⼀个元素*/s=pa; /*s作为P的跟踪指针*/r=pb;/*r作为q的跟踪指针*/while(p!=NULL&&q!=NULL){if(p->exp<q->exp){cmp=-1;}else if(p->exp>q->exp){cmp=1;}else///指数相等{cmp=0;}switch(cmp){/*根据指数的⽐较情况进⾏不同的处理*/case -1:{s=p;p=p->next;///pa表指针后移，没有插⼊break;}case0:{x=p->coef+q->coef;///指数相等，系数相加if(x!=0) /*系数不为0*/{p->coef=x;s=p;p=p->next;}/*if*/else///系数为0,在pa表中删除该结点{s->next=p->next;free(p);p=s->next;}/*else*/r->next=q->next;///在pb表中删除该结点free(q);q=r->next;break;} /*case0*/case1:{q->next=s->next;s->next=q;///将pb表中的q插⼊到pa表中的s的后⾯r->next=q->next;s=q;q=r->next;break;} /*case1*/}/*switch*/}/*while*/if(q!=NULL)///当pb连表还有剩余时接⼊到pa连表的尾部 {s->next=q;}free(pb);return pa;}/* Add*/。

数据结构《一元多项式》

一元多项式相加问题实验报告本实验的目的是进一步熟练掌握应用链表处理实际问题的能力。

一、问题描述通过键盘输入两个形如Po+P₁X¹+P₂X²+…+PX的多项式，经过程序运算后在屏幕上输出它们的相加和。

二、数据结构设计分析任意一元多项式的描述方法可知，一个一元多项式的每一个子项都由“系数-指数”两部份组成，因此可将其抽象为包含系数coef、指数 exp、指针域next 构成的链式线性表。

对多项式中系数为0的子项可以不记录它的指数值，将两个多项式分别存放在两个线性表中，然后经过相加后将所得多项式存放在一个新的线性表中，但是不用再开辟新的存储空间，只依靠结点的挪移来构成新的线性表，期间可以将某些不需要的空间回收。

基于这样的分析，可以采用不带头结点的单链表来表示一个一元多项式。

具体数据类型定义为：struct nodefloat coef;//系数域int exp; //指数域struct node *next;};三、功能函数设计1、输入并建立多项式的功能模块具体函数为node *in f un()此函数的处理较为全面，要求用户按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项，输入一个子项建立一个相关结点，当遇到输入结束标志时住手输入。

关键步骤具体如下：(1)控制用户按照指数递增的顺序输入r=a;while(r!=q->next)if(y<=r->exp)cout<<"请按照指数递增顺序输入，请重新输入";cin>>x>>y;break;r=r->next;从头开始遍历，若遇到目前输入的指数不是最大时，就跳出循环，让用户重新输入。

(2)当输入的系数为零时，不为其分配存储空间存储while(x==0){cin>>x>>y;continue;}即若系数为0,再也不进行动态分配并新建结点，而是重新提取用户输入的下一个子项的系数和指数，利用continue 进入下一次循环。

数据结构课程设计——一元多项式计算

数据结构课程设计——一元多项式计算一、课程设计题目及要求二、设计思路和方法三、程序流程图四、程序代码及注释五、测试结果及分析六、结论七、参考文献本次课程设计的题目为“一元多项式计算”，要求设计一个程序，能够实现一元多项式的加、减、乘、求导和求值等操作。

在设计思路和方法上，我们采用了链表的数据结构来存储多项式，同时设计了相应的函数来实现各种操作。

程序的流程图如下所示：插入流程图）程序的代码及注释如下所示：插入代码及注释）在测试结果及分析方面，我们对程序进行了多组测试，并对其进行了详细的分析和比较。

结果表明，我们的程序能够正确地实现各种操作，并且具有较高的效率和稳定性。

综上所述，本次课程设计的目标已经得到了圆满地实现，我们对于所取得的成果感到非常满意。

同时，我们也希望能够通过这次课程设计，加深对于数据结构及其应用的理解和掌握，为今后的研究和工作打下坚实的基础。

设计目标：本课程设计旨在结合理论与实际应用，提高学生组织数据及编写大型程序的能力。

通过掌握数据组织、算法设计和算法性能分析的方法，培养学生良好的程序设计能力。

具体实现是利用单链表表示一元多项式，实现多项式的输入、建立、输出、相加、相减和相乘。

总体设计：2.1 数据结构描述与定义：一元多项式定义系数和指数结构如下：coef，expn和next。

定义多项式的结构为线性链表的存储结构，每个结点包含三个元素：系数coef，指数expn和指向下一个结点的指针*next。

多个单项式通过指针连接起来，形成一个多项式。

2.2 模块设计：从实现多项式运算过程的角度来分析，至少需要以下子功能模块：多项式创建、销毁、输出、相加、相减和相乘。

定义并调用的函数有：Insert、CreatePolyn、DestroyPolyn、PrintPolyn、AddPolyn、SubtractPolyn、XXX和main函数。

注：该文章中没有明显的格式错误和需要删除的段落，因此没有进行小幅度改写。

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构一元多项式的运算

数据结构一元多项式的运算第一章引言在计算机科学中，数据结构是研究非原子数据对象的组织、存储和管理的科学和技术。

一元多项式是代数中的基本概念之一，它在计算机科学中有着广泛的应用。

本文将介绍一元多项式的运算，包括多项式的表示、加法、减法、乘法等操作。

第二章多项式的表示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。

一元多项式加法、减法、乘法运算的实现1。

1设计内容及要求1)设计内容（1）使用顺序存储结构实现多项式加、减、乘运算。

例如：10321058)(2456+-+-+=x x x x x x f ,x x x x x x g +--+=23451020107)(求和结果:102220128)()(2356++-+=+x x x x x g x f(2）使用链式存储结构实现多项式加、减、乘运算，10305100)(1050100+-+=x x x x f ，x x x x x x g 320405150)(10205090+++-=求和结果：1031040150100)()(102090100++-++=+x x x x x x g x f2)设计要求（1）用C 语言编程实现上述实验内容中的结构定义和算法。

（2）要有main()函数，并且在main()函数中使用检测数据调用上述算法.（3）用switch 语句设计如下选择式菜单.***＊＊*＊＊＊＊＊*＊＊＊数据结构综合性实验＊＊*＊＊＊**＊*＊*＊＊****＊*＊**一、多项式的加法、减法、乘法运算＊＊*＊**＊**＊＊*＊＊＊*＊ 1。

多项式创建 **＊*＊＊＊*＊＊＊**＊＊＊＊ 2。

多项式相加 *＊＊＊＊＊*＊＊＊＊＊*＊*＊* 3.多项式相减＊*＊＊＊*＊＊*＊*＊＊＊*** 4。

多项式相乘 *＊******＊**＊＊*＊** 5。

清空多项式 **＊＊*＊＊**＊＊*＊＊＊＊* 0.退出系统 ***＊＊＊＊*＊**＊＊＊*＊* 请选择（0—5）＊＊＊*＊**＊*****＊＊＊*＊＊＊**＊*＊＊＊****＊**＊*＊＊＊****＊*＊＊*＊*******＊**＊请选择（0—5）：1.2数据结构设计根据下面给出的存储结构定义:＃define MAXSIZE 20 //定义线性表最大容量//定义多项式项数据类型typedef struct｛float coef; //系数int expn； //指数｝term，elemType;typedef struct{term terms[MAXSIZE］； //线性表中数组元素int last； //指向线性表中最后一个元素位置}SeqList；typedef SeqList polynomial；1。

数据结构课程设计报告一元多项式相加

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

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

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

数据结构一元多项式的运算-无删减范文

数据结构一元多项式的运算数据结构一元多项式的运算简介一元多项式是数学中常见的概念，用于表示一个变量的多项式表达式。

在计算机科学中，经常需要对一元多项式进行各种运算，如加法、减法、乘法等。

为了实现这些运算，可以使用数据结构来存储和操作一元多项式。

本文将介绍一元多项式的数据结构和常见的运算方法，并给出相应的代码示例。

数据结构一元多项式可以用链表来表示。

每个节点包含两个部分：系数（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```减法运算减法运算可以看作加法运算的特殊情况，即将第二个多项式的系数取负数，再进行加法运算。

数据结构和算法-一元多项式运算算法（加法）

数据结构和算法-⼀元多项式运算算法（加法）算法名称：⼀元多项式算法算法介绍：加法运算：将具有与相同幂项的系数相加即可得到合并后的多项式。

若某个幂项只存在于⼀个多项式中，则直接合并到结果中举例利⽤代码实现这⾥主要使⽤了链表，通过3个函数来进⾏操作。

分别是Inpu函数，Add运算函数，打印函数。

代码：1. /*采⽤链表的⽅式*/2. #include<stdio.h>3. #include<stdlib.h>4. #include<limits.h>5. typedef struct polyn //定义多项式的结构6. {7.8. float coef; //系数项9. int expn; //指数10. struct polyn *next; //指向下⼀项11. }POLYN,*pPOLYN;12. void PolynInput(pPOLYN *p) //输⼊⼀元多项式13. {14. int i,min=INT_MIN; //INT_MIN是int型的最⼩数15. pPOLYN p1,p2; //分别表⽰2个多项式的指针16. if(!(*p=(POLYN *)malloc(sizeof(POLYN)))) //为头结点分配内存17. {18.19. printf("内存分配失败 \n");20. exit(0);21. }22. (*p)->coef=0; //设置头结点的系数为023. printf("输⼊该多项式的项数:");24. scanf("%d",&((*p)->expn));25. (*p)->next=NULL;26. for(i=0;i<(*p)->expn;i++) //输⼊多项式各项27. {28. if(!(p1=(pPOLYN)malloc(sizeof(POLYN)))) //分配⼀个多项式的内存29. {30. printf("内存分配失败: \n");31. exit(0);32. }33. printf("第%d项系数:",i+1);34. scanf("%f",&(p1->coef));35. do{36. printf("第%d项指数:",i+1);37. scanf("%d",&(p1->expn));38. if(p1->expn<min)39. printf("\n前项=指数值不能⼩于前⼀项指数值%d!\n重新输⼊\n",(*p)->next->expn);40. }while(p1->expn<min);41. min=p1->expn;42. p1->next=(*p)->next;43. (*p)->next=p1;44. }45. p1=(*p)->next; //合并多项式中指数值相同的项46. while(p1)47. {48. p2=p1->next; //取下⼀节点49. while(p2 && p2->expn==p1->expn) //若节点有效，节点与q节点的指数相同50. {51. p1->coef+=p2->coef; //累加系数52. p1->next=p2->next; //删除r指向的节点53. free(p2);54. p2=p1->next;56. }57. p1=p1->next;58. }59. }60. void PolynPrint(pPOLYN p) //输出多项式61. {62. pPOLYN p1;63. int i;64. printf("\n\n计算后的多项式共有%d项 \n",p->expn);65. p1=p->next;66. i=1;67. while(p1)68. {69. printf("第%d项,系数:%g,指数:%d\n",i++,p1->coef,p1->expn);70. p1=p1->next;71. }72. printf("\n");73. }74. void PolynAdd(pPOLYN pa,pPOLYN pb) //多项式相加pa=pa+pb75. {76.77. pPOLYN pa1,pb1,pc1,p;78. pa1=pa->next; //指向被加链表的第⼀个有效项79. pb1=pb->next; //指向加链表的第⼀个有效项80. pc1=pa; //指向被加链表81. pc1->next=NULL;82. pa->expn=0; //清空多项式项⽬数据83. while(pa1 && pb1) //两个多项式都未结束84. {85.86. if(pa1->expn > pb1->expn) //如果pa1指数⼤于pb187. {88. pc1->next=pa1; //将pa1指数加⼊结果链表中89. pc1=pa1;90. pa1=pa1->next; //处理pa1中的下⼀项91. pc1->next=NULL;92.93. }else if(pa1->expn < pb1->expn) //pa1的指数⼩于pb1的指数94. {95. pc1->next=pb1; //将pb1指数加⼊结果链表中96. pc1=pb1;97. pb1=pb1->next; //处理pb1的下⼀项98. pc1->next=NULL;99. }else { //pa1指数等于pb1指数，进⾏系统相加100. pa1->coef+=pb1->coef; //累加素数101. if(pa1->coef!=0) //若系数不为0102. {103. pc1->next=pa1; //将相加结果添加到结果链表中104. pc1=pa1;105. pa1=pa1->next; //处理pa1的下⼀项106. pc1->next=NULL;107. p=pb1;108. pb1=pb1->next; //处理pb1的下⼀项109. free(p);110. }111. else{ //系数为0，则不记录该项112. p=pa1; //⽤p指向pa1中的该项113. pa1=pa1->next; //链表中删除该项114. free(p); //释放该项所占⽤内存115. p=pb1; //⽤临时指针指向pb1中的该项116. pb1=pa1->next; //链表中删除该项117. free(p); //释放该项所占⽤内存118. pa->expn--; //后⾯要进⾏累加操作，此处先减119. }120. }121. pa-pa->expn++; //累加⼀个结果项122. }123. if(pa1) //若pa1中还有项124. {125. pc1->next=pa1; //将pa1中的项添加到结果链表中126. while(pa1)127. {128.129. pa->expn++;130. pa1=pa1->next;131. }132. }133. if(pb1) //若pb1中还有项134. {135.136. pc1->next=pb1; //将pb1中的项添加到结果链表中137. while(pb1)138. {140. pb1=pb1->next;141. }142. }143. free(pb); //释放pb头链所占的内存空间144. }145. int main()146. {147. pPOLYN pa=NULL,pb=NULL; //指向多项式链表的指针148. printf("输⼊第⼀个多项式数据:\n");149. PolynInput(&pa); //调⽤函数输⼊⼀个多项式150. printf("\n输⼊第⼆个多项式数据:\n");151. PolynInput(&pb); //调⽤函数，输⼊另⼀个多项式152. PolynAdd(pa,pb); //调⽤多项式相加函数153. printf("\n两个多项式之和为：");154. PolynPrint(pa); //输出运算得到的多项式155. getch();156. return 0;157. }附件列表。

一元多项式的加减求导运算算法(数据结构算法)

{
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，。

数据结构课程设计报告一元多项式的计算

一元多项式的计算一、需求分析建立一元多项式并按照指数降序排列输出多项式，将一元多项式输入并存储在内存中，能够完成两个多项式的加减运算并输出结果。

二、概要设计存储结构：一元多项式的表示在计算机内可以用链表来表示，为了节省存储空间，只存储多项式中系数非零的项。

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

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

基本算法： 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分别表示二个一元多项式的项数。