一元多项式相加算法

合集下载

北邮数据结构实验一元多项式实验报告

数据结构实验报告实验名称：实验一—线性表实现一个多项式学生姓名：黄锦雨班级：2011211109班内序号：20学号：2011210263日期：2012年10月31日实验目的：1.熟悉C++语言的基本编程方法，掌握集成编译环境的调试方法2.学习指针、模板类、异常处理的使用3.掌握线性表的操作的实现方法4.学习使用线性表解决实际问题的能力实验内容：利用线性表实现一个一元多项式Polynomialf(x) = a0 + a1x + a2x2 + a3x3+ … + a n x n要求：1．能够实现一元多项式的输入和输出2．能够进行一元多项式相加3．能够进行一元多项式相减4．能够计算一元多项式在x处的值5．能够计算一元多项式的导数（选作）6．能够进行一元多项式相乘（选作）7．编写测试main()函数测试线性表的正确性2. 程序分析由于多项式是线性结构，故选择线性表来实现，在这个程序中我采用的是单链表结构，每个结点代表一个项，多项式的每一项可以用其系数和指数唯一的表示。

如果采用顺序存储，那么对于结点的插入和删除的操作会比较麻烦，而且顺序表的结点个数固定，对于可能发生的情况无法很好的处理，而采用链表就会简单许多，还能自由控制链表的长度。

两个多项式要进行多次的计算，为了保护原始的数据，方便进行以后的计算，故选择把结果存储在一个新建的链表里。

2.1本程序完成的主要功能：1.输入和输出：需要输入的信息有多项式的项数，用来向系统动态申请内存；多项式各项的系数和指数，用来构造每个结点，形成链表。

输出即是将多项式的内容向屏幕输出。

2.多项式相加与相减：多项式的加减要指数相同即是同类项才能实现，所以在运算时要注意判断指数出现的各种不同的情况，分别写出计算方法。

将每项运算得到的结果都插入到新的链表中，形成结果多项式。

3.多项式的求导运算：多项式的求导根据数学知识，就是将每项的系数乘以指数，将指数减1即可，将每项得到的结果插入到结果多项式的链表中。

一元多项式的加法数据结构

一元多项式的加法数据结构一元多项式是数学中常见的一种代数表达式形式，由多个单项式按照一定的规则相加而成。

在计算机科学中，为了方便对一元多项式进行处理，需要定义一种合适的数据结构来表示和操作一元多项式的加法运算。

一元多项式的加法数据结构可以使用链表来实现。

每个节点表示一个单项式，包含两个成员变量：系数和指数。

系数表示单项式的系数，指数表示单项式的指数。

通过将多个单项式的系数和指数组织成一个链表，即可表示一个一元多项式。

在链表中，每个节点按照指数从小到大的顺序排列。

这样可以方便进行多项式的加法运算。

当两个一元多项式相加时，只需按照指数的大小依次比较两个链表中的节点，并根据指数的大小关系进行相应的操作。

具体的加法算法如下：1. 创建一个新的链表作为结果链表。

2. 初始化两个指针分别指向两个原始链表的头节点。

3. 循环比较两个链表中的节点，直到其中一个链表遍历完为止。

4. 比较当前节点的指数大小关系：- 如果两个节点的指数相等，将它们的系数相加，并将结果添加到结果链表中。

- 如果第一个链表中的节点指数较小，将第一个链表的节点添加到结果链表中，并将指针指向下一个节点。

- 如果第二个链表中的节点指数较小，将第二个链表的节点添加到结果链表中，并将指针指向下一个节点。

5. 当其中一个链表遍历完后，将另一个链表中剩余的节点依次添加到结果链表中。

6. 返回结果链表作为两个一元多项式相加的结果。

通过上述算法，可以实现对一元多项式的加法运算。

这种链表结构的一元多项式加法数据结构具有以下优点：- 灵活性：可以表示任意长度的一元多项式，不受固定数组长度的限制。

- 高效性：在添加节点和遍历节点时，时间复杂度为O(n)，其中n 为一元多项式的项数。

- 可扩展性：可以方便地扩展其他操作，如乘法、求导等。

除了链表结构，还可以使用数组等数据结构来表示一元多项式的加法。

不同的数据结构适用于不同的应用场景。

链表结构适合于插入和删除操作较多的情况，而数组结构适合于随机访问和内存占用较小的情况。

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

一元多项式计算(数据结构课程设计)一、系统设计1、算法思想根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应指数相加（减），若其和（差）不为零，则构成“和（差）多项式”中的一项；对于两个一元多项式中所有指数不相同的项，则分别写到“和（差）多项式”中去。

因为多项式指数最高项以及项数是不确定的，因此采用线性链表的存储结构便于实现一元多项式的运算。

为了节省空间，我采用两个链表分别存放多项式a 和多项式b，对于最后计算所得的多项式则利用多项式a进行存储。

主要用到了单链表的插入和删除操作。

(1)一元多项式加法运算它从两个多项式的头部开始，两个多项式的某一项都不为空时，如果指数相等的话，系数就应该相加；相加的和不为零的话，用头插法建立一个新的节点。

P 的指数小于q的指数的话就应该复制q的节点到多项式中。

P的指数大于q的指数的话，就应该复制p节点到多项式中。

当第二个多项式空，第一个多项式不为空时，将第一个多项式用新节点产生。

当第一个多项式空，第二个多项式不为空时，将第二个多项式用新节点产生。

(2)一元多项式的减法运算它从两个多项式的头部开始，两个多项式的某一项都不为空时，如果指数相等的话，系数就相减；相加的和不为零的话，用头插法建立一个新的节点。

p的指数小于q的指数的话，就应该复制q的节点到多项式中。

P的指数大于q的指数的话就应该复制p的节点到多项式中，并且建立的节点的系数为原来的相反数；当第二个多项式空，第一个多项式不为空时，将第一个多项式用新节点产生。

当第一个多项式空，第二个多项式不为空时，将第二个多项式用新节点产生，并且建立的节点的系数为原来的相反数。

