一元多项式的求和

合集下载

一元多项式的求和运算

一元多项式的求和运算一元多项式的求和运算是代数学中的重要概念，它涉及到多项式的基本运算和代数方程的求解。

在本文中，我们将全面介绍一元多项式的求和运算，并提供一些指导意义。

一元多项式是由若干项组成的，每一项包含一个常数乘以一个变量的幂。

例如，多项式f(x) = 3x^2 + 2x + 1就是一个一元多项式，其中包含了三个项：3x^2、2x和1。

求和运算即将多项式中的所有项相加，得到一个结果。

求和运算过程中，首先需要将多项式按照指数从高到低排列。

这样做的目的是方便相同指数的项合并，从而简化求和的过程。

例如，对于多项式f(x) = 3x^2 + 2x + 1，按照指数从高到低排列后，变为f(x) = 3x^2 + 2x + 1。

接下来，我们将相同指数的项合并。

在本例中，没有相同指数的项，所以不需要合并。

最后，将所有项相加，得到最终结果。

除了将相同指数的项合并外，求和运算还可以应用于求解代数方程。

当我们需要找到使得多项式等于零的变量值时，可以通过求和运算得到该变量的解。

例如，若要求解方程f(x) = 0，可以将多项式按照指数从高到低排列，并将所有项相加。

若最终结果为0，即表明该变量的某个值满足方程。

一元多项式的求和运算在数学和科学中有广泛的应用。

在代数学中，基于求和运算的多项式求解技术被广泛应用于方程求解、多项式插值和最小二乘拟合等问题中。

在物理学中，一元多项式的求和运算用于描述物理量之间的关系，如牛顿运动定律、电路分析和热力学方程等。

在经济学和金融学中，多项式的求和运算用于建模和预测经济变量，如股票价格、利率和通货膨胀率等。

通过一元多项式的求和运算，我们可以更好地理解多项式的性质和特点，从而应用于实际问题的求解。

同时，求和运算也是培养数学思维和解决实际问题的重要途径之一。

通过合理运用多项式的求和运算，我们可以化繁为简，解决复杂的问题。

综上所述，一元多项式的求和运算是代数学中的重要概念，它不仅包括多项式的基本运算和代数方程的求解，还具有广泛的应用。

一元多项式求和

一元多项式求和——链表编程一．实验名称：一元多项式求和——链表编程。

二．实验环境：Windows Xp ,Vc++6.0。

三．实验目的：1.掌握一元多项式的链表式存储算法；2.掌握链表的结构定义；3.采用尾插法生成单链表。

四．实验内容：1.一元多项式的表示：一元多项式可按升幂的形式表示为12012()n e e e n n P x p p x p x p x =++++……其中：i e 为第i 项的指数，i p 是指数i e 的项的系数，且121i n e e e e <=<=<=<=<=<=……。

则多项式()n P x 可以用一个线性表P 来表示：01(,)m P p p p =,?,；同理，多项式()n Q x 可表示为01(,,)n Q q q q =…（m<n ）。

其和多项式可表示为00111(,,,)m m m n R p q p p q q +=+++q ,?,?,q 。

2.一元多项式的链式存储：1）链式存储的结点结构：一元多项式中每一个非零项都由两部分构成——指数项和系数项。

下面为结点结构的定义：struct polynode{ int coef;int exp;polynode *next;} polynode, *polylist;2)建立一元多项式链式存储的算法：【算法思想】运用尾插法建立一元多项式的链表。

以输入系数0为结束标准，并约定建立一元多项式时，总是按指数从小到大的顺序排列。

算法如下：polylist polycreate(){ polynode *head,*rear,*s;int c,e;head=(polynode *)malloc(sizeof(polynode));rear=head;scanf("%d,%d",&c,&e);while(c!=0){ s=(polynode *)malloc(sizeof(polynode));s->codf=c;s->exp=e;rear->next=s;rear=s;scanf("%d,%d"&c,&e);}rear->next=NULL;return(head);}3.多项式相加的运算规则：【算法思想】以单链表polya和polyb分别表示两个一元多项式A和B，A+B，求和运算，就等同于单链表的插入问题。

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

