一元多项式的运算
- 格式：doc
- 大小：375.00 KB
- 文档页数：34
下载文档原格式
合集下载
第1关：基于链表的两个一元多项式的基本运算
第1关：基于链表的两个一元多项式的基本运算在计算机科学中，一元多项式是常见的代数表达式形式，通常用来表示多项式函数。
虽然一元多项式的计算看似简单，但如果使用数据结构来实现，将会大大提高计算效率。
这篇文档将详细介绍基于链表的两个一元多项式的基本运算。
一元多项式的定义：在代数学中，一元多项式是一种含有一个未知数的代数多项式。
它是指一个代数式，它是由保持仅仅又有限个多项式的乘积。
此外，一元多项式在基本运算方面具有封闭性，这也是为什么它被广泛应用的原因之一。
在这里，我们将讨论在计算机科学中对一元多项式的实现。
链表的定义：链表是一种线性数据结构，其中数据元素不是常规的数组索引组织，而是通过信息存储元素之间的链来相互连接。
每个元素被称为节点，并且每个节点包含一个下一个节点的指针。
基于链表的一元多项式的实现：基于链表的一元多项式的实现涉及到将每个多项式的系数和指数存储为链表中的节点。
这种实现的主要优点是，它可以轻松地进行添加和删除操作，可以有效地分配内存，而不会浪费存储空间。
考虑到一元多项式的基本运算包括加法，减法和乘法，我们将详细介绍每种操作的实现。
一、基于链表的两个一元多项式的加法操作在实现一元多项式加法时，我们需要创建两个链表来存储两个多项式。
链表节点应该包含两个属性：系数和指数。
然后我们可以使用以下方法将两个多项式相加。
1. 定义两个指针p1和p2分别指向多项式链表的头部。
2. 定义一个新链表，用于存储相加的项。
3. 当p1和p2都不为空时循环进行以下操作：a. 如果p1当前节点的指数小于p2当前节点的指数，则将p1的节点添加到新链表中并将p1指针向下移动一个节点。
b. 如果p1当前节点的指数大于p2当前节点的指数，则将p2的节点添加到新链表中并将p2指针向下移动一个节点。
c. 如果p1和p2当前节点的指数相等，则将两个节点的系数相加，并将结果添加到新链表中，并将p1和p2指针都向下移动一个节点。
的所有剩余项添加到新链表中。
一元多项式——精选推荐
第一章 多项式§1 数域 §2 一元多项式一、数域1、定义：P 是由一些复数组成的集合，包含0和1，如果P 中的任意两个数的和、差、积、商（除数不为零）仍在P 中，则称P 为一个数域。
简单地说：P 是一个含0和1的非空集合，且对四种运算封闭。
2、例1：有理数的集合Q ，实数集合R ，复数集合C 均为数域。
例2：{}()2,2Q Q b a b a P =∈+=是一个数域。
证明：Pd c adcb d c bd ac d c d c d c b a d c b a d c d c P bc ad bd ac d c b a P d b c a d c b a P d b c a d c b a Qd c b a P d c b a P P ∈--+--=-+-+=++≠-≠+∈+++=++∈-+-=+-+∈+++=+++∈∈++∀∈+=∈+=2222)2)(2()2)(2(2202,02)5(2)()2()2)(2)(4(2)()()2()2)(3(2)()()2()2)(2(,,,,2,22011;2000)1(2222有若故P 是一个数域。
练习：证{}Q b a bi a i Q ∈+=,)(是一个数域。
二、一元多项式注：在数域P 上进行讨论，x 是一个符号。
1、定义：0111a x a x a x a n n n n ++++-- ，（-∈Z n ）称为数域P 上的一元多项式。
其中P a a a n ∈,,,10 ，用 ),(),(x g x f 表示。
若0≠n a ，则称n a 为首项系数，n 为多项式的次数，用))((x f ∂表示。
0a 为常数项。
2、相等：)()(x g x f =当且仅当次数相同，对应系数相等。
3、运算：设0111)(a x a x a x a x f n n n n ++++=-- ，0111)(b x b x b x b x g m m m m ++++=-- ，m n ≥（1） 加法： )()()()()(00b a x b a x b a x g x f m m m n n n +++++++=+其中：011====+-m n n b b b())(),(max ))()((x g x f x g x f ≤+∂ （2） 乘法：snm s s j i j i m n m n m n m n m n xb a b a x b a b a x b a b a x b a x g x f ∑∑+==+-+--+⎪⎪⎭⎫ ⎝⎛=+++++++=0001001111)()()()()(若：0)(,0)(≠≠x g x f ，则))(())(())()((x g x f x g x f ∂+∂=∂ 4、运算规律：（1）)()()()(x f x g x g x f +=+（加法交换律）（2）))()(()()())()((x h x g x f x h x g x f ++=++（加法结合律） （3）)()()()(x f x g x g x f =（乘法交换律）（4）))()()(()())()((x h x g x f x h x g x f =（乘法结合律） （5）)()()()())()()((x h x f x g x f x h x g x f +=+（分配律） （6）若,0)(),()()()(≠=x f x h x f x g x f 则)()(x h x g =（消去律） 5、多项式环。
一元多项式矩阵
一元多项式矩阵
一元多项式矩阵是一种特殊的矩阵形式，其中每个元素都是一元多项式。
在代数学中，多项式是由常数和变量的乘积和加法组成的表达式。
一元多项式矩阵则是由多个一元多项式组成的矩阵。
一元多项式矩阵可以表示为一个m×n的矩阵，其中每个元素都是一个一元多项式。
矩阵中的每一行可以被看作是一个多项式向量，而每一列则可以表示为一个多项式序列。
一元多项式矩阵的运算包括加法，减法，数乘和矩阵乘法等。
在实际应用中，一元多项式矩阵常常用于解决多项式方程组的求解问题。
通过将多项式方程组转化为一元多项式矩阵的形式，可以利用矩阵的性质和运算规则来求解方程组。
通过对一元多项式矩阵进行初等行变换和高斯消元等操作，可以得到方程组的解。
除了求解方程组之外，一元多项式矩阵还可以用于表示和计算多项式的导数和积分。
通过对一元多项式矩阵进行微分和积分操作，可以得到多项式的导函数和原函数。
这对于研究多项式的性质和应用具有重要意义。
一元多项式矩阵还可以用于多项式插值和多项式逼近等问题。
通过对一元多项式矩阵进行插值和逼近操作，可以根据已知的数据点来构造出一个多项式函数，从而实现对未知数据点的预测和估计。
总结起来，一元多项式矩阵是一种特殊的矩阵形式，其中每个元素都是一元多项式。
它在求解多项式方程组、计算多项式的导函数和原函数、多项式插值和逼近等问题中具有重要的应用价值。
通过对一元多项式矩阵的研究和应用，可以更好地理解和掌握多项式的性质和运算规则，从而在数学和工程领域中发挥作用。
一元多项式的定义和运算讲解
定理 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
的两个多项式 与 互素的充分且必要条 件是：在 中可以求得多项式 与 ，使
令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环境中调试运行。
高等代数一元多项式
∂(f(x)g(x)) = ∂(f(x)) + ∂(g(x)).
证设
f(x) = anxn + an−1xn−1 + · · · + a0, g(x) = bmxm + bm−1xm−1 + · · · + b0,
其中 an ̸= 0, bm ̸= 0. 则 ∂(f(x)) = n, ∂(g(x)) = m.
. .. . . ..
次数公式
(1) 在考虑多项式 f(x) 和 g(x) 的和时，不妨设 n ≥ m 且令 bm+1 = bm+2 = · · · = bn = 0，则
f(x)
+
g(x)
=
∑n (ai
+
bi)xi.
i=0
从而 ∂(f(x) + g(x)) ≤ n = max(∂(f(x)), ∂(g(x))). (2) f(x)g(x) 的首项是 anbmxn+m，显然 anbm ̸= 0，因之，f(x)g(x) ̸= 0 而且它的次数就是 n + m.
. .. . . ..
多项式的运算律
1 加法交换律：f(x) + g(x) = g(x) + f(x). 2 加法结合律：(f(x) + g(x)) + h(x) = f(x) + (g(x) + h(x)). 3 乘法交换律：f(x)g(x) = g(x)f(x). 4 乘法结合律：(f(x)g(x))h(x) = f(x)(g(x)h(x)).
. . . .... .... .... . . . . .... .... .... . .
. .. . . ..
次数公式
证设
f(x) = anxn + an−1xn−1 + · · · + a0, g(x) = bmxm + bm−1xm−1 + · · · + b0,
其中 an ̸= 0, bm ̸= 0. 则 ∂(f(x)) = n, ∂(g(x)) = m.
. .. . . ..
次数公式
(1) 在考虑多项式 f(x) 和 g(x) 的和时，不妨设 n ≥ m 且令 bm+1 = bm+2 = · · · = bn = 0，则
f(x)
+
g(x)
=
∑n (ai
+
bi)xi.
i=0
从而 ∂(f(x) + g(x)) ≤ n = max(∂(f(x)), ∂(g(x))). (2) f(x)g(x) 的首项是 anbmxn+m，显然 anbm ̸= 0，因之，f(x)g(x) ̸= 0 而且它的次数就是 n + m.
. .. . . ..
多项式的运算律
1 加法交换律：f(x) + g(x) = g(x) + f(x). 2 加法结合律：(f(x) + g(x)) + h(x) = f(x) + (g(x) + h(x)). 3 乘法交换律：f(x)g(x) = g(x)f(x). 4 乘法结合律：(f(x)g(x))h(x) = f(x)(g(x)h(x)).
. . . .... .... .... . . . . .... .... .... . .
. .. . . ..
次数公式
数据结构一元多项式的运算
数据结构一元多项式的运算正文：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 一元多项式的乘法一元多项式的乘法是指将两个多项式相乘，并合并同类项。
具体操作如下：- 遍历一个多项式的每一项，与另一个多项式的每一项相乘。
数据结构一元多项式的运算
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) 。计算时运用单项 式与多项式相乘的法则，然后再次运用单项式与多项式相乘的法则。
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. 求两个一元多项式的和两个一元多项式的和等于对应指数相同的单项式系数相加的结果。
一元多项式
f ( x ) g( x ) 为数域 P上任意两个多项式，则 f ( x ) g( x ), f ( x ) g( x ) 仍为数域 P上的多项式．
5、一元多项式环 定义 对于上面定义的多项式加法和乘法，
所有数域 P中的一元多项式的全体称为数域
P上的一元多项式环，记作 P[ x ] . 其中P称
为 P[ x ] 的系数域．
注：一元多项式环对加法、减法封闭，对除法不封闭。
二、一元多项式的次数
定理5.1 f ( x ), g( x ) P[ x ] ，且 f ( x ) 0, g( x ) 0, ①若 f ( x ) 0, g( x ) 0, 则 ( f g) max( ( f ), ( g)); ② f ( x ) g( x ) 0, 则 ( f ( x ) g( x )) ( f ( x )) ( g( x ))
3．多项式的运算：加法（减法）、乘法
f ( x ) a n x a n 1 x
n n 1
a1 x a0 a i x i ,
i 0 m
j 0
n
g( x ) bm x m bm 1 x m 1 b1 x b0 b j x j ,
加法： 若 n m , 在 g ( x ) 中令
bn bn1
则
bm 1 0
n i 0 n
f ( x ) g( x ) (a i bi ) x i .
i 0
减法： f ( x ) g( x ) (a i bi ) x i
乘法：
f ( x ) g( x ) anbm x n m (anbm 1 an1bm ) x n m 1
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构课程设计实验报告专业班级：学号：姓名：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）．提示输入数据。
要求先输入多项式的项数。
（2）．创建多项式。
接收输入的数据，并保存到链表中。
（3）．显示已经创建好的多项式。
（4）．实现加、减法运算。
（5）.退出程序3、概要设计(1)链表结点的类型定义(2)建立有序链表void CreatPolyn(LinkList &L,int n)(3)多项式链表的相加void AddPolyn(LinkList La,LinkList Lb,LinkList &Lc)(4)多项式链表的输出void printList(LinkList L)4、详细设计(1)链表结点的类型定义typedef struct //在struct前使用关键字typedef，表示是声明新类型{float coef; //系数int expn; //指数}DataType; //DataType是新类型typedef struct node //单链表的存储{DataType data; //数据域struct node *next; //指向下一个结点}ListNode,*LinkList; //ListNode是结点的新类型，LinkList是指向ListNode类型的结点的指针类型(2)建立有序链表要实现多项式的加法运算，首先要建立多项式的存储结构，每一个一元多项式的存储结构就是一个有序单链表。
有序链表的基本操作定义与线性链表有两处不同，一个是结点的查找定位操作LocateNode有所不同，二是结点的插入操作InsertNode不同，这两个操作算法分别如下：//结点的查找定位int LocateNode(LinkList L,DataType e,int &q){ListNode *p=L->next;q=0;//记录结点位置序号while(p&&e.expn<p->data.expn){p=p->next;q++;}if(p==NULL||e.expn!=p->data.expn)return 0;elsereturn 1;}void InsertNode(LinkList &L,DataType e,int q)函数功能：将新的节点p插入到现有链表的后面，并确保多项式的指数expn是升序。
将s节点插入到e所指向的链表。
在该函数的操作中，要注意指针是如何移动的。
//有序链表结点的插入void InsertNode(LinkList &L,DataType e,int q){ListNode *s,*p;int i=0;p=L;while(p->next && i<q){p=p->next;i++;}//查找插入位置s=(ListNode*)malloc(sizeof(ListNode));s->data.coef=e.coef;s->data.expn=e.expn;s->next=p->next;p->next=s;}有了上述两个“结点的查找定位算法”和“有序链表结点的插入算法”，int n保存的多项式的项数，使用for语句，控制输入多项式的每一项。
当创建的链表长度为n时，将不再提示用户继续输入多项式的系数和指数。
建立一个一元多项式的单链表的具体算法如下：//多项式链表的建立void CreatPolyn(LinkList &L,int n){LinkList pa; //定义一个头指针为pa链表int i,q; //i用来计输入的项数，q指结点的位置序号DataType e; //插入的值epa=(ListNode*)malloc(sizeof(ListNode)); //生成链表头结点pa->next=NULL;for(i=1;i<=n;i++){scanf("%f,%d",&e.coef,&e.expn);if(!LocateNode(pa,e,q)) //当前链表中不存在该指数项InsertNode(pa,e,q); //调用InsertNode函数插入结点}L=pa;}根据一元多项式相加的运算规则：对于一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项；对于两个一元多项式中所有指数不相同的项，则分别复制到“和多项式”中相应的位置。
根据以上运算规则，其实现算法思路如下：假设pc为指向“和多项式链表”当前尾结点的指针，指针pa和pb分别指向两个多项式中当前进行比较的某个结点，则比较两个结点中的指数项值，有下面三种情况：1.若指针pa所指结点的指数值大于指针pb所指结点的指数值，则取pa指针所指向的结点插入到pc指针所指结点之后，分别修改指针pa和pc，使之指向链表的下一个结点；2.若指针pa所指结点的指数值小于指针pb所指结点的指数值，则取pb指针所指向的结点插入到pc指针所指结点之后，分别修改指针pb和pc，使之指向链表的下一个结点；3.若指针pa所指结点的指数值等于指针pb所指结点的指数值，则将两结点中的系数相加，如果其和数不为零，则修改pa指针所指结点中的系数值，将其结点插入到pc指针所指结点之后，分别修改pa、pb和pc，使之指向各自链表的下一个结点，同时删除并释放指针pb原先指向各自链表的下一个结点；如果和数为零，保存pa和pb所指向的结点，修改pa和pb指针使之指向各自链表的下一个结点，然后释放保存的两个结点。
再比较指针pa和pb指向节点中的指数项值，分3种情况进行处理…..这样的操作一直继续到pa或pb等于NULL为止。
最后将未结束的链表后面剩余的节点连接到pc指针所指向结点之后。
上述多项式的相加过程和两个有序链表合并的过程类似，不同之处仅在于多项式的比较多了相等比较后的操作。
因此，多项式相加的过程完全可以利用线性链表的基本操作来实现。
具体实现多项式相加的算法如下：void AddPolyn(LinkList La,LinkList Lb,LinkList &Lc){ //两个有序链表La和Lb表示的多项式相加ListNode *pa,*pb,*pc,*s;float sum;pa=La->next;pb=Lb->next; //pa和pb分别指向两个链表的开始结点Lc=pc=La; //用La的头结点作为Lc的头结点while (pa&&pb){if(pa->data.expn > pb->data.expn){pc->next=pa;pc=pa;pa=pa->next;}else if(pa->data.expn < pb->data.expn){pc->next=pb;pc=pb;pb=pb->next;}else {sum=pa->data.coef+pb->data.coef;if(fabs(sum)>0){ //系数和不为零pa->data.coef=sum;pc->next=pa;pc=pa;pa=pa->next;s=pb;pb=pb->next;free(s);}else{s=pa;pa=pa->next;free(s);s=pb;pb=pb->next;free(s);}}}pc->next=pa?pa:pb;//插入链表剩余部分free(Lb);//释放Lb的头结点}(4) 多项式链表的输出void printList(LinkList L)函数功能：显示多项式链表。
在输出项中使用了条件表达式，当系数项为正数时，在系数前输出一个“+”号，否则输出一个空格，而负数的负号还照常输出，使得输出结果尽量与原多项式的表示形式类似。
因此，输出多项式链表的算法实现如下：//多项式链表的输出void printList(LinkList L){ListNode *p;p=L->next;while(p){printf("%c %fx^ %d",(p->data.coef>0? '+':' '),p->data.coef,p->data.expn);p=p->next;}printf("\n");}源程序代码：#include <stdio.h>#include <stdlib.h>#include <math.h>//多项式链表结点类型定义typedef struct //在struct前使用关键字typedef，表示是声明新类型{float coef; //系数int expn; //指数}DataType; //DataType是新类型typedef struct node //单链表的存储{DataType data; //数据域struct node *next; //指向下一个结点}ListNode,*LinkList; //ListNode是结点的新类型，LinkList是指向ListNode类型的结点的指针类型//结点的查找定位int LocateNode(LinkList L,DataType e,int &q){ListNode *p=L->next;q=0;//记录结点位置序号while(p&&e.expn<p->data.expn){p=p->next;q++;}if(p==NULL||e.expn!=p->data.expn)return 0;elsereturn 1;}//有序链表结点的插入void InsertNode(LinkList &L,DataType e,int q){ListNode *s,*p;int i=0;p=L;while(p->next && i<q){p=p->next;i++;}s=(ListNode*)malloc(sizeof(ListNode));s->data.coef=e.coef;s->data.expn=e.expn;s->next=p->next;p->next=s;}//多项式链表的建立void CreatPolyn(LinkList &L,int n){LinkList pa; //定义一个头指针为pa链表int i,q; //i用来计输入的项数，q指结点的位置序号DataType e; //插入的值epa=(ListNode*)malloc(sizeof(ListNode)); //生成链表头结点pa->next=NULL;for(i=1;i<=n;i++){scanf("%f,%d",&e.coef,&e.expn);if(!LocateNode(pa,e,q)) //当前链表中不存在该指数项InsertNode(pa,e,q); //调用InsertNode函数插入结点}L=pa;}//多项式链表的输出void printList(LinkList L){ListNode *p;p=L->next;while(p){printf("%c %fx^ %d",(p->data.coef>0? '+':' '),p->data.coef,p->data.expn);p=p->next;}printf("\n");}//多项式链表的相加void AddPolyn(LinkList La,LinkList Lb,LinkList &Lc){ //两个有序链表La和Lb表示的多项式相加ListNode *pa,*pb,*pc,*s;float sum;pa=La->next;pb=Lb->next;//pa和pb分别指向两个链表的开始结点Lc=pc=La;//用La的头结点作为Lc的头结点while (pa&&pb){if(pa->data.expn > pb->data.expn){pc->next=pa;pc=pa;pa=pa->next;}else if(pa->data.expn < pb->data.expn){pc->next=pb;pc=pb;pb=pb->next;}else {sum=pa->data.coef+pb->data.coef;if(fabs(sum)>0){//系数和不为零pa->data.coef=sum;pc->next=pa;pc=pa;pa=pa->next;s=pb;pb=pb->next;free(s);}else{s=pa;pa=pa->next;free(s);s=pb;pb=pb->next;free(s);}}}pc->next=pa?pa:pb;//插入链表剩余部分free(Lb);//释放Lb的头结点}//主控函数void main(){LinkList La,Lb,Lc;int n;printf("输入第一个多项式的项数:");scanf("%d",&n);printf("输入第一个多项式的每一项的系数,指数:\n");CreatPolyn(La,n);printf("第一个多项式为:");printList(La);printf("输入第二个多项式的项数:");scanf("%d",&n);printf("输入第二个多项式的每一项的系数,指数:");CreatPolyn(Lb,n);printf("第二个多项式为:");printList(Lb);AddPolyn(La,Lb,Lc);printf("\n相加后的和多项式为:");printList(Lc);}5、调试分析此一元多项式的运算程序，只能实现一元多项式的加、减法，不能实现一元多项式的乘法，而且若想计数多个多项式的和或者差的话，必须退出界面重新开始计算。