一元多项式的相加减

合集下载

第1关：基于链表的两个一元多项式的基本运算

第1关：基于链表的两个一元多项式的基本运算在计算机科学中，一元多项式是常见的代数表达式形式，通常用来表示多项式函数。

虽然一元多项式的计算看似简单，但如果使用数据结构来实现，将会大大提高计算效率。

这篇文档将详细介绍基于链表的两个一元多项式的基本运算。

一元多项式的定义：在代数学中，一元多项式是一种含有一个未知数的代数多项式。

它是指一个代数式，它是由保持仅仅又有限个多项式的乘积。

此外，一元多项式在基本运算方面具有封闭性，这也是为什么它被广泛应用的原因之一。

在这里，我们将讨论在计算机科学中对一元多项式的实现。

链表的定义：链表是一种线性数据结构，其中数据元素不是常规的数组索引组织，而是通过信息存储元素之间的链来相互连接。

每个元素被称为节点，并且每个节点包含一个下一个节点的指针。

基于链表的一元多项式的实现：基于链表的一元多项式的实现涉及到将每个多项式的系数和指数存储为链表中的节点。

这种实现的主要优点是，它可以轻松地进行添加和删除操作，可以有效地分配内存，而不会浪费存储空间。

考虑到一元多项式的基本运算包括加法，减法和乘法，我们将详细介绍每种操作的实现。

一、基于链表的两个一元多项式的加法操作在实现一元多项式加法时，我们需要创建两个链表来存储两个多项式。

链表节点应该包含两个属性：系数和指数。

然后我们可以使用以下方法将两个多项式相加。

1. 定义两个指针p1和p2分别指向多项式链表的头部。

2. 定义一个新链表，用于存储相加的项。

3. 当p1和p2都不为空时循环进行以下操作：a. 如果p1当前节点的指数小于p2当前节点的指数，则将p1的节点添加到新链表中并将p1指针向下移动一个节点。

b. 如果p1当前节点的指数大于p2当前节点的指数，则将p2的节点添加到新链表中并将p2指针向下移动一个节点。

c. 如果p1和p2当前节点的指数相等，则将两个节点的系数相加，并将结果添加到新链表中，并将p1和p2指针都向下移动一个节点。

的所有剩余项添加到新链表中。

一元多项式相加问题实验报告

一元多项式相加问题实验报告一元多项式相加问题一、问题描述通过键盘输入两个形如P 0 +P 1 X 1 +P 2 X 2 +…+P n X 的多项式，经过程序运后在屏幕上输出它们的相加和。

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

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

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

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

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

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

⑶初始化完成后将最后一个结点的指针域置为空，并返回该新建链表的首地址。

if(q!=NULL)q-next=NULL;return a; ⑷动态分配空间新建结点存储系数和指数的代码如下：p=new node;p-coef=x;p-exp=y;if(a==NULL) a=p;else q-next=p;q=p; 2、多项式显示功能函数由于系数有正有负，故采取如下处理：对于正数，输出时在前面加“+”，头指针除外；对于负数，直接将系数输出即可，即：p=a;while(p){if(p==a)coutp-coef"*x^"p-else if(p-coef0)coutp-coef"*x^"p-else if(p-coef0)cout"+"p-coef"*x^"p-p=p-next;} 输出的多项式的形式形如：P 1 X^1+P 2 X^2+…+P n X^n 3、多项式相加的功能函数函数为：node *plus_fun(node *a,node *b) 此函数根据在 1 中初始化的两个多项式进行相加运算，并存放在以c 为头指针的一个新链表中。

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

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

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

数据结构一元多项式的运算正文：1. 引言本文档旨在介绍数据结构中一元多项式的运算方法。

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

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

2. 一元多项式的表示和存储2.1 一元多项式的定义一元多项式是指在一个变量x上的多项式，每一项由一个系数和一个指数组成，例如：2x^3 - 5x^2 + 3x + 1.其中，2、-5、3和1分别是系数，3、2、1和0分别是指数。

2.2 一元多项式的表示方法一元多项式可以使用数组、链表或其他数据结构来表示。

在本文中，我们选择使用数组来表示一元多项式。

数组的索引代表指数，数组的元素代表系数。

例如，多项式 2x^3 - 5x^2 + 3x + 1 可以表示为 [1, 3, -5, 2]。

2.3 一元多项式的存储结构为了表示一元多项式，我们可以使用一个数组来存储多项式的系数。