一元多项式计算(数据结构课程设计)一、系统设计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环境中调试运行。

完整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;}五、测试用例：六、实验总结通过这次实验，对于链表的应用知识有了更加深刻的认识，虽然中间出了很多问题，但是经过调试以后都得以解决。

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

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

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

在数学上，⼀元多项式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⼀元多项式的求和本节以多项式的加法为例，讲述⼀元多项式操作的实现。

一元多项式问题

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

一、问题描述：一元多项式相加是通过键盘输入两个形如p0+p1*x^1+p2*x^2+pn*x^n的多项式，经过程序运算后在屏幕上输出它们的相加和。

二、数据结构设计：分析任意一元多项式的描述方法可知，一个一元多项式的每一个子项都有“系数—指数”两部分组成，所以可以将它抽象成一个有“系数—指数对”构成的线性表，由于对多项式中系数为0的子项可以不记录它的指数值，对于这样的情况就不再付出存储空间来存放它了。

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

具体数据类型定义为：typedef struct node{float coef;int exp;int flag;struct node *next;}PolyNode;三、功能（函数）设计：1、输入并建立多项式的功能模块PolyNode * create(){float A;int B;PolyNode *a=NULL;PolyNode *b=NULL;PolyNode *c=NULL;scanf("%f,%d",&A,&B);while(A!=0||B!=0){if(A!=0){c=new PolyNode;c->coef=A;c->exp=B;c->flag=0;c->next=NULL;if(a==NULL){a=c;b=a;}else{b->next=c;b=c;}}scanf("%f,%d",&A,&B);}return a;}2、多项式相加的功能模块PolyNode *add(PolyNode *p,PolyNode *q){PolyNode *x,*y;PolyNode *r=NULL;PolyNode *c=NULL;PolyNode *l=NULL;x=p;y=q;while(x&&y){r=new PolyNode;if(x->exp==y->exp){r->coef=x->coef+y->coef;r->exp=x->exp;r->flag=0;r->next=NULL;x->flag=1;y->flag=1;x=x->next;y=y->next;}else if(x->exp>y->exp){r->coef=y->coef;r->exp=y->exp;r->flag=0;r->next=NULL;y->flag=1;y=y->next;}else{r->coef=x->coef;r->exp=x->exp;r->flag=0;r->next=NULL;x->flag=1;x=x->next;}if(c==NULL){c=r;l=c;}else{l->next=r;l=r;}}if(x==NULL)x=y;while(x){r=new PolyNode;r->coef=x->coef;r->exp=x->exp;r->flag=0;r->next=NULL;if(c==NULL){c=r;l=c;}else{l->next=r;l=r;}x->flag=1;x=x->next;}return c;}3、多项式显示的功能模块int print(PolyNode *w){if(w==NULL){cout<<'0';return 0;}PolyNode *v;v=w;cout<<'(';if(v->coef<0)cout<<'-';cout<<v->coef<<'x'<<v->exp;v=v->next;while(v){if(v->coef>=0)cout<<'+';cout<<v->coef<<'x'<<v->exp;v=v->next;}cout<<')';}四、界面设计：注意提示用户每一步操作输入的格式和限制，指导用户按照正确的格式输入数据。

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

实验一一元多项式的表示与相加实验目的：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语言有些生疏和遗忘，在编程过程中出现很多错误。

一元多项式相加完整实验报告

一元多项式相加实验报告一元多项式的相加一实验内容根据所学的数据结构中线性结构（线性表）的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加二需求分析1掌握线性结构的逻辑特性和物理特性。

2建立一元多项式。

3将一元多项式输入，并存储在内存中，并按照指数降序排列输出多项式。

4能够完成两个多项式的加减运算，并输出结果。

