一元多项式的相加减复习过程

合集下载

一元多项式的定义和运算讲解

一元多项式的定义和运算讲解
定理 2.4.1
令f (x)是F [x]的一个次数大于零的多项式,并且
此处
定理 2.4.2
例 在有理数域上分解多项式 为不可约因式的乘积.容易看出
(2)
一次因式x + 1自然在有理数域上不可约.我们证明, 二次因式 也在有理数域上不可约.不然的话, 将能写成有理数域上两个次数小于2的因式 的乘积,因此将能写成
这个定义的条件也可以用另一种形式来叙述
若多项式 有一个非平凡因式 而 ,那么 与 的次数显然都小于 的次数.反之,若 能写成两个这样的多项式的乘积,那么 有非平凡因式.因此我们可以说:
这里
多项式的减法
2.1.5 多项式加法和乘法的运算规则
(1)加法交换律:
(2)加法结合律:
(3)乘法交换律:
(4)乘法结合律:
(5)乘法对加法的分配律:
注意:
要把一个多项式按“降幂”书写

时,
叫做多项式的首项.
2.1.6 多项式的运算性质
定理
是数环R上两个多项式,并且
定义 2
设 是多项式 与 的一个公因式.若是 能被 与 的每一个公因式整除,那么 叫做 与 的一个最大公因式.
定义 1
的任意两个多项式 与 一定有最大公因式.除一个零次因式外, 与 的最大公因式是唯一确定的,这就是说,若 是 与 的一个最大公因式,那么数域F的任何一个不为零的数 c与 的乘积 ,而且当 与 不全为零多项式时,只有这样的乘积是 与 的最大公因式.
由此得出,


的最大公因式,而
定理 2.3.3
的两个多项式 与 互素的充分且必要条 件是:在 中可以求得多项式 与 ,使

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

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

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

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

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

3.3功能算法描述与数据结构说明
该多项式程序除了main()函数外,主要有以下函数: void Insert(Polyn p,Polyn h) Polyn CreatePolyn(Polyn head,int m) void DestroyPolyn(Polyn p) void PrintPolyn(Polyn P) int compare(Polyn a,Polyn b) Polyn AddPolyn(Polyn pa,Polyn pb) Polyn SubtractPolyn(Polyn pa,Polyn pb) Polyn MultiplyPolyn(Polyn pa,Polyn pb) 下面对这些函数逐一介绍。 3.3. 系统主要功能函数的详细设计 1. main()函数 main函数用来实现提示使用者输入、显示功能列表、调用其他运算 函数实现运算功能。 在main()函数中,定义m、n用来保存两个多项式的项数,pa、 pb、pc、pd、pf定义程序所需链表的头指针。在程序开始要求输入两个 多项式的项数,随后根据项数创建两个链表以保存多项式,再显示出功 能列表后通过if语句来实现功能的选择,从而对整个程序流程进行控 制。 2. Polyn CreatePolyn(Polyn head,int m) 该函数功能是创建新的多项式链表。int m保存的多项式的项数,
使用for语句,控制输入多项式的每一项。当创建的链表长度为m时,将 不再提示用户继续输入多项式的系数和指数。 在该函数中要用到分配空间的函数malloc()为新建链表分配空间。 3. void DestroyPolyn(Polyn p) 该函数的功能是销毁掉创建的两个链表,释放内存。以辅助退出程 序。 4. void Insert(Polyn p,Polyn h) 该函数功能:将新的节点p插入到现有链表的后面,并确保多项式 的指数exp是升序。将s节点插入到head所指向的链表。在该函数的操作 中,要注意指针是如何移动的。 5. Polyn AddPolyn(Polyn pa,Polyn pb) 该函数功能:实现两个多项式pa、pb相加,并将计算结果存储于新 建立的pc中,它的原理是将指数相同的单项式相加,系数相加后为0, 则pa、pb的指针都后移。在加法计算中要求pa,与pb的幂次序都是升 序,否则可能得到错误的结果。 该函数调用了int compare(Polyn a,Polyn b)的结果,用来判断多 项式在同一指数下a、b是否有为系数为0。同样也使用了malloc()关键 字,为新链表创建空间。 6. int compare(Polyn a,Polyn b) 该函数功能:判断两个多项式在同一指数下是否有其中一个为系数 为0。用来辅助加法和乘法运算。 7. Polyn SubtractPolyn(Polyn pa,Polyn pb) 该函数功能:实现两个多项式pa、pb相减,其原理根加法类似,将 指数相同的指数相减。与加法不同的是在送在减法中,创建了新的链表 来存放结果,并返回该链表的头指针。 8. void PrintPolyn(Polyn P) 该函数功能:显示多项式链表。在该函数中较复杂的是如何控制链 表的输出,尤其是第一项的输出,同时还有符号的控制。在输出第一项 时要判断是不是常数项,若是,则不要输出字符x。 9. Polyn MultiplyPolyn(Polyn pa,Polyn pb) 函数功能:实现两个多项式相乘,A(X) * B(x) 。计算时运用单项 式与多项式相乘的法则,然后再次运用单项式与多项式相乘的法则。

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

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