数组的长度应该比多项式的最高指数大1.数组的索引代表指数，数组的元素代表系数。

例如，数组 [1, 3, -5, 2] 表示的多项式 2x^3 - 5x^2 + 3x + 1 中，索引0对应指数为3的项，索引1对应指数为2的项，以此类推。

3. 一元多项式的基本运算3.1 一元多项式的加法一元多项式的加法是指将两个多项式相加，并合并同类项。

具体操作如下：- 将两个多项式的系数相加，并将结果存储在一个新的多项式中。

- 遍历新的多项式，将相邻的相同指数的项合并。

3.2 一元多项式的减法一元多项式的减法是指将一个多项式减去另一个多项式，并合并同类项。

具体操作如下：- 将两个多项式的系数相减，并将结果存储在一个新的多项式中。

- 遍历新的多项式，将相邻的相同指数的项合并。

3.3 一元多项式的乘法一元多项式的乘法是指将两个多项式相乘，并合并同类项。

具体操作如下：- 遍历一个多项式的每一项，与另一个多项式的每一项相乘。

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

数据结构一元多项式的运算数据结构一元多项式的运算1、引言1.1 研究背景1.2 研究目的2、一元多项式的定义2.1 一元多项式的概念2.2 一元多项式的表示方法2.3 一元多项式的次数和系数2.4 一元多项式的零多项式和常数项2.5 一元多项式的加法运算2.6 一元多项式的减法运算2.7 一元多项式的乘法运算3、一元多项式的特殊运算3.1 一元多项式的乘方运算3.2 一元多项式的取余运算3.3 一元多项式的求导运算3.4 一元多项式的积分运算3.5 一元多项式的复合运算4、一元多项式的应用4.1 一元多项式在数学中的应用4.2 一元多项式在计算机科学中的应用4.3 一元多项式在工程领域中的应用5、实例分析5.1 实例一：一元多项式的相加减5.2 实例二：一元多项式的乘法运算5.3 实例三：一元多项式的特殊运算应用6、结论附件：附件一：一元多项式的代码实现示例法律名词及注释：1.一元多项式: 指仅有一个未知数的多项式。

2.多项式的次数: 多项式中各项最高次幂的次数。

3.多项式的系数: 多项式中各项中未知数的系数。

4.零多项式: 所有系数均为0的多项式。

5.常数项: 多项式中次数为0的项，即常数项。

6.多项式的加法运算: 将两个多项式相同次项的系数相加。

7.多项式的减法运算: 将两个多项式相同次项的系数相减。

8.多项式的乘法运算: 将两个多项式的各项相乘，并根据指数相加合并同类项。

9.多项式的乘方运算: 将一个多项式自乘n次。

10.多项式的取余运算: 两个多项式相除后的余数部分。

11.多项式的求导运算: 对多项式中的每一项进行求导操作。

12.多项式的积分运算: 对多项式中的每一项进行积分操作。

13.多项式的复合运算: 将一个多项式代入另一个多项式中进行运算。

一元多项式的运算

数据结构课程设计实验报告专业班级：学号：姓名：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 结点的指数项，由此得到下列运算规则：

一元多项式相加

⼀元多项式相加描述：对于两个⼀元多项式，如果需要对他们进⾏多项式相加操作，常见的两种思路如下：(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 }它适合⼤部分项都有的稠密多项式。

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

实验报告课程名称：数据结构实验名称：一元多项式的相加班级： 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. 数据结构分析：逻辑结构为线性表，采用链式存储结构。

一元多项式的定义和运算

多问题：5、除了定义之外，判断一个集合是数环有没有其他简单的方法？项式
定理1.1.1：设S是一个非空数集，S是数环的充高等要条件是S中任两个数的差和积仍在S中。代二、数域数定义2：设F是一个含有不等零的数的数集，如果F
中任两个数的和、差、积、商（除数不为0）仍在F中，则称F是一个数域。定义 2：设F是一个数环，如果 ① F内含有一个非 1 零数； ② 对 a, b F , 且 b 0 ，则 a b F 则称F是一个数域。多例如：有理数集Q，实数集R，复数集C都是数域，
高等代数
第一章多项式
学时：28学时教学方法和手段
由于多项式与整数在许多方面有相似之处，因此在建立多项式分解理论时要注意与整数理论作对比。
基本内容和教学目的
1
本章主要讨论一元多项式的概念和运算，建立多项式因式分解理论，并讨论与之有密切关系的求根问题。这是中学有关知识的加深和扩充。
有理数、实数、复数。再比如讨论多项式的因式分解、方程的根的情况，都跟数的范围有关。
例如
1
x 2 在有理数范围内不能分解，在实数范围内
2
多项式
就可以分解。 x2 1 0 在实数范围内没有根，在复数范围内就有根。等等。
我们目前学习的解析几何，数学分析都是在实数高等范围内来讨论问题的。但在高等代数中，通常不做代这样的限制。在代数中，我们主要考虑一个集合中元素的加减数
多项式
本章的重点和难点
重点:一元多项式的因式分解理论. 难点:最大公因式的概念,多项式的整除,互素和不可约多项式等概念之间的联系与区别.
§1.1 数环和数域高研究数学问题常常需要明确规定所考虑的数的等代范围，学习数学也是如此。数比如，先学习自然数，然后整数，再正有理数、