三概要设计1 本程序所用到的抽象数据类型：typedef OrderedLinkList polynomial;// 用带表头结点的有序链表表示多项式结点的数据元素类型定义为:typedef struct { // 项的表示float coef; // 系数int expn; // 指数 term, ElemType;V oid AddPolyn(polynomail&Pa,polynomail&Pb)Position GetHead()Position NextPos(LinkList L,Link p)Elem GetCurElem(Link p)int cmp(term a term b)Status SetCurElem(Link&p, ElemType e)Status DelFirst(Link h, Link &q)Status ListEmpty(LinkList L)Status Append(LinkList&L, Link S)FreeNode()2 存储结构一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。

它包含三个域，分别存放多项式的系数，指数，以及指向下一个项的指针。

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

3 模块划分a) 主程序；2）初始化单链表；3）建立单链表； 4）相加多项式4 主程序流程图四详细设计根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项，对于两个一元多项式中所有指数不相同的项，则分别复抄到“和多项式”中去。

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

2.4 一元多项式的表示和相加

2.4 一元多项式的表示和相加一元多项式：P n（x）=p0+p1x+p2x2+ …+p n x n在计算机中，可以用一个线性表来表示：P = （p0， p1，…，p n）但是对于形如 S（x） = 1 + 3x10000– 2x20000 的多项式，上述表示方法是否合适？一般情况下的一元稀疏多项式可写成P n(x) = p1x e1 + p2x e2+ ┄ + p m x em其中：p i是指数为e i的项的非零系数，0≤ e1 < e2< ┄ < e m = n可以下列线性表表示：（（p1, e1）, (p2, e2), …, (p m,e m) ）例如:多项式P999(x) = 7x3 - 2x12 - 8x999可用线性表 ( （7, 3）, （-2, 12）, （-8, 999））) 表示抽象数据类型一元多项式的定义如下：ADT Polynomial {数据对象：D＝{ a i | a i∈TermSet, i=1,2,...,m, m≥0TermSet 中的每个元素包含一个表示系数的实数和表示指数的整数 } 数据关系：R1＝{ <a i-1 ,a i >|a i-1，a i∈D， i=2,...,n且a i-1中的指数值＜a i中的指数值 }基本操作：多项式的有关操作} ADT Polynomial一元多项式的实现：typedef OrderedLinkList polynomial； // 用带表头结点的有序链表表示多项式结点的数据元素类型定义为：typedef struct { // 项的表示float coef； // 系数int expn； // 指数} term, ElemType；void CreatPolyn (polynomail &p, int m); {//输入m项的系数和指数，建立表示一元多项式的有序链表P InitList (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)；//生成结点并插入链表}}}//CreatPolyn算法：2.22void AddPolyn (polynomial &Pa, polynomial &Pb) { // 多项式加法：Pc = Pa＋Pb，利用两个多项式的结//点构成“和多项式”ha = GetHead (La)； hb = GetHead (Lb)；//ha和hb分别指向La和Lb的头结点pa = NextPos ( La, ha)； pb = NextPos ( Lb, hb)； //pa和pb分别指向La和Lb中当前结点while ( pa && pb ){ // La和Lb均非空a = GetCurElem ( pa )；b = GetCurElem ( pb )； //a和b为两表中当前比较元素switch (*cmp(e1, e2)) {case -1：{ // 多项式PA中当前结点的指数值小ha=qa； qa = NextPos ( Pa, qa)； break；case 0： { // 两者的指数值相等sum= a.coef + b.coef ;if ( sum != 0.0 ) {//修改多项式PA中当前结点的系数值 SetCurElem (qa, sum)； ha=qa；}else { //删除多项式PA中当前结点DelFirst (ha, qa)； FreeNode (qa)；}DelFirst(hb, qb)； FreeNode(qb)；qb=NextPos ( Pb, qb)； qa = NextPos ( Pa, qa)； break；case 1: { //多项式PB中当前结点的指数值小 DelFirst (hb, qb)； InsFirst (ha, qb)；qb =NextPos ( Pb, qb)；ha = NextPos ( Pa, qa)；break； }//switch}//whileif (!ListEmpty (Pb)) Append (Pa, qb)；//链接Pb中剩余结点 FreeNode (hb)； // 释放Pb的头结点} // AddPolyn算法：2.23本章小结1、了解线性表的逻辑结构特性，以及线性表的顺序存储结构和链式存储结构。