实验一一元多项式的表示与相加实验目的:1.复习并熟练掌握数据结构所使用的程序设计语言——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语言有些生疏和遗忘,在编程过程中出现很多错误。

一元多项式环的概念及其通用性质

一元多项式环的概念及其通用性质

03 一元多项式的加法与减法
加法规则
设两个一元多项式为$P(x) = a_0 + a_1x + a_2x^2 + ldots + a_nx^n$和$Q(x) = b_0 + b_1x + b_2x^2 + ldots + b_mx^m$, 则它们的和$P(x) + Q(x)$定义为系数相加,即$(a_0 + a_1x + a_2x^2 + ldots + a_nx^n) + (b_0 + b_1x + b_2x^2 + ldots + b_mx^m) = (a_0+b_0) + (a_1+b_1)x + (a_2+b_2)x^2 + ldots + (a_n+b_n)x^n$。
一元多项式环的概念及其通用性质
目录
• 一元多项式环的定义 • 一元多项式环的基本性质 • 一元多项式的加法与减法 • 一元多项式的乘法 • 一元多项式的除法 • 一元多项式环的特殊性质
01 一元多项式环的定义
定义
一元多项式环是由所有一元多项式构 成的环,其中加法、减法和乘法运算 封闭。
一元多项式环中的元素称为一元多项 式。
THANKS FOR WATCHING
感谢您的观看
举例说明:$(x^2+3x+2) - (x+1) = (1-1)x^2 + (3-1)x + (2-1) = 0x^2 + 2x + 1$。
04 一元多项式的乘法
单项式与多项式相乘
定义
举例
单项式与多项式相乘是指将单项式的每一项 分别与多项式的每一项相乘,并合并同类项。

一元多项式表示与相加

一元多项式表示与相加

系数 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.2_一元多项式的定义和运算

§1.2_一元多项式的定义和运算

an 0, bm 0 anbm 0
f x g x 0
f x g x nm
多项式乘法没有零因子。
第一章 多项式
推论1:若 f x g x 0 f x 0或g x 0 证:若f=0或g=0,则必有fg=0。 反之,若 f x 0, g x 0
第一章
多项式
定义2: f x , g x 是两个多项式, f x g x
最高次项, 亦称为首项。 除系数为0的项之外,同次项的系数都相等。 多项式的表法唯一。 方程 a0 a1x an xn 0 是一个条件等式而不是 两个多项式相等。 定义3: 设 f x a0 a1x
k 相乘积的和作为 x 的系数。得:
k f x g x aib j x k 0 i j k 2 3 2 例1.2.3:设 f x 3x 4x 5, g x x 2x x 1
nm
f x g x x 5x 5x 6
f x n.
第一章 多项式
an xn , an 0,
非负整数n称为 f x 的次数,记为:
2 f x 3 x 2x 1, f x 2, 例1.2.2:
f x 3, f x 0
零次多项式:次数为0的多项式即非零常数。 零多项式:系数全为0的多项式。对零多项式不 定义次数,因此,在谈论多项式的次数时,意味着这 个多项式不是零多项式。 首一多项式:首项系数为1的多项式。 二、多项式的运算 定义4: 设 f x a0 a1x
第一章 多项式

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1多项式