§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
第一章多项式

一元多项式相加减c语言

一元多项式相加减c语言一元多项式相加减是一个基础的多项式操作，其基本形式是用数组存储系数和指数（对于非零项来说），然后进行相应的加减操作。

以下是一个简单的C语言实现：```c#include <stdio.h>struct term {int coeff; // 系数int exp; // 指数};struct poly {int len; // 多项式的长度struct term *arr; // 存储多项式每一项的数组};// 创建多项式struct poly create_poly(int coeff[], int exp[]) {struct poly p;p.len = sizeof(coeff) / sizeof(coeff[0]);p.arr = (struct term*)malloc(p.len * sizeof(struct term));for (int i = 0; i < p.len; i++) {p.arr[i].coeff = coeff[i];p.arr[i].exp = exp[i];}return p;}// 多项式相加struct poly poly_add(struct poly p1, struct poly p2) {struct poly result = {0, NULL};int len = p1.len > p2.len ? p1.len : p2.len;result.arr = (struct term*)malloc(len * sizeof(struct term));for (int i = 0; i < len; i++) {if (i < p1.len && i < p2.len && p1.arr[i].exp == p2.arr[i].exp) {result.arr[i].coeff = p1.arr[i].coeff + p2.arr[i].coeff; } else if (i < p1.len) {result.arr[i].coeff = p1.arr[i].coeff;result.arr[i].exp = p1.arr[i].exp;} else { // i < p2.lenresult.arr[i].coeff = p2.arr[i].coeff;result.arr[i].exp = p2.arr[i].exp;}}result.len = len;return result;}// 多项式相减struct poly poly_sub(struct poly p1, struct poly p2) {struct poly result = {0, NULL};int len = p1.len > p2.len ? p1.len : p2.len;result.arr = (struct term*)malloc(len * sizeof(struct term));for (int i = 0; i < len; i++) {if (i < p1.len && i < p2.len && p1.arr[i].exp == p2.arr[i].exp) {result.arr[i].coeff = p1.arr[i].coeff - p2.arr[i].coeff; } else if (i < p1.len) { // 如果p1有该项，而p2没有，则直接复制p1的项到结果中。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

一元多项式的相加减

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

一元稀疏多项式计算器加,减,乘,除运算

山东大学14级计算机科学与技术学院,王士彬#include<ctime>#include<iostream>#include<list>#include<string>using namespace std;class term{public:term(int c=0,int e=0):coef(c),exp(e){}int coef;//系数int exp;//指数};class Polynomial{private:int degree;//阶数list<term> termList;//存储多项式public:Polynomial(){degree=0;};//---------------------------------------构造函数，创造一个0阶多项式int Degree();//--------------------------------------------------求多项式的阶数double Value(double x);//----------------------------------------返回多项式在x下的值void Clear();//--------------------------------------------------清空多项式Polynomial shunxu();//-----------------------指数递增变递减，递减变递增Polynomial paixu();//------------------------用来对计算后结果的排序处理（主要去掉系数为0的项）/*函数方法*/void Input();//----------------------------------------------------------------多项式输入void OutPut();//---------------------------------------------------------------多项式输出Polynomial Add(Polynomial &b);//-----------------------------------------------多项式相加Polynomial Subtract(Polynomial &b);//------------------------------------------多项式相减Polynomial Multiply(Polynomial &b);//------------------------------------------多项式相乘Polynomial Divide(Polynomial &b); //-------------------------------------------多项式相除/*操作符重载*/friend istream& operator>>(istream &is,Polynomial &obj);//----------------输入符号重载friend ostream& operator<<(ostream &os,Polynomial &obj);//----------------输出符号重载Polynomial operator+(Polynomial &b);//------------------------------------加号重载Polynomial operator-(Polynomial &b);//------------------------------------减号重载Polynomial operator*(Polynomial &b);//------------------------------------乘号重载Polynomial operator/(Polynomial &b);//------------------------------------除号重载};int Polynomial::Degree(){list<term>::iterator iter=termList.begin();term temp=(term)*iter;int degree=temp.exp;return degree;}double Polynomial::Value(double x){double sum=0;int i;list<term>::iterator iter=termList.begin();for(;iter!=termList.end();iter++){term temp=(term)*iter;int t=1;for(i=temp.exp;i!=0;i--){t=t*x;}sum+=temp.coef*t;}return sum;}void Polynomial::Clear(){termList.clear();}Polynomial Polynomial::shunxu(){Polynomial p1;list<term>::iterator iter=termList.begin();for(;iter!=termList.end();iter++){term temp;term t_a=(term)*iter;temp.coef=t_a.coef;temp.exp=t_a.exp;p1.termList.push_front(temp);}return p1;}//用来对计算后结果的排序处理（在输入时已经对系数为0的情况处理过了，但得出的结果系数可能有等于0的，此方法就是对系数为0的情况处理）Polynomial Polynomial::paixu(){Polynomial aaa;list<term>::iterator it =termList.begin();for(;it!=termList.end();){term t11=*it;if(t11.coef==0){it++;}else{aaa.termList.push_back(t11);it++;}}return aaa;}void Polynomial::Input(){int n;cout<<",请输入多项式的项数：";cin>>n;cout<<"按升幂输入多项式的系数和指数"<<endl;for(int i=1;i<=n;i++){term t_temp;cout<<"请输入第"<<i<<"项系数和指数,中间以空格为界:";cin>>t_temp.coef;cin>>t_temp.exp;if(t_temp.coef!=0){termList.push_back(t_temp);}}}void Polynomial::OutPut(){if(termList.empty()){cout<<"0";}else{list<term>::iterator it = termList.begin();for(;it!=termList.end();){term t11=*it;if(t11.exp!=0){if(t11.coef==1){if(t11.exp==1){cout<<"x";if(++it!=termList.end()){term t112=*it;if(t112.coef>0){cout<<"+";}else {cout<<"";}}}else{cout<<"x^"<<t11.exp;if(++it!=termList.end()){term t112=*it;if(t112.coef>0){cout<<"+";}else {cout<<"";}}}}else if(t11.coef==(-1)){if(t11.exp==1){cout<<"-x";if(++it!=termList.end()){term t112=*it;if(t112.coef>0){cout<<"+";}else {cout<<"";}}}else{cout<<"-x^"<<t11.exp;if(++it!=termList.end()){term t112=*it;if(t112.coef>0){cout<<"+";}else {cout<<"";}}}}else{if(t11.exp==1){cout<<t11.coef<<"x";if(++it!=termList.end()){term t112=*it;if(t112.coef>0){cout<<"+";}else {cout<<"";}}}else{cout<<t11.coef<<"x^"<<t11.exp;if(++it!=termList.end()){term t112=*it;if(t112.coef>0){cout<<"+";}else {cout<<"";}}}}}else{cout<<t11.coef;if(++it!=termList.end()){term t112=*it;if(t112.coef>0){cout<<"+";}else {cout<<"";}}}}}}Polynomial Polynomial::Add(Polynomial &b){Polynomial c;list<term>::iterator iter_a=termList.begin();list<term>::iterator iter_b=b.termList.begin();while(iter_a!=termList.end()&&iter_b!=b.termList.end()){term t_temp;term t_a=(term)*iter_a;term t_b=(term)*iter_b;if(t_a.exp<t_b.exp){c.termList.push_back(t_b);iter_b++;}else if(t_a.exp>t_b.exp){c.termList.push_back(t_a);iter_a++;}else{t_temp.coef=t_a.coef+t_b.coef;t_temp.exp=t_a.exp;c.termList.push_back(t_temp);iter_a++;iter_b++;}}for(;iter_a!=termList.end();iter_a++){c.termList.push_back(*iter_a);}for(;iter_b!=b.termList.end();iter_b++){c.termList.push_back(*iter_b);}Polynomial c1=c.paixu();return c1;}Polynomial Polynomial::Subtract(Polynomial &b){Polynomial c;list<term>::iterator iter_a=termList.begin();list<term>::iterator iter_b=b.termList.begin();while(iter_a!=termList.end()&&iter_b!=b.termList.end()){ term temp;term t_a=(term)*iter_a;term t_b=(term)*iter_b;if(t_a.exp>t_b.exp){c.termList.push_back(t_a);iter_a++;}else if(t_a.exp<t_b.exp){temp.coef=-t_b.coef;temp.exp=t_b.exp;c.termList.push_back(temp);iter_b++;}else{temp.coef=t_a.coef-t_b.coef;temp.exp=t_a.exp;c.termList.push_back(temp);iter_a++;iter_b++;}}for(;iter_a!=termList.end();iter_a++){c.termList.push_back(*iter_a);}for(;iter_b!=b.termList.end();iter_b++){term temp2;term t_b=(term)*iter_b;temp2.coef=-t_b.coef;temp2.exp=t_b.exp;c.termList.push_back(temp2);}Polynomial c1=c.paixu();return c1;}Polynomial Polynomial::Multiply(Polynomial &b){Polynomial c;list<term>::iterator iter_a=termList.begin();for(;iter_a!=termList.end();iter_a++){Polynomial c1;//这个c1的位置只能放在这里，局部变量list<term>::iterator iter_b=b.termList.begin();for(;iter_b!=b.termList.end();iter_b++){term temp;term t_a=(term)*iter_a;term t_b=(term)*iter_b;temp.coef=t_a.coef*t_b.coef;temp.exp=t_a.exp+t_b.exp;c1.termList.push_back(temp);}c=c.Add(c1);c1.Clear();}return c;}Polynomial Polynomial::Divide(Polynomial &b){Polynomial a;//被除数list<term>::iterator iter_a=termList.begin();for(;iter_a!=termList.end();iter_a++){term temp;term t_a=(term)*iter_a;temp.coef=t_a.coef;temp.exp=t_a.exp;a.termList.push_back(temp);}//---------------------------------------------------------Polynomial quotient,remainder,temp1,temp2;list<term>::iterator qa_a=a.termList.begin();list<term>::iterator qb_b=b.termList.begin();term qa=(term)*qa_a;term qb=(term)*qb_b;temp1=a;//cout<<"要到达while循环了"<<endl;while(qa.exp>=qb.exp){term temp2_term;temp2_term.coef=qa.coef/qb.coef;temp2_term.exp=qa.exp-qb.exp;quotient.termList.push_back(temp2_term);Polynomial center_quotient;center_quotient.termList.push_back(temp2_term);Polynomial tt=b*center_quotient;a=a-tt;a=a.paixu();list<term>::iterator qa_1=a.termList.begin();qa=(term)*qa_1;}Polynomial ji=quotient*b; // Polynomialremainder =temp1-ji;return remainder;}istream &operator>>(istream &is,Polynomial &obj){int n;cout<<"请输入多项式的项数：";cin>>n;cout<<"按升幂输入多项式的系数和指数"<<endl;for(int i=1;i<=n;i++){term t_temp;cout<<"请输入第"<<i<<"项系数和指数,中间以空格为界:";cin>>t_temp.coef;cin>>t_temp.exp;if(t_temp.coef!=0){obj.termList.push_back(t_temp);}}return is;}ostream& operator<<(ostream &os,Polynomial &obj){ if(obj.termList.empty()){cout<<"0";}else{list<term>::iterator it = obj.termList.begin();for(;it!=obj.termList.end();){term t11=*it;if(t11.exp!=0){if(t11.coef==1){if(t11.exp==1){cout<<"x";if(++it!=obj.termList.end()){term t112=*it;if(t112.coef>0){cout<<"+";}else {cout<<"";}}}else{cout<<"x^"<<t11.exp;if(++it!=obj.termList.end()){term t112=*it;if(t112.coef>0){cout<<"+";}else {cout<<"";}}}}else if(t11.coef==(-1)){if(t11.exp==1){cout<<"-x";if(++it!=obj.termList.end()){term t112=*it;if(t112.coef>0){cout<<"+";}else {cout<<"";}}}else{cout<<"-x^"<<t11.exp;if(++it!=obj.termList.end()){term t112=*it;if(t112.coef>0){cout<<"+";}else {cout<<"";}}}}else{if(t11.exp==1){cout<<t11.coef<<"x";if(++it!=obj.termList.end()){term t112=*it;if(t112.coef>0){cout<<"+";}else {cout<<"";}}}else{cout<<t11.coef<<"x^"<<t11.exp;if(++it!=obj.termList.end()){term t112=*it;if(t112.coef>0){cout<<"+";}else {cout<<"";}}}}}else{cout<<t11.coef;if(++it!=obj.termList.end()){term t112=*it;if(t112.coef>0){cout<<"+";}else {cout<<"";}}}}}return os;}Polynomial Polynomial::operator+(Polynomial &b){Polynomial c;list<term>::iterator iter_a=termList.begin();list<term>::iterator iter_b=b.termList.begin();while(iter_a!=termList.end()&&iter_b!=b.termList.end()){ term t_temp;term t_a=(term)*iter_a;term t_b=(term)*iter_b;if(t_a.exp<t_b.exp){c.termList.push_back(t_b);iter_b++;}else if(t_a.exp>t_b.exp){c.termList.push_back(t_a);iter_a++;}else{t_temp.coef=t_a.coef+t_b.coef;t_temp.exp=t_a.exp;c.termList.push_back(t_temp);iter_a++;iter_b++;}}for(;iter_a!=termList.end();iter_a++){c.termList.push_back(*iter_a);}for(;iter_b!=b.termList.end();iter_b++){c.termList.push_back(*iter_b);}Polynomial c1=c.paixu();return c1;}Polynomial Polynomial::operator-(Polynomial &b){Polynomial c;list<term>::iterator iter_a=termList.begin();list<term>::iterator iter_b=b.termList.begin();while(iter_a!=termList.end()&&iter_b!=b.termList.end()){ term temp;term t_a=(term)*iter_a;term t_b=(term)*iter_b;if(t_a.exp>t_b.exp){c.termList.push_back(t_a);iter_a++;}else if(t_a.exp<t_b.exp){temp.coef=-t_b.coef;temp.exp=t_b.exp;c.termList.push_back(temp);iter_b++;}else{temp.coef=t_a.coef-t_b.coef;temp.exp=t_a.exp;c.termList.push_back(temp);iter_a++;iter_b++;}}for(;iter_a!=termList.end();iter_a++){c.termList.push_back(*iter_a);}for(;iter_b!=b.termList.end();iter_b++){term temp2;term t_b=(term)*iter_b;temp2.coef=-t_b.coef;temp2.exp=t_b.exp;c.termList.push_back(temp2);}Polynomial c1=c.paixu();return c1;}Polynomial Polynomial::operator*(Polynomial &b){Polynomial c;list<term>::iterator iter_a=termList.begin();for(;iter_a!=termList.end();iter_a++){Polynomial c1;//这个c1的位置只能放在这里，局部变量list<term>::iterator iter_b=b.termList.begin();for(;iter_b!=b.termList.end();iter_b++){term temp;term t_a=(term)*iter_a;term t_b=(term)*iter_b;temp.coef=t_a.coef*t_b.coef;temp.exp=t_a.exp+t_b.exp;c1.termList.push_back(temp);}c=c+c1;}return c;}Polynomial Polynomial::operator/(Polynomial &b){ Polynomial a;//被除数list<term>::iterator iter_a=termList.begin();for(;iter_a!=termList.end();iter_a++){term temp;term t_a=(term)*iter_a;temp.coef=t_a.coef;temp.exp=t_a.exp;a.termList.push_back(temp);}//---------------------------------------------------------Polynomial quotient,remainder,temp1,temp2;list<term>::iterator qa_a=a.termList.begin();list<term>::iterator qb_b=b.termList.begin();term qa=(term)*qa_a;term qb=(term)*qb_b;temp1=a;//cout<<"要到达while循环了"<<endl;while(qa.exp>=qb.exp){term temp2_term;temp2_term.coef=qa.coef/qb.coef;temp2_term.exp=qa.exp-qb.exp;quotient.termList.push_back(temp2_term);Polynomial center_quotient;center_quotient.termList.push_back(temp2_term);Polynomial tt=b*center_quotient;a=a-tt;a=a.paixu();list<term>::iterator qa_1=a.termList.begin();qa=(term)*qa_1;//cout<<"一直在while循环里"<<endl;}// cout<<"出while循环了"<<endl;Polynomial ji=quotient*b;remainder =temp1-ji;return quotient;}int main(){time_t t;time(&t);cout<<endl;cout<<" §欢迎使用一元稀疏多项式计算器┌────────┐"<<endl;//┍┑╟┄┈┊╓╱╭─╮│┃╰━╯┄┄cout<<" §功能：多项式的加，减，乘，除及按x求值┃王士彬┃"<<endl; cout<<" §输入：多项式的项数，系数，指数┃2014级计算机学院┃"<<endl; cout<<" §各种运算后的结果└────────┘"<<endl;cout<<"-------------------------------------------------------------------------------运行时间："<<ctime(&t)<<endl;cout<<" 【功能选择项】"<<endl;cout<<" ≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡"<<endl;cout<<" ┃1,输入多项式A和B ┃2,计算多项式A+B ┃"<<endl;cout<<" ┃3,计算多项式A-B ┃4,计算多项式A*B ┃"<<endl;cout<<" ┃5,计算多项式A/B ┃6,计算A在x处的值┃"<<endl;cout<<" ┃7,计算多项式A的阶数┃8,退出┃"<<endl;cout<<" ≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡"<<endl;int i;Polynomial p1,p2,p3,p4,p5,p6,p7;Polynomial p1_1;Polynomial p2_2;cout<<"请选择功能项:";cin>>i;while(i!=1){cout<<"请先建立多项式A和B"<<endl;cout<<"请选择功能项:";cin>>i;}do{switch(i){case 1:{p1.Clear();p2.Clear();p1_1.Clear();p2_2.Clear();cout<<"多项式A，";cin>>p1;cout<<"多项式B，";cin>>p2;p1_1=p1.shunxu();//降幂p2_2=p2.shunxu();//降幂cout<<"多项式A为："<<p1_1<<endl;cout<<"多项式B为："<<p2_2<<endl;cout<<"------------------------------------1输入AB 2加3减4乘5除6求值7求阶数8退出"<<endl;cout<<"请选择功能项:";cin>>i;if(i==8){cout<<"-------------------欢迎你下次使用-------------------------"<<endl;}break;}case 2:{// p3=p1_1.Add(p2_2);p3=p1_1+p2_2;cout<<"A+B的结果为："<<p3<<endl;cout<<"------------------------------------1输入AB 2加3减4乘5除6求值7求阶数8退出"<<endl;cout<<"请选择功能项:";cin>>i;if(i==8){cout<<"欢迎你下次使用"<<endl;}break;}case 3:{p4=p1_1.Subtract(p2_2);//p4=p1_1-p2_2;cout<<"A-B的结果为："<<p4<<endl;cout<<"------------------------------------1输入AB 2加3减4乘5除6求值7求阶数8退出"<<endl;cout<<"请选择功能项:";cin>>i;if(i==8){cout<<"欢迎你下次使用"<<endl;}break;}case 4:{p5=p1_1*p2_2;cout<<"A*B的结果为："<<p5<<endl;cout<<"------------------------------------1输入AB 2加3减4乘5除6求值7求阶数8退出"<<endl;cout<<"请选择功能项:";cin>>i;if(i==8){cout<<"-----------------欢迎你下次使用！！------------"<<endl;}break;}case 5:{p6=p1_1/p2_2;p7=p1_1.Divide(p2_2);cout<<"A/B的结果为商："<<p6<<" 余数："<<p7<<endl;cout<<"------------------------------------1输入AB 2加3减4乘5除6求值7求阶数8退出"<<endl;cout<<"请选择功能项:";cin>>i;if(i==8){cout<<"欢迎你下次使用"<<endl;}break;}case 6:{int x,y;cout<<"请输入x的值：";cin>>x;y=p1_1.Value(x);cout<<"A在x="<<x<<"下的值为："<<y<<endl;cout<<"------------------------------------1输入AB 2加3减4乘5除6求值7求阶数8退出"<<endl;cout<<"请选择功能项:";cin>>i;if(i==8){cout<<"欢迎你下次使用"<<endl;}break;}case 7:{int a=p1_1.Degree();cout<<"多项式A的阶数为："<<a<<endl;cout<<"------------------------------------1输入AB 2加3减4乘5除6求值7求阶数8退出"<<endl;cout<<"请选择功能项:";cin>>i;if(i==8){cout<<"欢迎你下次使用"<<endl;}break;}default:{cout<<"输入错误，请重新输入"<<endl;cout<<"------------------------------------1输入AB 2加3减4乘5除6求值7求阶数8退出"<<endl;cout<<"请选择功能项:";cin>>i;if(i==8){cout<<"欢迎你下次使用"<<endl;}break;}}}while(i!=8);}。

一元多项式操作

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;

一元多项式的定义

一元多项式的定义一元多项式是数学中常见的一个概念，也是代数学中的基础内容之一。

它由一个变量和系数构成，变量通常用字母表示，系数可以是实数或复数。

一元多项式的一般形式为：P(x) = a_nx^n + a_{n-1}x^{n-1} + ... + a_2x^2 + a_1x + a_0其中，P(x)表示一元多项式，a_n, a_{n-1}, ..., a_0表示系数，x表示变量，n表示多项式的次数。

一元多项式的次数是指最高次项的次数，而系数则表示每个变量的权重。

一元多项式的次数可以是非负整数，次数为0的多项式称为常数。

例如，P(x) = 3x^2 + 2x - 1是一个次数为2的一元多项式。

一元多项式具有以下特性：1. 线性叠加性：任意两个一元多项式相加或相减，仍然是一个一元多项式。

例如，P(x) = 2x^2 + 3x + 1和Q(x) = 4x - 2相加得到R(x) = 2x^2 + 7x - 1。

2. 系数相等性：两个一元多项式在相同的次数上的系数相等，才能认为这两个多项式相等。

例如，P(x) = 2x^2 + 3x + 1和Q(x) = 2x^2 + 3x + 1是相等的一元多项式。

3. 零多项式：所有系数都为零的一元多项式称为零多项式，记作0。

例如，P(x) = 0是一个零多项式。

4. 一元多项式的加法和减法：一元多项式的加法和减法可通过对应项的系数相加或相减得到。

例如，P(x) = 2x^2 + 3x + 1和Q(x) = 4x - 2相加得到R(x) = 2x^2 + 7x - 1，相减得到R(x) = 2x^2 - x + 3。

5. 一元多项式的乘法：一元多项式的乘法是指将两个多项式的每一项进行相乘，并将同次幂的结果合并。

例如，P(x) = (x + 1)(x - 2)展开得到P(x) = x^2 - x - 2。

6. 一元多项式的除法：一元多项式的除法是指将一个多项式除以另一个多项式，得到商式和余式。

基于链表的两个一元多项式的基本运算

基于链表的两个一元多项式的基本运算链表是一种常见的数据结构，其特点是可以在任意位置插入或删除节点，因此在一些数学问题中也会用到。

本文将介绍基于链表的两个一元多项式的基本运算。

一元多项式是指只有一个未知数的多项式，例如：$3x^2+2x+1$。

在计算机中，可以将多项式表示为一个链表，每个节点表示一个项，其中包含系数与指数。

例如，$3x^2+2x+1$可以表示为一个链表，节点分别为：$3\rightarrow2\rightarrow1$，分别表示$3x^2$、$2x$和$1$。

两个一元多项式的基本运算主要包括：多项式相加、相减与相乘。

对于相加与相减，我们只需要将两个链表按照指数从小到大的顺序逐个相加或相减，最后得到新的一元多项式。

具体的实现可以采用如下步骤：1. 定义两个指针，分别指向链表的头节点。

2. 对于每个节点，比较其指数大小，如果相同则将系数相加，指数不同则将较小的指针向后移动。

3. 如果其中一个链表已经遍历完，则将另一个链表的剩余部分加到结果链表中。

例如，将两个多项式$3x^2+2x+1$和$2x^2+3x$相加的过程如下：1. 指针一指向3，指针二指向2，它们的指数不同，将指向较小的2。

2. 现在指针一指向2，指针二指向2，它们的指数相同，将系数相加得到5，将指针一和指针二同时向后移动。

3. 现在指针一指向1，指针二指向3，它们的指数不同，将指向较小的1。

4. 现在指针一指向null，指针二指向3，将指针二的剩余部分加到结果链表中。

最终结果为$5x^2+5x+1$。

相减的方法与相加类似，只需要将相减的多项式转化为相加即可。

对于相乘，我们需要采用另一种方法。

具体实现如下：1. 定义一个临时链表，初始为空。

2. 对于第一个多项式的每个节点，将其与第二个多项式的每个节点相乘，并将结果放入临时链表中。

3. 将临时链表中的多项式相加，得到最终结果。

例如，将两个多项式$3x^2+2x+1$和$2x+1$相乘的过程如下：1. 将第一个多项式的每个节点与第二个多项式的每个节点相乘，得到一个临时链表，节点分别为：$6\rightarrow5\rightarrow2$，表示$6x^3+5x^2+2x$。