一元多项式表示与相加

系数 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 结点的指数项，由此得到下列运算规则：

一元多项式相加

⼀元多项式相加描述：对于两个⼀元多项式，如果需要对他们进⾏多项式相加操作，常见的两种思路如下：(1)对于⼀个多项式，保存其最⾼项次数HighPowder，以及⼀个该多项式对应次数分别为0-HighPowder的各项的系数的数组()。

(2)多项式中系数不为零的每⼀项，保存其系数与该项的次数。

下⾯分别⽤这两种思路实现⼀元多项式加法操作。

思路⼀（数组实现）：数据结构定义：1 typedef struct Poly2 {3int CoeffArray[11];4int HighPower;5 } *Polynomial;实现：1 #include <stdio.h>2 #include <stdlib.h>34 typedef struct Poly5 {6int CoeffArray[11];7int HighPower;8 } *Polynomial;910void ZeroPolynomial(Polynomial Poly)11 {12int i;13for(i = 0; i < 11; i++)14 {15 Poly->CoeffArray[i] = 0;16 }17 Poly->HighPower = 0;18 }1920void AddPolynomial(Polynomial Poly1,Polynomial Poly2, Polynomial PolySum)21 {22int i;23 ZeroPolynomial(PolySum);24 PolySum->HighPower = Poly1->HighPower > Poly2->HighPower?25 Poly1->HighPower:Poly2->HighPower;26for(i = PolySum->HighPower; i >= 0 ; i--)27 {28 PolySum->CoeffArray[i] = Poly1->CoeffArray[i] + Poly2->CoeffArray[i];29 }30 }3132int main(void)33 {34int i,j,k;35 Polynomial P1,P2,Sum;36 P1 = malloc(sizeof(struct Poly));37 P2 = malloc(sizeof(struct Poly));38 Sum = malloc(sizeof(struct Poly));39//初始化40 ZeroPolynomial(P1);41 ZeroPolynomial(P2);42 P1->HighPower = 10;43for(i = 10; i >= 0; i--)44 {45 P1->CoeffArray[i] = i;46 }4748 P2->HighPower = 8;49for(j = 8; j >=0; j--)50 {51 P2->CoeffArray[j] = j;52 }53 P2->CoeffArray[8] = 8;54 AddPolynomial(P1,P2,Sum);5556 printf("The high power of the Polynomial is %d\n",Sum->HighPower); 57for(k = 0; k <= 10; k++)58 {59 printf("The Coeff of power %d is %d\n",k,Sum->CoeffArray[k]);60 }6162return0;63 }它适合⼤部分项都有的稠密多项式。

一元多项式的相加减

实验一一元多项式的表示和相减、相乘一、实验目的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;}七、分析总结本程序从源代码开始经过多次调试，一开始创建多项式并没有遇到什么问题，但是减法开始遇到问题，好在经过调试和反复检验后问题都得以解决，在多项式相加的基础上修改，相减和相乘就容易得多。

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

B(x) 8x 22x7 9x8
C(x) A(x) B(x) 7 11x 22x7 5x17
A
-1
70
31
98
5 17 ^
B
-1
81
22 7 -9 8 ^
C
-1
70
11 1 22 7
5 17 ^
运算规则
设p,q分别指向A,B中某一结点，p,q初值是第一结点
p->exp < q->exp: p结点是结果多项式
•重点：线性表的顺序存储；线性表的链式存储；顺序表的插入、删除单链表的插入、删除
•难点：双向链表的系列操作线性表的应用。
if(x!=0){ p->coef=x; pre=p;} else { pre->next=p->next; free(p);}
p=pre->next; u=q; q=q->next; free(u); } else { u=q->next;q->next=p;pre->next=q;
pre=q; q=u; } } if(q!=NULL) pre->next=q; free(pb); }
算法描述
pre
p pre
p pre
pp
p
ppaa
--11
77 00
31111 111
99 88
55 1177 ^^
ppbb
--11
88 11
2222 77
--99 88 ^^ q=NULL
q
prqe
q
pa
-1
70
11 1
22 7
5 17 ^
Ch2_7.c