1多项式
与 g(x) 相等,记为 f (x) = g(x) . 系数全为零的多项式称为零多项式,记为 0 .
12
+ a0 ,
在 (1)
中,如果 an 0,那么 anxn 称为多项
式 (1) 的首项, an 称为首项系数,n 称为多项式
(1) 的次数. 零多项式是唯一不定义次数的多项式.
多项式 f (x) 的次数记为 ( f (x) ) .
m+b m-1 + … + b x + b g ( x ) = b x x 1 0 (2x2 - 1) (x2 m - x + 1)m-1 是数域 P 上两个多项式 . 那么它们可以写成 4 3 2 2 = 2x - 2x + 2x x + x 1 n m
3 , .g ( x) = 2x4 f -( 2x x) + x2 +ax -1 ix
所以 f (x) g(x) 可表成
i j s
a b
i
j
.
16
s x . f ( x) g ( x) a b i j s 0 i j s
m n
显然,数域 P 上的两个多项式经过加、减、乘
等运算后,所得结果仍然是数域 P 上的多项式. 对于多项式的加减法,不难看出 ( f (x) g(x) ) max( ( f (x) ) , (g(x) ) )
+ (a1 + b1)x + (a0 + b0)
(ai bi ) x .
i i 0
n
15
3. 乘法
f (x) · g(x) = anbmxn+m + (anbm-1 + an-1bm )xn+m-1

多项式的四则运算

多项式的四则运算

摘要在算法程序的设计与编写过程中,根据对本题的要求分析,结合设计对象的特点,实现一元多项式的加、减、乘、除以及对多项式求导、求值的相关计算。

根据一元多项式的结构特点和运算规则。

本程序中采用了链表的存储与实现,采用链表可以很方便的对其中的结点进行插入、删除等操作。

通过链表的合并即可完成多项式的四则运算。

1 引言:1.1 待处理问题的问题背景:本题要求对从键盘上输入的任意两个一元多项式,能够分别对每个多项式进行降幂排序并输出,实现对这两个多项式的加、减、乘、除等相关运算。

在具体实现时,可采用链式存储结构将多项式中的每一项连接起来,从而表达出整个多项式,其中每一项是一个一元多项式,通过每一项系数与指数的输入设定,可以实现对整个多项式的设定,再通过建立单链表,结点来存储每一项的系数与指数,通过链表完成多项式的存储,对每个多项式分别建立一个链表,通过链表的加减乘除运算规则实现连标的合并,最终得到计算结果。

2需要完成的任务:根据题目要求,本程序需要实现对两个一元多项式的四则运算以及对多项式进行赋值求值运算、求导运算等相关计算,要求正确输出运算结果,对不满足输入要求的数据有一定的反应。

3设计:3.1核心算法的设计与说明:3.1.1 一元多项式的定义:有多个单项式的代数和就构成了多项式,一元多项式就是只含有一个变元的多项式。

所以由定义可知有n个单项式组成的一元多项式来说,它的运算是满足交换率的,所以可进行降幂排序,只需将它的所有指数相比较,然后将指数大的放前面,小的放后面即可完成排序。

3.1.2本题的核心算法:首先调用建表函数,CreatePolyn建立两个一元多项式,然后对两个一元多项式进行降幂排序,该过程的实现主要由insert()函数实现,然后调用相应的计算函数: 加(AddPolyn)、减(SubtractPolyn)、(MultiplyPolyn)、除(DevicePolyn)、导数(Derivative)、求值(ValuePolyn)。

一元多项式计算程序报告

一元多项式计算程序报告

学院课程设计题目:(一元多项式计算问题)一元多项式计算。

要求:能够按照指数降序排列建立并输出一元多项式;能够完成两个一元多项式的相加、相减,并将结果输入。

1、问题分析和任务定义(1).任务定义:此程序需要完成如下的要求:将多项式按照指数降序排列建立并输出,将两个一元多项式进行相加、相减操作,并将结果输入。

a:输入并建立多项式;b:输出多项式,输出形式为表达式的形式,并且多项式的指数为降序;c:多项式a和b相加,建立多项式a+b;d:多项式a和b相减,建立多项式a-b。

e:多项式的输出形式为类数学表达式。

(2).问题分析:本程序的关键点在于如何将输入的一元多项式按指数的降序进行排列,而难点就是将输入的两个一元多项式进行相加、相减操作。