2、概要设计(1)主函数流程图：（注：a代表第一个一元二次方程，b代表第二个一元二次方程）(2)一元多项式计算算法用类C语言表示：Typedef struct00{ //项的表示，多项式的项作为LinkList的数据元素Float coef；//细数Int expn；//指数}term，ElemType；//两个类型名：term用于本ADT，ElemType为LinkList的数据对象名Typedef LinkList polynomial：//用带表头的节点的有序链表表示多项式//基本操作的函数原型说明Void CreatePolyn（polynomail&P）；//输入n的系数和指数，建立表示一元多项式的有序链表P 销毁一元多项式P Void DestroyPolyn（polynomailP）；销毁一元多项式PvoidPrintPoly（polynomail P）；//打印输入一元多项式PIntPolynLength（polynnomail P);//返回一元多项式P中的项数void CreatPolyn（polynomail&Pa.polunomail&Pb);//完成多项式相加运算，即:Pa=Pa+Pb,并贤惠一元多项式Pb voidSubtractPolyn（polunomail&Papolunomail&Pb）；//完成多项式相减运算，即：Pa=Pa-Pb，并销毁一元多项式Pb//基本操作的算法描述Int cmp(tem a，temp b）；//依a的指数值<（或=）（或>b的住数值，分别返回-1、0和+1Void CreatePolyn（polynomail&P,int m){//输入m项的系数和指数，建立表示一元多项式的有序链表PInitList（P）；h=GetHead（P）；E.coef=0.0； e.expn=-1；S erCurElem（h，e）；//设置头结点的数据元素For （i=1；i<=m；++i）{ //依次输入m个非零项Scanf（e.coef，e.epn）；If（！LocateElem（P，e，q，（*cmp）（）））{//当前链表中不存在该指数项If(MakeNode（s，e））InsFirst（q，s）；//生成节点并插入链表}}}//CreatPolun二、详细设计1、算法实现(1)输入一元多项式函数：void shuchu(pnode *head){pnode *p;int one_time=1;p=head;while(p!=NULL) /*如果不为空*/{if(one_time==1){if(p->zhishu==0) /*如果指数为0的话，直接输出系数*/printf("%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/else if(p->xishu==1||p->xishu==-1)printf("X^%d",p->zhishu); /*如果系数是1的话就直接输出+x*//*如果系数是-1的话就直接输出-x号*/else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);one_time=0;}else{if(p->zhishu==0) /*如果指数为0的话，直接输出系数*/{if(p->xishu>0)printf("+%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/}else if(p->xishu==1) /*如果系数是1的话就直接输出+x号*/printf("+X^%d",p->zhishu);else if(p->xishu==-1) /*如果系数是-1的话就直接输出-x号*/printf("X^%d",p->zhishu);else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("+%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/printf("%5.2fX^%d",p->xishu,p->zhishu);}p=p->next; /*指向下一个指针*/}printf("\n");}(2)加法函数/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针，r,s为临时指针，p指向第1个多项式并向右移动，q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话，就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话，就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}(3)减法函数/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针，r,s为临时指针，p指向第1个多项式并向右移动，q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话，就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话，就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}2、程序代码/*一元多项式计算*//*程序功能：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减，并将结果输出；*//*提示：输入完一元多项式之后，输入“0 0”结束本一元多项式的输入*//*注意：系数只精确到百分位，最大系数只能为999.99,指数为整数.如果需要输入更大的系数，可以对程序中5.2%f进行相应的修改*/#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<conio.h>/*建立结构体*/typedef struct pnode{float xishu; /*系数*/int zhishu; /*指数*/struct pnode *next; /*下一个指针*/}pnode;/*用头插法生成一个多项式，系数和指数输入0时退出输入*/pnode * creat()int m;float n;pnode *head,*rear,*s; /*head为头指针，rear和s为临时指针*/ head=(pnode *)malloc(sizeof(pnode));rear=head; /*指向头*/scanf("%f",&n); /*系数*/scanf("%d",&m); /*输入指数*/while(n!=0) /*输入0退出*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=n;s->zhishu=m;s->next=NULL;rear->next=s; /*头插法*/rear=s;scanf("%f",&n); /*输入系数*/scanf("%d",&m); /*输入指数*/}head=head->next; /*第一个头没有用到*/return head;}/*调整多项式*/void tiaozhen(pnode *head){pnode *p,*q,*t;float temp;p=head;while(p!=NULL){q=p;t=q->next;while(t!=NULL){if(t->zhishu>q->zhishu)q=t;t=t->next;}temp=p->xishu;p->xishu=q->xishu;q->xishu=temp;temp=p->zhishu;p->zhishu=q->zhishu;q->zhishu=temp;p=p->next;}/*显示一个多项式*/void shuchu(pnode *head){pnode *p;int one_time=1;p=head;while(p!=NULL) /*如果不为空*/{if(one_time==1){if(p->zhishu==0) /*如果指数为0的话，直接输出系数*/printf("%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/else if(p->xishu==1||p->xishu==-1)printf("X^%d",p->zhishu); /*如果系数是1的话就直接输出+x*//*如果系数是-1的话就直接输出-x号*/else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);one_time=0;}else{if(p->zhishu==0) /*如果指数为0的话，直接输出系数*/{if(p->xishu>0)printf("+%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/}else if(p->xishu==1) /*如果系数是1的话就直接输出+x号*/printf("+X^%d",p->zhishu);else if(p->xishu==-1) /*如果系数是-1的话就直接输出-x号*/printf("X^%d",p->zhishu);else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("+%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);}p=p->next; /*指向下一个指针*/}printf("\n");/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针，r,s为临时指针，p指向第1个多项式并向右移动，q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话，就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话，就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}/*两个多项式的减法运算*/pnode * sub(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r;float x; /*x为系数相减*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*两个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu-q->xishu; /*系数相减*/if(x!=0) /*相减的差不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=-q->xishu; /*建立的节点的系数为原来的相反数*/s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}else{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}while(p!=NULL) /*当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}while(q!=NULL) /*当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=-q->xishu; /*建立的节点的系数为原来的相反数*/ s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}void add_main(){pnode * a,*b,*c;printf("\n输入第一个一元多项式:\n系数指数\n");a=creat();tiaozhen(a);printf("\n输入第二个一元多项式:\n系数指数\n");b=creat();tiaozhen(b);c=add(a,b);printf("第一个一元多项式如下:");shuchu(a);printf("第二个一元多项式如下:");shuchu(b);printf("两式相加如下:");shuchu(c);}void sub_main(){pnode * a,*b,*c;printf("\n输入第一个一元多项式:\n系数指数\n");a=creat();tiaozhen(a);printf("\n输入第二个一元多项式:\n系数指数\n");b=creat();tiaozhen(b);c=sub(a,b);printf("第一个一元多项式如下:");shuchu(a);printf("第二个一元多项式如下:");shuchu(b);printf("两式相减如下:");shuchu(c);}void open(){printf("\n****************************************************\n");printf(" 功能项: * 1 两个一元多项式相加;2 两个一元多项式相减;0 退出*\n");printf("****************************************************\n\n请选择操作: ");}void main(){int choose;open();while(choose!=0){scanf("%d",&choose);getchar();switch(choose){case 0:return;case 1:printf("\n 两个一元多项式相加\n");add_main();choose=-1;open();break;case 2:printf("\n 两个一元多项式相减\n");sub_main();choose=-1;open();break;default:printf("没有该选项!请重新选择操作!\n\n");open();}}}三、测试方案及结果1、测试方案在Visual C++ 6.0环境中调试运行。

数据结构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;

完整word版一元多项式求和实验报告范文_

完整word版一元多项式求和实验报告范文_实验一、线性结构综合应用一、实验题目：顺序表的应用二、实验内容：一元多项式求和。

把任意给定的两个一元多项式P(某),Q(某)输入计算机，计算它们的和并输出计算结果。

三、设计分析：实现要定义的一元多项式应采用链式存储结构。

根据一元多项式相加的运算法则，对于两个多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成新多项式的一项；对于两个多项式中所有指数不同的项，分别复制到新多项式中。

新多项式不必另外生成，而是在原来的两个多项式中摘取结点即可。

采用顺序存储结构存储多项式系数A，使多项式的某些运算变得更简洁。

但在实际使用时，多项式的阶数可能很高，不同的多项式阶数可能相差很大，这使顺序存储结构的最大长度难以确定。

而且，最高次幂与最低次幂项之间缺项很多时，采用顺序存储结构显然十分浪费存储空间，因此，一般情况下多采用链式存储结构来存储高阶多项式。

在用线性链表来存储一个多项式时，多项式中的每个非零项系数对应一个结点，结点由数据元素项和指针组成。

数据元素项中包含系数和指数值，设计中先定义定义数据元素中的数据，其中有指数、系数级指针ne某t等。

并要先构造一元多项式。

在定义输出、删除、合并等模块。

假设指针qa和qb分别指向多项式A和B中当前进行操作的某个结点，比较这个结点的指数项，可能有三种情况：①指针qa->e某p<qb->e某p,则摘取qa指针所指结点插入到和多项式中；②指针qa->e某p<qb->e某p,则摘取qb指针所指结点插入到和多项式中；③指针qa->e某p=qb->e某p,则将系数相加，若和数不为零，则修改qa->coef的值，同时释放qb所指结点，反之，从多项式A的链表中删除相应的结点，并释放指针Pa和Pb所指结点；还有就是在输入是采取的降序输入，也好使两个多项式进行合并。

并输出。

在主函数中将前面也的这些功能都运用起来就可以了四、程序代码：#include<iotream>#defineNULL0uingnamepacetd;typedeftructPolynomial{floatcoef;//系数inte某p;//指数tructPolynomial某ne某t;}Polynomial;Polynomial某CreatPolyn(){//输入m项的系数和指数，建立一元多项式floatmod;intind;Polynomial某H,某p,某;H=newPolynomial;=H;潣瑵请输入多项式的系数和指数：(按0结束输入)<<endl; cin>>mod>>ind;while(mod){p=(Polynomial某)newPolynomial;p->coef=mod;p->e某p=ind;->ne某t=p;=p;cin>>mod>>ind;}->ne某t=NULL;returnH;}voidPrint(Polynomial某pa){//打印输出一元多项式pwhile(pa->ne某t!=NULL){pa=pa->ne某t;cout<<pa->coef<<某某^<<pa->e某p;if(pa->ne某t!=NULL&&pa->ne某t->coef>0) cout<<+;}}voidDelete(Polynomial某pa){//删除一元多项式Polynomial某p,某q;p=pa->ne某t;while(p){q=p;p=p->ne某t;deleteq;}pa->ne某t=NULL;}voidAddPolyn(Polynomial某pa,Polynomial某pb) {//用于链表的合并使用完成多项式的相加运算floatum;Polynomial某p,某q,某pre,某temp;p=pa->ne某t;q=pb->ne某t;pre=pa;while(p!=NULL&&q!=NULL){if(p->e某p>q->e某p){pre->ne某t=p;pre=pre->ne某t;p=p->ne某t;}eleif(p->e某p==q->e某p) {um=p->coef+q->coef;if(um!=0){p->coef=um;pre->ne某t=p;pre=pre->ne某t;p=p->ne某t;temp=q;q=q->ne某t; deletetemp;}ele{temp=p->ne某t;deletep;p=temp;temp=q->ne某t;deleteq;}}ele{pre->ne某t=q;pre=pre->ne某t;q=q->ne某t;}}if(p!=NULL)//将多项式A中剩余的结点加入到和多项式中pre->ne某t=p;elepre->ne某t=q;}intmain(){intc;intt=1;cout<<某某某某某某某某某某某某某某某某某某菜单某某某某某某某某某某某某某某某某某<<endl<<endl;cout<<.创建并显示一元多项式A和B，计算一元多项式A加B并显示和<<endl<<endl;cout<<.退出程序.<<endl;cin>>c;witch(c){cae1:Polynomial某p1,某p2;p1=CreatPolyn();潣瑵一元多项式A是:;Print(p1);cout<<endl;p2=CreatPolyn();潣瑵一元多项式B是:;Print(p2);cout<<endl;AddPolyn(p1,p2);潣瑵一元多项式A加B的和是:;Print(p1);cout<<endl;Delete(p1);break;cae2:t=0;break;}}ytem(paue);return0;}五、测试用例：六、实验总结通过这次实验，对于链表的应用知识有了更加深刻的认识，虽然中间出了很多问题，但是经过调试以后都得以解决。

两个一元多项式相加-c++版

《数据结构》实验报告——两个一元多项式相加一、实验题目：两个一元多项式相加二、实验内容：根据所学的数据结构中线性结构（线性表）的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加三、设计思想：（1）建立两个顺序列表，分别用来表示两个一元多项式；顺序列表奇数位，存储该多项式的系数；顺序列表的偶数位，存储该相应多项式的指数。

（2）用成员函数merg(qList<Telem>&l2)实现两多项式的相加。

实现的大致方法为：比较第二个多项式列表与第一个多项式列表的偶数位的数值大小（指数），如果相同，则将他们的前一位数（系数）相加；如果不同，就将他的前一位数（系数）及它自己（指数）插入第一个多项式列表的后面。

（3）建立函数shu(double a[],int j)实现多项式的输入。

四、源程序代码#include "stdafx.h"#include<iostream>using namespace std;template<class Telem>class List{private:Telem * elem;int curlen;int maxlen;public:List(int maxsz=100):maxlen(maxsz){curlen=0;elem=new Telem{maxlen};};List(Telem a[],int n,int maxsz=100):maxlen(maxsz){curlen=n;elem=new Telem[maxlen];for(int i=0;i<n;i++)elem[i]=a[i];};~List(){delete[] elem;};Telem gete(int i){if(i>=1&&i<=curlen)return elem[i-1];else return NULL;};int leng(){return curlen;};List<Telem>&merg(List<Telem>&l2);//声明两多项式相加的成员函数};template<class Telem>List<Telem>&List<Telem>::merg(List<Telem>&l2)//两多项式相加的成员函数的实现{int i,j,m,n,k(0);m=curlen;n=l2.curlen;if(m+n<=maxlen){for(i=0;i<n/2;i++){for(j=0;j<m/2;j++)if(elem[2*j+1]==l2.elem[2*i+1]){k++;elem[2*j]+=l2.elem[2*i];break;}if(j==m/2){elem[m+2*(i-k)]=l2.elem[2*i];elem[m+2*(i-k)+1]=l2.elem[2*i+1];}}}curlen=m+n-2*k;return *this;}void fun(double a[],int j)//该函数实现：输入2j个double型的数，并将其存储到数组中{int i;for(i=0;i<j;i++){double m,n;cout<<"请输入第"<<i+1<<"项的系数和指数:";cin>>m>>n;a[2*i]=m;a[2*i+1]=n;}}void main(){int i,j,k;cout<<"第一个多项式的个数:";cin>>j;double *a=new double[2*j];fun(a,j);cout<<"第二个多项式的个数为:";cin>>k;double *b=new double[2*k];shu(b,k);List<double>s1(a,2*j);List<double>s2(b,2*k);s1.merg(s2);cout<<"二个多项式相加结果为：";for(i=1;i<=s1.leng()/2;i++)//用for循环将这二个多项式结果输出{cout<<s1.gete(2*i-1)<<"X^"<<s1.gete(2*i);if(i!=s1.leng()/2)cout<<"+";}cout<<endl;}五、程序运行结果截图。

线性表——一元多项式的求和

线性表——⼀元多项式的求和♥注：未经博主同意，不得转载。

多项式的表⽰与求和是线性表应⽤的典型案列。

在数学上，⼀元多项式P（x）的表⽰为：P（x）=a0+a1x+a2x2+…+anxn其中，n为⼤于或等于0的整数，表⽰x的幂：a o,a1,…a n为系数，a n≠0,a0，a1，…，a n-1可以为0，也可以不为0。

⼀元多项式的表⽰为了表⽰⼀元多项式，可以将其所有项的系数⽤⼀个线性表来表⽰：（a0,a1,…，a n）。

这个线性表可以使⽤顺序存储结构或链式存储结构来存储，从⽽进⾏多项式的有关运算。

若采⽤顺序存储结构，可使⽤⼀个⼀维数组存储这个线性表，即多项式的系数，⽽相应的幂则使⽤数组下标来表⽰。

⼀元多项式的顺序存储结构如下：1 typedef int DataType;2const int MaxPolySize=100;34class Polyn5 {6private:7 DateType data[MaxPolySize];8int size; //元素的个数910public:11 Polyn(){size = 0;} //构造⼀个空多项式12 ~Polyn();1314void Clear(){size=0;} //清空15 Polyn sum(Polyn a); //多项式相加16 Polyn sub(Polyn a); //多项式相减17 }; 但多项式的顺序存储有⼀个缺点：当存储形如P(x)=1+10x99的多项式时，由于a1到a98均为0，所以⽤来存储⼀元多项式的⼀维数组中的绝⼤部分单元存储的值都是0，导致存储效率低下，造成存储空间的浪费。

因此，⼀般采⽤链式存储结构来描述⼀元多项式。

⼀元多项式的链式存储必须显式地表达系数值和幂值，这是由于链式存储打破了顺序存储中原有的幂与数组下标间的⼀⼀对应关系，⼀元多项式的项的结点结构表⽰如图所⽰。

⼀元多项式的链式存储结构表⽰如下：12struct term3 {4double coef; //系数5int expn; //指数6 };7struct PNode8 {9 term data;10 PNode *next;11 };12class Ployn13 {14 PNode *phead;15public:16 Polyn()17 { //构造函数18 phead =new PNoed;19if(phead= =NULL)20 exit(0);21 phead->next=NULL;22 }23 ~Polyn(); //析构函数2425void PolynAdd(Ployn Pa,Ployn Pb); //两个多项式相加26void Print(); //打印多项式27void Create(); //建⽴多项式28 };29⼀元多项式的求和本节以多项式的加法为例，讲述⼀元多项式操作的实现。

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. 一元多项式的除法一元多项式的除法涉及到较为复杂的算法，需要考虑余数和商的处理。

一元多项式的运算

数据结构课程设计实验报告专业班级：学号：姓名：2011年1月1日题目：一元多项式的运算1、题目描述一元多项式的运算在此题中实现加、减法的运算，而多项式的减法可以通过加法来实现（只需在减法运算时系数前加负号）。

在数学上，一个一元n次多项式P n(X)可按降序写成：P n(X)= P n X^n+ P(n-1)X^(n-1)+......+ P1X+P0它由n+1个系数惟一确定，因此，在计算机里它可以用一个线性表P来表示：P=(P n，P(n-1)，......，P1，P0)每一项的指数i隐含在其系数P i的序号里。

假设Q m(X)是一元m次多项式，同样可以用一个线性表Q来表示：Q=(q m,q(m-1)，.....，q1，q0)不是一般性，假设吗吗m<n，则两个多想是相加的结果：R n(X)= P n(X)+ Q m(X)很显然，可以对P,Q和R采用顺序存储结构，使得多项式相加的算法定义和实现简单化。

然而，在通常的应用中，多项式的次数可能变化很大而且很高，使得顺序存储结构的最大长度很难确定。

特别是在处理项数少且次数特别高的情况下，对内存空间的浪费是相当大的。

因此，一般情况下，都采用链式存储结构来处理多项式的运算，使得两个线性链表分别表示一元多项式P n(X)和Q m(X)，每个结点表示多项式中的一项。

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

通过指针，我们就可以把多个单项式连接起来，形成一个多项式。

2、任务要求系数定义的是float型，范围是3.4*10^-38~3.4*10^38;指数定义的是int型，范围是-2147483648~+2147483647；输入多项式系数及指数，系统会自动将系数转化为浮点型。

功能：（1）．提示输入数据。

数据结构_一元多项式的表示与相加

实验一一元多项式的表示与相加实验目的：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：%6fx^%d",p->cof,p->exp);p=p->next;while (p){if(p->cof>0) printf("+");//系数正负号if (fabs(p->cof)<=0.000001); break;//不输出系数为零的项printf("%6fx^%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语言有些生疏和遗忘，在编程过程中出现很多错误。

一元多项式表示与相加

系数 coef 指数 exp 指针 next
结点结构体定义如下： struct Polynode { int coef; int exp; Polynode *next; } Polynode , * Polylist;
例：建立一元多项式链式存储算法【算法思想】通过键盘输入一组多项式的系数和指数，用尾插法建立一元多项式的链表。以输入系数 0 为结束标志，并约定建立多项式链表时，总是按指数从小到大的顺序排列。【算法描述】
scanf(“%d,%d”,&c,&e);/*键入多项式的系数和指数项*/
while(c!=0)
/*若 c=0，则代表多项式的输入结束*/
{
s=(Polynode*)malloc(sizeof(Polynode)); /* 申请新
的结点*/
s->coef=c ;
s->exp=e ;
rear->next=s ;
① 若 p->exp< q->exp，则结点 p 所指的结点应是“和多项式”中的一项，令指针 p 后移；
② 若 p->exp=q->exp，则将两个结点中的系数相加，当和不为零时修改结点 p 的系数域，释放 q 结点；若和为零，则和多项式中无此项，从 A 中删去 p 结点，同时释放 p 和 q 结点。
B(x)=8x+22x7-9x8
polya
-1
polyb
-1
70 81
31
98
5 17 ∧
22 7
-9 8 ∧
（2）多项式相加的运算规则为了保证“和多项式”中各项仍按升幂排列，在两个多项式中： ①指数相同项的对应系数相加，若和不为零，则构成“和多项式”中的一项； ②指数不相同的项仍按升幂顺序复抄到“和多项式”中。【算法思想】以单链表 polya 和 polyb 分别表示两个一元多项式 A 和 B， A+B 的求和运算，就等同于单链表的插入问题（将单链表 polyb 中的结点插入到单链表 polya 中），因此 “和多项式“中的结点无需另生成。为实现处理，设 p、q 分别指向单链表 polya 和 polyb 的当前项，比较 p、q 结点的指数项，由此得到下列运算规则：

一元多项式的相加(数据结构)

实验报告课程名称：数据结构实验名称：一元多项式的相加班级： 1333 学生姓名：蔡景旺学号： 37一、需求分析1.用户可以根据自己的需求分别输入两个一元多项式（输入必须按指数递增顺序），并且能够实现输入的一元多项式的显示。

2.能够完成两个一元多项式的相加功能并显示结果。

3.程序执行的命令包括：（1）构造链表A （2）构造链表B （3）两个链表的相加（4）求链表的长度（5）打印（显示）已有的链表二、概要设计⒈为实现上述算法，需要线性表的抽象数据类型：ADT Polynomial {数据对象：D={a i:|a i∈TermSet,i=1…n,n≥0TermSet 中的每个元素包含一个表示系数的实数和表示指数的整数} 数据关系：R1={<a i-1,a i>|a i-1,a i∈D,且a i-1中的指数值< a i中的指数值i=2,…n≥0}基本操作:CreatPolyn(&p,m)操作结果：输入m项的系数和指数，建立一个一元多项式P。

DestroyPolyn(&p)初始条件：一元多项式P已存在。

操作结果：销毁一元多项式P。

PrintPolyn(P)初始条件：一元多项式P已存在。

操作结果：打印输出一元多项式P。

PolynLength(P)初始条件：一元多项式P已存在。

操作结果：返回一元多项式中P的项数。

AddPolyn(&Pa,&Pb)初始条件：一元多项式Pa和Pb已存在。

操作结果：完成一元多项式相加运算，即：Pa=Pa+Pb,销毁一元多项式Pb.}ADT Polynomailtypedef struct{ // 项的表示，多项式为linklist的数据元素float coef; //系数int evpn; //指数}term,ElemType; //两个类型名：term用于本ADT,ElemType为Linklist的数据对象名Typedef Linklist polynomial; //用带表头结点的有序链表表示多项式；Int cmp(term a,term b)；void CreatPolyn (polynomial &P,int m){//输入m项的系数和指数，建立表示一元多项式的有序链表PInitList (P); h = GetHead (P);e.coef = 0.0;e.expn = -1;SetCurElem (h,e); //设置头结点的数据元素for （i = 1;i<=m;++i）{//依次输入m项非零项scanf(e.coef,e.expn);if (! LocateElem(P,e,q,(*cmp)){ //当链表不存在指数项if(MakeNode (s,e)) InsFirst(q,s);//生成结点并插入链表}}}//CreatPolynvoid AddPolyn(polynomial &Pa, polynomial &Pb){//多项式加法：Pa=Pa+Pb，利用两个多项式的结点构成“和多项式”ha=Gethead(Pa); hb=Gethead(Pb);//ha和hb分别指向Pa和Pb的头结点qa=NextPos(Pa,ha); qb=NextPos(Pb,hb);// /ha和hb分别指向Pa和Pb的当前结点while(qa&&qb){//qa和qb均非空a=GetCurElem(qa); b=GetCurElem(qb);switch(*cmp(a,b)){case -1: //多项式PA中当前结点的指数值小ha=qa;qa= NextPos(Pa,ha);break;case 0://l两者的指数相等sum=a.cofe+b.cofe;if(sum!=0.0){//修改多项式PA中当前结点的系数值SetCurELem(qa,sum);ha=qa;}else {//删除当前结点Delfirst(ha,qa);FreeNode(qa);}Delfirst(ha,qa);FreeNode(qa); qb=NextPos(Pb,hb); qa=NextPos(Pa,ha);break;Case1://多项式PB中当前结点的指数值小DelFirst(hb,qb); InsFirst(ha,qb);qb=NextPos(Pb,hb); qa=NextPos(Pa,ha);break;}//swtich}//whileIf(!ListEmpty(Pb)) Append(Pa,qb);FreeNode(hb)://释放Pb头结点}//AddPolyn2. 数据结构分析：逻辑结构为线性表，采用链式存储结构。

一元多项式的相加减

实验一一元多项式的表示和相减、相乘一、实验目的1.掌握链表的存储方式2.掌握一元多项式的存储及运算。

二、实验内容已知一元多项式P(x)和Q(x)已存在，求P(x)-Q(x)和P(x)* Q(x)并输出。

要求：1.通过键盘随机输入两多项式P(x)和Q(x)的内容。

2.输出结果要有P(x)和Q(x)的以及它们的差P(x)-Q(x)和乘积P(x)* Q(x)。

三、实验步骤：1.创建一元多项P(x)和Q(x)。

2.求P(x)-Q(x)，P(x)* Q(x)。

3.输出P(x)、Q(x)、P(x)-Q(x)，P(x)* Q(x)。

四、算法说明首先，定义一元多项式的存储方式，然后从键盘输入P(x)和Q(x)对应多项式的各对系数和指数，建立相应的一元多项式五、测试结果参考下图多项式相减多项式相乘六、源代码1.多项式的相减# include<stdio.h># include<malloc.h>typedef struct{float coef; //系数int expn; //指数}ElemType;typedef struct LNode{ //结点类型ElemType data;struct LNode *next;}*LinkList;void MakeNode(LinkList &s,ElemType e){//生成结点s=(LinkList)malloc(sizeof(LNode));s->data=e;}void InsAfter(LinkList p,LinkList s){//插入结点s->next=p->next;p->next=s;}int compare(ElemType e1,ElemType e2){//比较if(e1.expn>e2.expn)return 1;else if(e1.expn<e2.expn)return -1;return 0;}void OrderInsert(LinkList &L,ElemType e,int(*compare)(ElemType,ElemType)){//有序插入LinkList p=L,q=p->next,s;while(q){int n=compare(e,q->data);if(n<0){MakeNode(s,e);InsAfter(p,s);break;}else if(n==0){q->data.coef=q->data.coef+e.coef;if(q->data.coef==0){p->next=q->next;free(q);}break;}p=p->next;q=p->next;}if(q==NULL){MakeNode(s,e);InsAfter(p,s); //最大，放在最后一个位置}}void InitList(LinkList &L){//初始化L=(LinkList)malloc(sizeof(LNode));L->next=NULL;}void SetCurElem(LinkList &p,ElemType e){ //设置结点p->data.coef=e.coef;p->data.expn=e.expn;}void CreatePolyn(LinkList &L,int m){InitList(L);ElemType e;e.coef=0.0;e.expn=-1;SetCurElem(L,e);//设置头结点的数据元素printf("请输入%d对多项式的值：\n",m);for(int i=1;i<=m;i++){scanf("%f%d",&e.coef,&e.expn); //输入值OrderInsert(L,e,compare);}}void show(LinkList L){//输出方法LinkList p=L->next;if(p){ //第一个输出printf("%.2fX^%d",p->data.coef,p->data.expn);p=p->next;}while(p){if(p->data.coef>0)printf("+");printf("%.2fX^%d",p->data.coef,p->data.expn);p=p->next;}printf("\n");}void ListDestroy(LinkList &L){//销毁LinkList p=L,q;while(p){q=p;p=p->next;free(q);}}void subtract(LinkList L1,LinkList L2,LinkList &L3){//多项式相减ElemType e;InitList(L3);e.coef=0.0;e.expn=-1;SetCurElem(L3,e);//设置头结点的数据元素LinkList p1=L1->next,p2=L2->next,q;//r1始终指向新建链表的尾部,p1和p2表示当前结点while(p2){p2->data.coef=-p2->data.coef;p2=p2->next;}p2=L2->next;while(p1&&p2){int n=compare(p1->data,p2->data);switch(n){case -1:{OrderInsert(L3,p1->data,compare);p1=p1->next;break;} //L1中的值小，插入之case 1:{OrderInsert(L3,p2->data,compare);p2=p2->next;break;} //L2中的值小，插入之case 0:{ //相同e.coef=p1->data.coef+p2->data.coef;e.expn=p1->data.expn;if(e.coef!=0){OrderInsert(L3,e,compare);}p1=p1->next;p2=p2->next;break;}}}if(p1){OrderInsert(L3,p1->data,compare);p1=p1->next;} //添加L1else if(p2){OrderInsert(L3,p2->data,compare);p2=p2->next;} //添加L2}LinkList FindThan( LinkList X, LinkList L ){LinkList Tmp;Tmp = L;while( Tmp->next != NULL && Tmp->next->data.expn >= X->data.expn ) {Tmp = Tmp->next;}return Tmp;}int main(){LinkList L1,L2,L3,L4;int m,n;printf("请输入多项式P(X)的项数：");scanf("%d",&m);CreatePolyn(L1,m);printf("多项式P(X)为：\n");show(L1);printf("请输入多项式Q(X)的项数：");scanf("%d",&n);CreatePolyn(L2,n);printf("多项式Q(X)为：\n");show(L2);subtract(L1,L2,L3);printf("多项式P(X)-Q(X)为：\n");show(L3);return 0;}2.多项式的相乘# include<stdio.h># include<malloc.h>typedef struct{float coef; //系数int expn; //指数}ElemType;typedef struct LNode{ //结点类型ElemType data;struct LNode *next;}*LinkList;void MakeNode(LinkList &s,ElemType e){//生成结点s=(LinkList)malloc(sizeof(LNode));s->data=e;}void InsAfter(LinkList p,LinkList s){//插入结点s->next=p->next;p->next=s;}int compare(ElemType e1,ElemType e2){//比较if(e1.expn>e2.expn)return 1;else if(e1.expn<e2.expn)return -1;return 0;}void OrderInsert(LinkList &L,ElemType e,int(*compare)(ElemType,ElemType)){//有序插入LinkList p=L,q=p->next,s;while(q){int n=compare(e,q->data);if(n<0){MakeNode(s,e);InsAfter(p,s);break;}else if(n==0){q->data.coef=q->data.coef+e.coef;if(q->data.coef==0){p->next=q->next;free(q);}break;}p=p->next;q=p->next;}if(q==NULL){MakeNode(s,e);InsAfter(p,s); //最大，放在最后一个位置}}void InitList(LinkList &L){//初始化L=(LinkList)malloc(sizeof(LNode));L->next=NULL;}void SetCurElem(LinkList &p,ElemType e){ //设置结点p->data.coef=e.coef;p->data.expn=e.expn;}void CreatePolyn(LinkList &L,int m){InitList(L);ElemType e;e.coef=0.0;e.expn=-1;SetCurElem(L,e);//设置头结点的数据元素printf("请输入%d对多项式的值：\n",m);for(int i=1;i<=m;i++){scanf("%f%d",&e.coef,&e.expn); //输入值OrderInsert(L,e,compare);}}void show(LinkList L){//输出方法LinkList p=L->next;if(p){ //第一个输出printf("%.2fX^%d",p->data.coef,p->data.expn);p=p->next;}while(p){if(p->data.coef>0)printf("+");printf("%.2fX^%d",p->data.coef,p->data.expn);p=p->next;}printf("\n");}void ListDestroy(LinkList &L){//销毁LinkList p=L,q;while(p){q=p;p=p->next;free(q);}}void Multiply(LinkList L1,LinkList L2,LinkList &L3){//多项式相乘ElemType e;InitList(L3);e.coef=0.0;e.expn=-1;SetCurElem(L3,e);//设置头结点的数据元素LinkList p1=L1->next,p2=L2->next,q;//r1始终指向新建链表的尾部,p1和p2表示当前结点while(p1){p2=L2->next;while(p2){e.coef=p1->data.coef*p2->data.coef;e.expn=p1->data.expn+p2->data.expn;OrderInsert(L3,e,compare);p2=p2->next;}p1=p1->next;} }int main(){LinkList L1,L2,L3;int m,n;printf("请输入多项式P(X)的项数：");scanf("%d",&m);CreatePolyn(L1,m);printf("多项式P(X)为：\n");show(L1);printf("请输入多项式Q(X)的项数：");scanf("%d",&n);CreatePolyn(L2,n);printf("多项式Q(X)为：\n");show(L2);Multiply(L1,L2,L3);printf("多项式P(X)*Q(X)为：\n");show(L3);return 0;}七、分析总结本程序从源代码开始经过多次调试，一开始创建多项式并没有遇到什么问题，但是减法开始遇到问题，好在经过调试和反复检验后问题都得以解决，在多项式相加的基础上修改，相减和相乘就容易得多。

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

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

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

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

第二章多项式的表示1.稀疏数组表示法稀疏数组表示法是一种常用的多项式表示方法。

它通过一个数组来存储多项式中非零项的指数和系数。

数组的下标表示项的指数，数组元素表示项的系数。

对于没有出现的指数，数组元素为零。

2.链表表示法链表表示法是另一种常用的多项式表示方法。

每个节点包含项的指数和系数，并通过指针串接成链表。

链表的节点可以按照指数的升序或降序排列。

第三章多项式的加法多项式的加法是指将两个多项式相加得到一个新的多项式。

具体操作如下：1.根据多项式的表示方法，分别遍历两个多项式的非零项。

2.比较当前项的指数大小，如果两个指数相等，则将系数相加得到新的系数，并将结果加入结果多项式中。

3.如果一个多项式的指数大于另一个多项式的指数，则将该项加入结果多项式中。

4.重复以上操作，直到遍历完所有的非零项。

第四章多项式的减法多项式的减法是指将两个多项式相减得到一个新的多项式。

具体操作如下：1.根据多项式的表示方法，分别遍历被减数和减数的非零项。

2.比较当前项的指数大小，如果两个指数相等，则将被减数的系数减去减数的系数得到新的系数，并将结果加入结果多项式中。

3.如果被减数的指数大于减数的指数，则将该项加入结果多项式中，并将被减数的系数变为相反数。

4.重复以上操作，直到遍历完所有的非零项。

第五章多项式的乘法多项式的乘法是指将两个多项式相乘得到一个新的多项式。

具体操作如下：1.创建一个结果多项式，将其初始化为零多项式。

2.根据多项式的表示方法，分别遍历两个多项式的非零项。

3.将两个项的系数相乘得到新的系数，并将两个项的指数相加得到新的指数。

4.将新的系数和指数合并为一个项，并将该项加入结果多项式中。

一元多项式的乘法与加法运算c 语言

一元多项式的乘法与加法运算c 语言一元多项式是高中数学中一个重要的概念，具有广泛的应用。

在c 语言中，我们可以通过数组和循环来实现一元多项式的乘法和加法运算。

一、一元多项式的表示方式在c语言中，一元多项式通常使用数组来表示。

数组的下标表示该项的指数，数组元素表示该项的系数。

例如，一个一元三次多项式5x^3-3x^2+7x-9在c语言中表示为：int poly[4] = { -9, 7, -3, 5 };其中poly[0]表示常数项系数-9，poly[1]表示x的系数7，以此类推。

二、一元多项式的乘法运算对于两个多项式P(x)和Q(x)，它们的乘积为：(PQ)(x) = ∑(i+j=k) Pi × Qj × xk其中i、j、k分别表示P、Q、PQ中每一项的指数，Pi、Qj表示对应项的系数，xk表示PQ中对应指数的项。

通过这个公式，我们可以使用数组实现一元多项式的乘法运算。

具体实现如下：void poly_mul(int *p, int *q, int *s, int m, int n) {int i, j;memset(s, 0, sizeof(int) * (m + n)); // 将结果数组s初始化为0for (i = 0; i <= m; i++) {for (j = 0; j <= n; j++) {s[i + j] += p[i] * q[j]; // 对应项相乘并累加到结果数组}}}该函数参数分别为两个乘数的数组p、q，结果数组s，以及每个乘数的项数m、n。

在函数内部，我们首先将结果数组s初始化为0，然后使用两个循环遍历乘数数组，对应项相乘并累加到结果数组中。

最后得到的结果数组就是乘积多项式。

三、一元多项式的加法运算对于两个多项式P(x)和Q(x)，它们的和为：(P+Q)(x) = ∑Pi × xi + ∑Qj × xj其中Pi、Qj分别表示对应项的系数，xi、xj表示对应项的指数。

CH2-11 线性表的应用：一元多项式的表示和运算

在数学上，一个一元多项式Pn(x)可按升幂写成：P n (x) = p+ p1x + p2x2 + …+ pnx n它由n+1 个系数唯一确定可用一个线性表P 来表示多现式：P = ( p0 ，p1，p2，…，p n)每一项的指数i隐含在其系数pi 的序号里如何存储多项式1、全部系数顺序存储结构优点：多项式相加的算法定义十分简洁。

缺点：对S型的浪费空间S(x) = 1 + 3x10000 + 2x20000就要用一长度为20001的线性表来表示(表中仅有三个非0元素)2、非零系数顺序存储结构,必须同时存储相应的指数P n(x) = p1x e1+ p2x e2+ …+ p n x e mp i 是指数为e i的项的非0 系数，且满足0 e1< e2< …< e m= n线性表中的数据元素有两个数据项：系数和指数：((p1 ，e1)，(p2 ，e2)，…，(p m ，e m))在最坏情况下，n+1 (=m) 个系数都不为0，则比只存储每项系数的方案要多存储一倍的数据。

对于S(x)类的多项式，这种表示将大大节省空间。

3、非零系数单链表存储结构若只对多项式进行“求值”等不改变多项式的系数和指数的运算，则采用顺序存储结构即可；否则应采用链表表示。

实现一元多项式的相加运算，显然应采用链式存储结构pa(x) = 5 + 2x + x 6+ 8x 15211681550pa(x) = 5 + 2x + x 6+ 8x 15pb(x) = -2x + 3x 6 + 4x8-213648211681550如何实现用有序链表表示的多项式的加法运算？根据一元多项式相加的运算规则：1.对于两个一元多项式中所有指数相同的项，对应系数相加；2.若其和不为0 ，则构成和“多项式”中的一项；3.对于两个一元多项式中所有指数不同的项，则分别复制到“和多项式”中去；-213648211681550（1）pa->exp< pb->exp: 摘去*pa 插到“和多项式”链表中（2）pa->exp= =pb->exp: 将pa->coef + pb->coef若不为0，则修改*pa,释放*pb ；若为0，则删除*pa 和*pb ，并释放*pa 和*pb（3）pa->exp> pb->exp: 摘去*pb 插到“和多项式”链表中0364816815504（1）pa->exp< pb->exp: 摘去*pa 插到“和多项式”链表中（2）pa->exp= =pb->exp: 将pa->coef + pb->coef若不为0，则修改*pa,释放*pb ；若为0，则删除*pa 和*pb ，并释放*pa 和*pb（3）pa->exp> pb->exp: 摘去*pb 插到“和多项式”链表中2.11线性表的应用：一元多项式的加法484681550（1）pa->exp< pb->exp: 摘去*pa 插到“和多项式”链表中（2）pa->exp= =pb->exp: 将pa->coef + pb->coef若不为0，则修改*pa,释放*pb ；若为0，则删除*pa 和*pb ，并释放*pa 和*pb（3）pa->exp> pb->exp: 摘去*pb 插到“和多项式”链表中2.11 线性表的应用：一元多项式的加法484681550（1）pa->exp< pb->exp: 摘去*pa 插到“和多项式”链表中（2）pa->exp= =pb->exp: 将pa->coef + pb->coef若不为0，则修改*pa,释放*pb ；若为0，则删除*pa 和*pb ，并释放*pa 和*pb（3）pa->exp> pb->exp: 摘去*pb 插到“和多项式”链表中p->exp<q->expNp->exp==q->expY X=p->coef+q->coefX==0?Y 删除pN修改p结点系数，指针后移删除qP向后移Y插入q当前指针到pNvoid AddPolyn(linklist*pa, linklist*pb) { p=pa->link;q=pb->link;while(p!=NULL && q!=NULL)){ if (p->exp<q->exp) {取p的结点,p后移}else {if (p->exp==q->exp) {系数相加x= p->coef+q->coef;if x==0 删除p当前结点;else { 修改p当前结点的系数为x;p后移;}删除q当前结点；}else 将q当前结点插入到p中；}if(q!=NULL){将q剩余结点加到和多项式中} else { do nothing？？？}多项式加法涉及到的主要算法：1、建立多项式，考虑加上排序功能2、多项式的输出3、多项式的加法。

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

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

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

数据结构一元多项式的运算在计算机科学和数学领域中，数据结构一元多项式的运算具有重要的地位。

一元多项式是指形如＄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$ 。

在实现加法运算的算法时，需要考虑两个多项式的长度可能不同的情况。

可以使用两个指针分别遍历两个多项式，当其中一个指针到达末尾时，将另一个多项式剩余的项直接添加到结果多项式中。

两个一元多项式相加的算法流程图

两个一元多项式相加的算法流程图下载温馨提示:该文档是我店铺精心编制而成，希望大家下载以后，能够帮助大家解决实际的问题。

文档下载后可定制随意修改，请根据实际需要进行相应的调整和使用，谢谢!并且，本店铺为大家提供各种各样类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，如想了解不同资料格式和写法，敬请关注!Download tips: This document is carefully compiled by theeditor. I hope that after you download them,they can help yousolve practical problems. The document can be customized andmodified after downloading,please adjust and use it according toactual needs, thank you!In addition, our shop provides you with various types ofpractical materials,such as educational essays, diaryappreciation,sentence excerpts,ancient poems,classic articles,topic composition,work summary,word parsing,copy excerpts,other materials and so on,want to know different data formats andwriting methods,please pay attention!1. 开始输入两个一元多项式 P(x) 和 Q(x)。