算法与数据结构实验一元多项式求和

《算法与数据结构》实验报告姓名：***班级：计科01学号：**********实验题目：链表的应用实验内容：一元多项式求和把任意给定的两个一元多项式P(x),Q(x)输入计算机，计算它们的和并输出计算结果。

设计分析：一元多项式可以用单链表表示，结点结构图示如下：Array一元多项式链表的结点结构一元多项式算法伪代码如下：源程序代码：#include"StdAfx.h"#include<stdlib.h>typedef struct LNode{int x,z;struct LNode *next;}LinkList;void OutLinkList(LinkList *L);void PutLinkList(LinkList *&L,int n);LinkList *AddLinkList(LinkList *a,LinkList *b);void OutXLinkList(LinkList *L);void OutZLinkList(LinkList *L);void main(){int n,m;LinkList *a,*b,*c;printf("\t\t\t本À?程¨¬序¨°可¨¦以°?完ª¨º成¨¦两¢?个?一°?元a多¨¤项?式º?的Ì?加¨®法¤¡§运?算?。

¡ê\n");printf("请?输º?入¨?一°?元a多¨¤项?式º?a的Ì?项?数ºym：êo");scanf("%d",&m);printf("请?按ã¡ä照?从ä¨®低Ì¨ª次ä?到Ì?高?次ä?的Ì?顺3序¨°依°¨¤此ä?输º?入¨?一°?元a多¨¤项?式º?a的Ì?系¦Ì数ºy和¨ª指?数ºy：êo\n");PutLinkList(a,m);printf("a=");OutLinkList(a);printf("请?输º?入¨?一°?元a多¨¤项?式º?b的Ì?项?数ºyn：êo");scanf("%d",&n);printf("请?按ã¡ä照?从ä¨®低Ì¨ª次ä?到Ì?高?次ä?的Ì?顺3序¨°依°¨¤此ä?输º?入¨?一°?元a多¨¤项?式º?b的Ì?系¦Ì数ºy和¨ª指?数ºy：êo\n");PutLinkList(b,n);printf("b=");OutLinkList(b);c=AddLinkList(a,b);printf("两¢?个?多¨¤项?式º?的Ì?和¨ª为a：êo\na+b=");OutLinkList(c);}void PutLinkList(LinkList *&L,int n){LinkList *s,*r;L=(LinkList *)malloc(sizeof(LinkList));r=L;for(int i=0;i<n;i++){s=(LinkList *)malloc(sizeof(LinkList));printf("请?输º?入¨?第Ì¨²%d项?的Ì?系¦Ì数ºy：êo",i+1);scanf("%d",&s->x);printf("请?输º?入¨?第Ì¨²%d项?的Ì?指?数ºy：êo",i+1);scanf("%d",&s->z);r->next=s;r=s;}r->next=NULL;}void OutLinkList(LinkList *L) {char FuHao;LinkList *p=L->next;FuHao=p->x>0? '+':'-';if(FuHao=='-'){printf("%c",FuHao);if(p->x==-1)printf("1");}OutXLinkList(p);OutZLinkList(p);p=p->next;while(p!=NULL){FuHao=p->x>0? '+':'-';printf("%c",FuHao);OutXLinkList(p);OutZLinkList(p);p=p->next;}printf("\n");}void OutXLinkList(LinkList *L) {int xi=L->x>0? L->x:-L->x;if(L->x==1||L->x==-1);elseprintf("%d",xi);}void OutZLinkList(LinkList *L) {if(L->z==0);else if(L->z==1||L->z==-1){if(L->z<0){if(L->x==1||L->x==-1)printf("1");printf("/");}printf("X");}else{if(L->z<0)printf("/");int zhi=L->z>0? L->z:-L->z;printf("X^%d",zhi);}}LinkList *AddLinkList(LinkList *a,LinkList *b){a=a->next;b=b->next;LinkList *c,*d,*s;c=(LinkList *)malloc(sizeof(LinkList));d=c;while(a!=NULL&&b!=NULL){if(a->z<b->z){s=(LinkList *)malloc(sizeof(LinkList));s->x=b->x;s->z=b->z;d->next=s;d=s;b=b->next;}else if(a->z>b->z){s=(LinkList *)malloc(sizeof(LinkList));s->x=a->x;s->z=a->z;d->next=s;d=s;a=a->next;}else{s=(LinkList *)malloc(sizeof(LinkList));s->x=a->x+b->x;s->z=a->z;if(s->x==0);else{d->next=s;d=s;}a=a->next;b=b->next;}}if(a!=NULL)d->next=a;else if(b!=NULL)d->next=b;elsed->next=NULL;return c;}测试用例：当a=3x^8-x^5+2x^3+7x^2+5x,b=5x^5+3x^4-7x^2-3x^(-3)时，运行结果如下：试验总结：通过本次试验，学会了链表的应用，加深了对链表的理解，知道了链表是把线性表中的元素按照链式储存方式到计算机中的一片连续的储存空间中。