实现本程序需要解决以下几个问题:1、如何将输入的一元多项式按指数的降序进行排列;2、如何确定要输入的多项式的项数;3、如何将输入的两个一元多项式进行显示出来;4、如何将输入的两个一元多项式进行相加操作;5、如何将输入的两个一元多项式进行相减操作。

次程序是链表的应用,通过链表实现一元多项式的相加相减操作。

要对一元多项式进行表示:一元多项式的表示在计算机可以用链表来表示为了节省存储空间,我们只存储多项式中系数非0 的项。

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

下图1所示为该结点的结构:图1结点的结构创建一元多项式链表,对一元多项式的运算中会出现各种可能情况进行分析,实现一元多项式的相加、相减操作。

2、数据结构的选择和概要设计本题设计要求能够按照指数降序排列建立并输出多项式;能够完成两个多项式的相加,相减,并将结果输入。

(1)数据结构的选用A:基于链表中的节点可以动态生成的特点,以及链表可以灵活的添加或删除节点的数据结构,为了实现任意多项式的加法,减法,因此选择单链表的结构体,它有一个系数,指数,下一个指针3个元属;例如,图2中的两个线性链表分别表示一元多项式和一元多项式。

一元多项式操作

一元多项式操作
r->next=q;
q=s;
}
}
p=head1->next;//遍历head1链表,计数,将head1的项数算出并赋给head1头结点的指数位作记录
while(p!=NULL)
{
count2++;
p=p->next;
}
head1->ci=count2;
return head1;
}
dxs *paixu(dxs *head)//多项式整理排序函数
if(oper1=='+')//三个多项式相加
{
head2=create();
head2=paixu(head2);
display1(head2);
head1=jia(head1,head2);
head1=paixu(head1);
display1(head1);
head3=create();
head3=paixu(head3);
head=new dxs;
head->ci=n;//头结点的指数位储存这个多项式有多少个项
head->next=NULL;
tail=head;
for(int i=0;i<n;i++)
{
cout<<"Input Di "<<i+1<<" Xiang Xi Shu:";//输入每项得系数
cin>>xi1;
{
float xi1,xi2;
int ci1,ci2,count2=0;
dxs *p,*q;
dxs *r=head1;

一元多项式的表示与相加

一元多项式的表示与相加

一元多项式的表示与相加
一元多项式是指只含有一个变量的多项式,其表示方式通常为:
f(x) = a0 + a1x + a2x^2 + …+ anxn
其中,a0、a1、a2……an是多项式的系数,n是多项式的次数,x是变量,^表示“次方”的意思。

一元多项式的相加可以通过对应同次幂的系数进行相加的方式实现。

例如,给定两个一元二次多项式:
f(x) = 2x^2 - 3x + 1
g(x) = x^2 + 2x - 3
我们可以将它们相加,得到下面的结果:
f(x) + g(x) = (2+1)x^2 + (-3+2)x + (1-3)
= 3x^2 - x - 2
因此,将两个一元多项式相加时,需要先确定它们的次数,并将同次幂的系数相加后得到新的系数。

如果某个多项式的次数高于另一个多项式,则需要在较低次数的多项式中补充0作为系数再进行相加。

一元多项式的运算

一元多项式的运算

一元多项式的运算
哎呀,一元多项式的运算?这可真是个让人头疼的家伙!
就拿我们学数学来说吧,每次遇到一元多项式的运算,我感觉就像走进了一个迷宫。

你想想看,一堆数字、字母、还有各种符号凑在一起,那场面,简直比菜市场还热闹!
比如说,一个简单的一元多项式3x + 5,再加上另一个2x - 1,这得咋算呀?就好像我有3 个苹果和5 个橘子,你有2 个苹果和1 个橘子,咱俩把水果放一块儿,得好好数数到底有几个苹果几个橘子。

还有乘法呢!要是让(x + 2)乘以(x - 3),这可不像我帮妈妈数鸡蛋那么简单。

这得一项一项地乘,然后再相加,就跟搭积木似的,一块一块地往上堆。

老师在讲台上讲得口沫横飞,我在下面听得晕头转向。

“同学们,这很简单呀!”老师总这么说。

简单?老师啊,您咋就不理解我们的苦呢!
我瞅瞅同桌,他也皱着眉头,小声嘟囔着:“这啥呀,太难了!”我忍不住问他:“你懂了没?”他摇摇头,一脸无奈:“懂啥呀,我感觉自己像在云里雾里飘着呢!”
再看看后面的学霸,人家倒是一脸轻松,笔在纸上“唰唰”地写着,好像这对他来说就是小菜一碟。

哼,我就不信我搞不定!
回到家,我一头扎进作业里,和这些一元多项式较上劲了。

妈妈走过来说:“宝贝,休息会儿。

”我头也不抬:“不行啊妈妈,我非得把它弄明白不可!”
经过一番苦战,我好像有点明白了。

原来,只要掌握了规律,也没那么可怕嘛!就像找到了迷宫的出口,一下子豁然开朗。

我觉得呀,一元多项式的运算虽然一开始让人头疼,但只要我们不放弃,多练习,总能战胜它!就像爬山一样,过程很累,但爬到山顶看到的风景,那可美极了!。

多项式

多项式
m<n Qm(x) : Q = ( q0,q1,q2,…,qm ) 则 Rn(x) = Pn(x) + Qm(x) R = ( p0 + q0,p1 + q1,p2 + q2,…,pm + qm,pm+1,…,pn )
显然,采用顺序存储 结构实现方便。
P
p0 p1
Q
q0 q1
R
p0 + q0 p1 + q1
{ if (pa->expn<pb->expn)
{ p=(polynomial *)malloc(sizeof(polynomial)) ; p->coef=pa->coef ; p->expn=pa>expn ; p->next=NULL ;
/* 生成一个新的结果结点并赋值 */
pc->next=p ; pc=p ; pa=pa->next ; }
8
qa->expn == qb->expn, 计算sum=qa->coef + qb->coef, 且sum==0 的情况:
ha->next=qa->next; //DelFirst(ha, qa); free( qa ); //FreeNode(qa); hb->next=qb->next; //DelFirst(hb, qb); free( qb ); //FreeNode(qb); qa = ha->next; //qa=NextPos(Pa, ha); qb = hb->next; //qb=NextPos(Pb, hb); ha qa qa 2 3 7
p->coef=x ; p->expn=pb>expn ; p->next=NULL ;

两个一元多项式相加

两个一元多项式相加

两个一元多项式相加
《两个一元多项式相加》
哎呀!今天老师在数学课上讲了两个一元多项式相加,这可把我难住啦!
啥是一元多项式呀?一开始我是一头雾水。

老师在黑板上写了一堆式子,比如说:3x + 5 和2x - 1 。

老师说要把它们相加,这可咋办?
我瞅瞅同桌,他也皱着眉头,一脸迷茫。

我小声问他:“你懂了没?”他摇摇头说:“这也太难了,谁能搞明白呀?”
老师开始讲解啦,她就像一个神奇的魔法师,一边写一边说:“同学们,咱们先看这两个多项式的同类项,啥是同类项呢?就像一群小伙伴,x 就是它们的标志,系数不一样没关系,但字母和指数得一样。

” 我心里想:这咋跟找朋友似的?
老师接着说:“那3x 和2x 就是同类项,5 和-1 也是同类项。

把同类项的系数相加,3x + 2x 不就等于5x 嘛,5 + (-1)不就是4 嘛。

” 我恍然大悟,这不就像把相同颜色的糖果放到一起嘛!
我赶紧拿起笔自己算,可算着算着又迷糊了。

我拍拍前桌的肩膀问:“你能再给我讲讲不?”前桌回过头来,耐心地说:“你看啊,就像搭积木,相同的积木块堆在一起,数字和字母都不能乱。


经过一番努力,我终于算出了几道题。

这感觉太棒啦,就像解开了一个超级大谜题!
等到下课铃响,我还有点意犹未尽呢。

我跟小伙伴们说:“这两个一元多项式相加,一开始觉得像个大怪兽,现在发现也没那么可怕嘛!”
我觉得呀,数学虽然有时候很难,但是只要我们认真听老师讲,多和同学们讨论,就一定能战胜这些难题!就像爬山一样,虽然过程中会累会遇到困难,但是当我们爬到山顶,看到美丽的风景,就会觉得一切都值得!。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

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

相关文档
最新文档