一元多项式相加问题

一元多项式运算一、需求分析1．程序的功能一元稀疏多项式简单计算器的基本功能包括：1．按照指数升序次序，输入并建立多项式A与B，2．计算多项式A与B的和，即建立多项式A+B，3．按照指数升序次序，输出多项式A、B、A+B。

2．输入输出的要求输入要求：按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项：“系数、指数对”。

输出要求：可以在文本界面下，采用类似于数学表达式的方式输出多项式，如多项式A 可显示为：A=3+6X∧3-2X∧8+12X∧20。

需要注意：1.系数值为1的非零次项的输出形式中略去系数1，如子项1x8的输出形式为x8，项－1x3的输出形式为－x3；2.多项式的第一项的系数符号为正时，不输出“+”，其它项要输出“+”、“-”符号。

3．测试数据1．(x+3x6－8.6x11)+(6－3x6+21x9)=6+x+21x9－8.6x112．(3x－3－x+4.1x2－1.2x9)＋(―3x―3－5.1x2 +7.8x12)=－x－x2－1.2x9+7.8x123．(x+x3)+(―x―x3)=04．(x+x100)+(x100+x200)=(x+2x100+x200)5．(x+x2+x3)+0=x+x2+x3二、概要设计1．本程序所用的抽象数据类型的定义一元n次多项式：P(x,n)=P0+P1X1+P2X2+…+P n X n，其每一个子项都是由“系数”和“指数”两部分来组成的，因此可以将它抽象成一个由“系数、指数对”构成的线性表，其中，多项式的每一项都对应于线性表中的一个数据元素。

由于对多项式中系数为0的子项可以不记录它的指数值，对于这样的情况就不再付出存储空间来存放它了；基于此，可以采用一个带有头结点的单链表来表示一个一元多项式。

2．主模块的流程及各子模块的主要功能主模块的主要流程如下：（1）输入多项式，建立多项式链表；（2）多项式相加，进行多项式的相加工作；（3）完成多项式的输出；3．模块之间的层次关系该模块的层次关系如下：首先建立两个多项式，并将其储存，接下来调用多项式的加法函数对其进行相加的操作，最后，在屏幕上显示多项式相加的结果。

一元多项式相加

《数据结构》课设计报告2012—2013学年第一学期课程名称数据结构设计题目用单链表实现集合的操作专业班级姓名学号指导教师一元多项式相加1.问题描述已知A（x）=a0+a1x+a2x2+…+a n x n 和B（x）= b0+b1x+b2x2+…+b n x m ,并且在A（x）和B（x）中指数相差很多，求A（x）= A（x）+ B（x）。

2.基本要求(1)设计存储结构表示一元多项式;(2)设计算法实现一元多项式相加;(3)分析算法的时间复杂度和空间复杂度.3.设计思想一元多项式求和实际上是合并同类项的过程，其运算规则为：（1）若两项的指数相等，则系数相加；（2）若两项的指数不相等，则将两项加在结果中。

一元多项式由n+1个系数唯一确定，因此，可以用一个线性表来表示，每一项的系数i隐含在其系数ai的序号里。

但是，当多项式的指数很高且变化很大时，在表示多项式的线性表中就会存在很多0元素。

一个较好的存储方法就是只存非0元素，但是需要在存储非0元素系数的同时存储相应的指数。

这样，一个一元多项式的每一个非0项可由系数和指数唯一表示。

由于两个一元多项式相加后，会改变多项式的指数和系数，因此采用顺序表不合适。

采用单链表存储，则每一个非0项对应单链表中的一个节点，且单链表应按指数递增有序排列。

其中：Coef是系数域，存放非0项的系数；Exp是指数域，存放非0项的指数；Next是指针域，存放指向下一个节点的指针。

将两个一元多项式用两个单链表存储后，如何实现二者相加呢？设两个工作指针p和q，分别指向两个单链表的开始节点。

通过对节点p的指针域和节点q的指针域进行比较进行同类项合并，则出现下列三种情况：1.若p->exp小于q->exp，则节点p应为结果中的一个节点。

2. 若p->exp大于q->exp，则节点q应为结果中的一个节点，将q插入到第一个链表中节点p之前。

3.若p->exp等于q->exp，则节点p与节点q为同类项，将q的系数加到p 的系数上。

一元多项式的求和

一元多项式的求和一元多项式的求和是数学中的一个重要概念，它涉及到对多个项的系数进行加法运算，从而得到一个结果。

在代数学中，一元多项式是由一个变量和它的各次幂所组成的表达式。

求和则是将多个项相加的过程。

本文将围绕一元多项式的求和展开讨论，介绍求和的基本概念、求和的性质以及求和的应用。

一、求和的基本概念在数学中，求和是将一系列数值按照一定规则相加的运算。

对于一元多项式的求和，我们需要先了解一元多项式的基本结构。

一元多项式由一个变量和它的各次幂所组成，例如：2x^2 + 3x + 1。

其中，2、3、1是各项的系数，x^2、x、1是各项的幂次。

一元多项式的求和就是将这些项的系数相加得到的结果。

二、求和的性质求和具有以下几个重要的性质：1. 求和是可交换的：对于任意两个多项式f(x)和g(x)，有f(x)+g(x)=g(x)+f(x)。

这意味着求和的顺序可以改变，不影响最终的结果。

2. 求和是可结合的：对于任意三个多项式f(x)、g(x)和h(x)，有(f(x)+g(x))+h(x)=f(x)+(g(x)+h(x))。

这意味着多个多项式相加时，可以先将前两个多项式相加，再与第三个多项式相加，结果是一样的。

3. 求和的零元素：对于任意一个多项式f(x)，存在一个称为零多项式的多项式0(x)，使得f(x)+0(x)=f(x)。

这意味着将零多项式与任意多项式相加，结果仍然是原来的多项式。

三、求和的应用求和在数学中有着广泛的应用，尤其在代数学、概率论、统计学等领域具有重要作用。

下面以几个具体的例子来说明求和的应用：1. 等差数列求和：对于一个等差数列a，其通项公式为an=a1+(n-1)d，其中a1为首项，d为公差，n为项数。

等差数列的求和公式为Sn=(a1+an)n/2，其中Sn为前n项的和。

通过等差数列的求和公式，我们可以方便地计算出一个等差数列的和。

2. 等比数列求和：对于一个等比数列b，其通项公式为bn=b1*q^(n-1)，其中b1为首项，q为公比，n为项数。