数据结构-多项式相加

合集下载

多项式相加数据结构

多项式相加数据结构多项式相加是一种常见的数学操作，它在数据结构中也有广泛的应用。

本文将介绍多项式相加的概念、实现方法以及应用场景。

## 一、多项式相加的概念多项式是由常数项和一系列幂次项组成的代数表达式，形如：P(x) = a0 + a1x + a2x^2 + ... + anx^n其中，ai为系数，x为变量，n为最高次数。

多项式相加即将两个或多个多项式相加得到一个新的多项式。

## 二、多项式相加的实现方法多项式相加的实现方法有多种，常见的有数组表示法、链表表示法和稀疏矩阵表示法。

1. 数组表示法：将多项式的系数存储在一个数组中，数组下标表示幂次，数组元素表示系数。

2. 链表表示法：将多项式的每一项用链表的形式连接起来，每个节点包含系数和幂次信息。

3. 稀疏矩阵表示法：对于稀疏的多项式，只存储非零项的信息，可以用矩阵的形式表示。

不同的表示方法适用于不同的场景，选择合适的实现方法可以提高多项式相加的效率和灵活性。

## 三、多项式相加的应用场景多项式相加在实际应用中有很多场景，以下列举几个常见的应用场景：1. 数据压缩：在某些情况下，数据具有稀疏性，多项式相加可以将稀疏数据压缩为较小的存储空间，减少数据传输和存储成本。

2. 图像处理：图像的滤波操作可以看作是将图像的像素值与一个多项式进行相加的过程，通过调整多项式的系数可以实现不同的滤波效果。

3. 信号处理：信号可以表示为一个多项式的形式，多项式相加可以实现信号的叠加和混合，用于音频合成、语音识别等应用。

4. 机器学习：在机器学习算法中，多项式相加可以用于特征工程，通过将不同特征的多项式进行相加，得到新的特征表示，提高模型的拟合能力。

## 四、总结多项式相加是一种常见的数学操作，在数据结构中有广泛的应用。

本文介绍了多项式相加的概念、实现方法和应用场景，并提到了多项式相加在数据压缩、图像处理、信号处理和机器学习等领域的重要性。

选择合适的实现方法和应用场景可以提高多项式相加的效率和灵活性，进而推动相关领域的发展和应用。

数据结构-实验一-一元多项式相加

数据结构实验报告实验一：一元多项式相加姓名：周成学号： 13083511专业：软件工程任课教师：马慧珠2013年12 月01 日1.实验名称：一元多项式相加2.实验目的:如何使用C语言实现链表的说明、创建以及结点的插入和删除等操作。

3.实验要求：对一元多项式能实现输入、输出，以及两个一元多项式相加及结果显示。

4.实验内容：一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。

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

根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项，对于两个一元多项式中所有指数不相同的项，则分别复抄到“和多项式”中去。

核心算法PolyAdd是把分别由pa和pb所指的两个多项式相加，结果为pa所指的多项式。

运算规则如下：相加时，首先设两个指针变量qa和qb分别从多项式的首项开始扫描，比较qa和qb所指结点指数域的值，可能出现下列三种情况之一：（1）qa->exp大于qb->exp,则qa继续向后扫描。

（2）qa->exp等于qb->exp,则将其系数相加。

若相加结果不为零，将结果放入qa->coef中，并删除qb所指结点，否则同时删除qa和qb所指结点。

然后qa、qb继续向后扫描。

（3）qa->exp小于qb->exp,则将qb所指结点插入qa所指结点之前，然后qa、qb继续向后扫描。

扫描过程一直进行到qa或qb有一个为空为止，然后将有剩余结点的链表接在结果表上。

所得pa指向的链表即为两个多项式之和。

5.实验程序代码及运行结果：#include"stdafx.h"#include<stdio.h>#include<stdlib.h>#include<malloc.h>#include<stdio.h>#define NULL 0typedef struct NODE{float coef; //系¦Ì数ºyint expn; //指?数ºystruct NODE *next;}NODE;NODE *Creat(int n);void print(NODE *head);NODE *AddPolyn(NODE *head1, NODE *head2);NODE *Delfirst(NODE *head, NODE *q);void InsertBefore(NODE *p1, NODE *p2);int compare(int a, int b);/*创ä¡ä建¡§链¢¡ä表À¨ª*/NODE *Creat(int n){NODE *current, *previous, *head;int i;head = (NODE *)malloc(sizeof(NODE)); /*创ä¡ä建¡§头ª¡¤结¨¢点Ì?*/previous = head;for(i = 0; i < n; i++){current = (NODE *)malloc(sizeof(NODE));printf("请?输º?入¨?系¦Ì数ºy和¨ª指?数ºy : ");scanf("%f%d", &current->coef, &current->expn);previous->next = current;previous = current;}previous->next = NULL;return head;}/*一°?元a多¨¤项?式º?的Ì?想?加¨®，ê?总Á¨¹体¬?考?虑?，ê?可¨¦分¤?qa的Ì?指?数ºy比À¨¨qb小?，ê?或¨°等Ì¨¨于®¨²pb(如¨?果?系¦Ì数ºy相¨¤加¨®等Ì¨¨于®¨²0和¨ª不?等Ì¨¨于®¨²0),或¨°大ä¨®于®¨²pb里¤?面?由®¨¦InsertBefore和¨ªDelfirst两¢?个?小?模¡ê块¨¦组Á¨¦成¨¦一°?部?分¤?*/ NODE *AddPolyn(NODE *head1, NODE *head2){NODE *ha, *hb, *qa, *qb;int a, b;float sum;ha = head1; /*ha和¨ªhb指?向¨°头ª¡¤结¨¢点Ì?*/hb = head2;qa = ha->next; /*qa和¨ªqb指?向¨°头ª¡¤结¨¢点Ì?的Ì?下?一°?个?结¨¢点Ì?*/qb = hb->next;while(qa && qb) /*qa和¨ªqb均¨´非¤?空?*/{a = qa->expn;b = qb->expn;switch(compare(a, b)) {case -1 : /*qa->expn < qb->expn*/ha = qa;qa = qa->next;break;case 0 :sum = qa->coef + qb->coef; /*系¦Ì数ºy的Ì?和¨ª*/if(sum != 0.0) { /*如¨?果?不?是º?0.0*/qa->coef = sum; /*改?变À?系¦Ì数ºy*/ha = qa;}else{free(Delfirst(ha, qa));}free(Delfirst(hb, qb));qa = ha->next;qb = hb->next; /*qb释º¨ª放¤?后¨®要°a重?新?赋3值¦Ì*/ break;case 1 : /*如¨?果?qa-> expn > qb -> expn*/Delfirst(hb, qb);InsertBefore(ha, qb); /*把ã?qb插?入¨?到Ì?ha下?一°?个?结¨¢点Ì?之?前¡ã*/qb = hb->next;ha = ha->next;break;}}if(qb)ha->next = qb; /*插?入¨?剩º¡ê余®¨¤的Ì?pb*/free(head2);return head1;}/*比À¨¨较?*/int compare(int a, int b){if(a < b)return -1;else if(a > b)return 1;elsereturn 0;}/*删¦?除y结¨¢点Ì?q*/NODE *Delfirst(NODE *p1, NODE *q){p1 -> next = q -> next;return (q);}/*插?入¨?结¨¢点Ì?,引°y入¨?结¨¢点Ì?p,可¨¦以°?让¨?p插?入¨?到Ì?p2和¨ªp1之?间?*/ void InsertBefore(NODE *p1, NODE *p2){NODE *p;p = p1->next;p1->next = p2;p2->next = p;}/*打ä¨°印®?,为a了¢?美¨¤观?程¨¬序¨°分¤?开a打ä¨°印®?*/void print(NODE *head){NODE *current;current = head->next;while(current->next != NULL){printf("%0.f * x^%d + ", current->coef, current->expn);current = current -> next;}printf("%0.f * x^%d", current->coef, current->expn);//system（ê¡§"pause");}int main(){NODE *head1, *head2, *head3;int n1, n2;printf("请?输º?入¨?你?需¨¨要°a的Ì?多¨¤项?式º?的Ì?项?数ºy n1 : "); scanf("%d", &n1);head1 = Creat(n1);printf("第Ì¨²一°?个?多¨¤项?式º?的Ì?显?示º? : \n");print(head1);printf("\n请?输º?入¨?你?需¨¨要°a的Ì?多¨¤项?式º?的Ì?项?数ºy n2 : "); scanf("%d", &n2);head2 = Creat(n2);printf("\n第Ì¨²二t个?多¨¤项?式º?的Ì?显?示º? : \n");print(head2);head3 = AddPolyn(head1, head2);printf("\n合?并¡é后¨®的Ì?多¨¤项?式º?的Ì?显?示º? : \n");print(head3);printf("\n");}运行结果：实验数据1如图：输入一个四次二项式X^3+2X^4，一个五次二项式X^4+2X^5，输出如图：实验数据2如图：输入一个五次四项式X^2+X^3+X^4+X^5，还有一个五次五项式1+X+X^3+2X^4+2X^5输出如图所示实验数据3如图：输入一个七次三项式1+2x^5+3X^7，还有一个五次四项式1+2X^2+3X^4+4X^5,输出如图：6.实验总结本来我对编程很没有信心，做这样一个课程设计感觉有点吃力，虽然有些人觉得很简单，但是我还是坚持做下来了，我不断的看书，翻阅资料，询问同学，上网搜索，总算有模有样地把这个程序编的能运行了。

数据结构-单链表-多项式相加

数据结构-单链表-多项式相加【问题描述】编写⼀个程序⽤单链表存储多项式，并实现两个⼀元多项式A与B相加的函数。

A，B刚开始是⽆序的，A与B之和按降序排列。

例如：多项式A: 1.2X^0 2.5X^1 3.2X^3 -2.5X^5多项式B: -1.2X^0 2.5X^1 3.2X^3 2.5X^5 5.4X^10多项式A与B之和：5.4X^10 6.4X^3 5X^1【输⼊形式】任意两个多项式A和B的项数及对应的系数和指数，要查询的第⼏项【输出形式】多项式中某⼀项的系数与指数，系数保留⼀位⼩数【输⼊样例】4 1.2 0 2.5 1 3.2 3 -2.5 55 -1.2 0 2.5 1 3.2 3 2.5 5 5.4 102【输出样例】6.4 31 #include<bits/stdc++.h>2 #include<stdlib.h>3using namespace std;4 typedef long long ll;56struct node{7double data;8int index;9 node* next;10 node():index(0){}11 node* operator [] (int n){12 node* end=next;13while(end&&n--)end=end->next;14return end;15 }16bool operator < (const node &t) const {17return index>t.index;18 }19 node operator * (node& t);20 };2122void newList(node & head,int length){23 node *a=new node[length];//这是这个函数的解释node* operator [] (int n)P11⾏申请空间的⽅式 new int[10]申请10个int类型的空间再返回node指针类型24for(int i=0;i<length;++i)cin>>a[i].data>>a[i].index;25//a是node类型数组啊26 sort(a,a+length);//p16⾏的函数解释27 node* end=&head;28for(int i=0;i<length;++i){29 node* t=new node;30 t->data=a[i].data;31 t->index=a[i].index;32 end->next=t;33 end=t;34 }//他这好像就特别简单 end=xx 之后就申请了新节点赋值然后挂上去35delete[] a;36 }37void show(node& head){//传递的这个是引⽤38 node* end=head.next;//就还是这个类型所以⽤的是.39while(end){40if(end->index==1) cout<<end->data<<"X^"<<(end->next?" + ":"\n");41else cout<<end->data<<"X^"<<end->index<<(end->next?" + ":"\n");//末尾加的这个的意思是如果下⼀个节点还有就+上如果没有就换⾏42 end=end->next;43 }44 }4546///多项式相加：47void combine(node& a, node& b){//传递的是引⽤48 node* p,*q,*tail,*temp;49double s;50 p=a.next;51 q=b.next;52 tail=&a;//就直接修改a链表了53while(p&&q){54if(p->index>q->index){55 tail->next=p;tail=p;p=p->next;56 }else if(p->index==q->index){57 s=p->data+q->data;58if(s){59 p->data=s;60 tail->next=p; tail=p;p=p->next;61 temp=q;q=q->next;delete temp;62 }else{63 temp=p;p=p->next;delete temp;64 temp=q;q=q->next;delete temp;65 }//删除没有⽤的节点这点甚是符合朕⼼厉害66 }else{67 tail->next=q; tail=q; q=q->next;68 }69 }70if(p)tail->next=p;71else tail->next=q;72 }7374int main(){75 node a,b;76int n1,n2;cin>>n1;77 newList(a,n1);78 cin>>n2;79 newList(b,n2);80 combine(a,b);8182 cin>>n1;83 cout<<fixed<<setprecision(1)<<a[n1-1]->data<<""<<a[n1-1]->index<<endl;//这⾥可以这么骚也是因为p11⾏⽜逼84 show(a);//给引⽤传参数就是传本⾝不是传指针85 }。

多项式相加数据结构

多项式相加数据结构多项式相加数据结构是一种用于处理多项式加法的算法和数据结构。

在数学中，多项式是由常数和变量的乘积相加而成的表达式。

例如，2x² + 3x + 4就是一个多项式。

在计算机科学中，我们需要对多项式进行操作，如求导、求积分、求根、求值等。

对于两个多项式P(x)和Q(x)，它们的加法可以表示为：R(x) = P(x) + Q(x)，即将它们的同类项相加得到结果R(x)。

例如，(2x² + 3x + 4) + (4x² - 2x + 1) = 6x² + x + 5。

实现多项式相加有很多方法，其中一种常见的方法是使用链表来存储每个非零系数的项。

链表中每个节点包含两个字段：系数和指数。

系数表示该项的系数，指数表示该项中变量的指数。

例如，在上面的例子中，第一个多项式可以表示为：2 -> 2 -> null其中第一个节点表示系数为2、指数为2（即2x²）的一项，第二个节点表示系数为3、指数为1（即3x）的一项。

使用链表存储多项式有以下优点：1. 可以灵活地插入和删除节点，方便进行各种操作。

2. 可以节省空间，因为只存储非零系数的项，而且指数是有序的。

3. 可以方便地进行排序和合并，因为链表中的节点是有序的。

下面是一个简单的多项式相加算法：1. 创建一个空链表R，用于存储结果。

2. 从P和Q的头节点开始遍历它们的链表。

3. 如果P和Q都还有节点，则比较它们的指数大小：a. 如果P的指数小于Q的指数，则将P节点插入到R中，并移动P 指针到下一个节点。

b. 如果Q的指数小于P的指数，则将Q节点插入到R中，并移动Q指针到下一个节点。

c. 如果P和Q的指数相等，则将它们对应系数相加得到新系数，并创建一个新节点插入到R中。

然后移动P和Q指针到下一个节点。

4. 如果其中一个链表已经遍历完了，则将另一个链表剩余部分直接插入到R中。

5. 返回结果链表R。

数据结构实验多项式加法

数据结构实验报告实验名称：多项式加减法学号：19姓名：林强实验日期：一、实验目的通过实现多项式的加减法，对链表有更深入的了解二、实验具体内容1、实验题目1：（1）题目设计一个一元稀疏多项式简单的加减法计算器实现要求：一元稀疏多项式简单计算器的基本功能是：（1）输入并建立多项式：8517A+x+x=；+73x9)(x798xB-+x=822x)(x（2）输出多项式（3）多项式A和B相加，建立多项式C＝A＋B，并输出相加的结果多项式C（4）选作：多项式A和B相减，建立多项式C＝A－B，并输出相加的结果多项式D （2）分析1：本程序的任务是实现两个多项式的加法其中多项式的系数为浮点型，指数为整数，输出的结果也为系数和指数。

（1）输入的形式和输入值的范围：输入多项式的系数a和未知数X的指数b，当a和b都为零时，输入结束。

输入值的范围：a为实数，b为整数。

（2）输出形式：输出多项式的系数和多项式未知数X的指数即(a,b)形式。

（3）程序所能达到的功能，实现两个多项式的加法，并输出最后的结果2：整个程序运行期间实行动态创建节点，一边输入数据，一边创建节点当将全部数据输入到单链表中后再调用多项式加法这个函数，并一边实现多项式的相加，一边释放节点，有效防止了在程序反复运行过程中可能出现系统空间不够分配的现象（3）实验代码typedef int Status;#define OVERFLOW -1#define null 0typedef struct Lnode{float coef; //存储项系数int expn;//存储项指数struct Lnode *next;}Lnode,*LinkList;typedef LinkList polynomial;Status InitList_L(LinkList &L) {//初始化头节点L=(LinkList)malloc(sizeof(Lnode));if(!L)return(-1);L->next=null;return 1;}void AddPolyn(polynomial pa, polynomial pb){ //实现两个多项式相加的算法float x;polynomial qa;polynomial qb;polynomial s;polynomial u;qa=pa->next; qb=pb->next; s=pa;while(qa&&qb){if(qa->expn<qb->expn){s=qa;qa=qa->next;}else if(qa->expn==qb->expn){x=qa->coef+qb->coef; if(x!=0){qa->coef=x;s=qa;qa=qa->next;u=qb;qb=qb->next;free(u);}else{s->next=qa->next;free(qa);qa=s->next;u=qb;qb=qb->next;free(u);}}else if(qa->expn>qb->expn){u=qb->next;s->next=qb;s=qb;qb->next=qa;qb=u;}}if(qb)qa->next=qb;free(pb);void main(){float a;int b;polynomial L1;polynomial L2;LinkList q;LinkList p;LinkList m;LinkList n;InitList_L(L1);q=L1;InitList_L(L2);p=L2;cout<<"请输入数据："<<endl;for(;;){cin>>a;cin>>b;if(a==0&&b==0)break;m=new Lnode;m->coef=a;m->expn=b;q->next=m;q=m;q->next=null;}//循环输入第一个多项式的系数与指数for(;;){cin>>a;cin>>b;if(a==0&&b==0)break;n=new Lnode;n->coef=a;n->expn=b;p->next=n;p=n;p->next=null;}//循环输入第二个多项式的系数与指数AddPolyn(L1,L2);//调用多项式相加的算法while((L1->next)!=null){cout<<"("<<L1->next->coef<<","<<L1->next->expn<<")"<<" ";L1=L1->next;}//输出计算结果}三、实验小结通过编写多项加法这个程序，我将自己所学到的创建链表，初始化链表和多项式加法算法都应用了一次，这使我们不仅仅只是理论化的学习书本上的知识，而是将学习到的理论知识应用到实际的操作中来增强我们的实际操作能力，这使我增加了实际操作经验，也使我通过实际操作来认识到自己在程序编写上的不足从而增强了我的实际编写程序的能力。

数据结构实验报告完成多项式的运算

简单介绍：本次作业力在学会链表表示线性表的插入、删除、查找等基本操作设计与实现，学习利用链表提供的接口去求解实际问题，同时熟悉链表的的存储方法。

再基于线性链表的基础设计完成多项式的相加运算程序。

一、实验目的和要求完成多项式的相加、相乘运算。

（1）掌握线性表的插入、删除、查找等基本操作设计与实现（2）学习利用线性表提供的接口去求解实际问题（3）熟悉线性表的的存储方法二、实验内容和原理1.实验内容设计一个一元多项式的简单计算程序，其基本功能有：（1）输入并建立多项式；（2）输出多项式；（3）多项式的相加运算。

利用单链表实现。

2.实验原理使用单链表实现一元多项式的存储，并实现两个一元多项式的加法运算。

三、实验环境硬件：（1）学生用微机（2）多媒体教室或远程教学（3）局域网环境软件：（1）Windows XP中文操作系统（2）VC6.0四、算法描述及实验步骤1、描述：加法：输入建立一元多项式,进行简单加法运算,输出结果；通过建立单链表A和B分别存放多项式的a和b的各项系数及指数；并且利用A使得不产生新的节点而在A中存放数据运算结果；该过程通过定义指针变量p和q使它们分别指向两个多项式的第一个节点，之后依次比较它们所指向的项的指数，即一种情况指数相等时系数相加且和不为零，修改当前p所指项的系数（和），同时删除q所指项，若和为零则同时删除p和q各自所指；情况二，p当前项指数大于q当前项，将q所指插入p所指之前作为结果项之一；情况三，p当前项指数小于q当前项，p所指作为多项式和的一项，移动p指向下一项，进行比较，在移动p，q至其中以个链空，把另一个链余下节点插在p所指之后；乘法：定义指针p,q指向所操作节点，通过A链表的每一项与B链表各项相乘，指数相加，系数相乘，将值赋给新节点各自域，构成一新的链表，最后返回头结点。

可这样有一个问题，即新生成的链表，即最终结果混乱，没有对数据进行过滤，相同指数项应在执行加法运算，所以可以这样实现，通过A链表的每一项与B链表各项相乘的新生成节点单独构成一链表，并将第一个链表加入另一新链表，循环此操作将后生成的链表加之先前的链表，即可实现排序问题。

数据结构多项式相加

public interface LList<E> //线性表接口{boolean isEmpty(); //判断线性表是否为空int length(); //返回线性表长度E get(int index); //返回序号为index的对象E set(int index, E element); //设置序号为index对象为boolean add(int index, E element);//插入element对象，插入后对象序号为indexboolean add(E element); //插入element对象，插入位置没有约定E remove(int index); //移去序号为index的对象，返回被移去对象void clear(); //清空线性表}2.用栈实现括号的匹配public interface SStack<E> {boolean isEmpty(); //判断是否空栈boolean push(E element); //入栈E pop(); //出栈E get(); //取栈顶元素值}三．实验详细设计1.用单链表实现多项式相加创建三个类：结点类，链表类，主类结点类：创建结点，每个结点包括指数域，系数域，后继结点链，创建构造方法和带有参数的方法，获取，设置指数和系数，返回后继结点链表类：创建构造函数，设置并获得表头。

插入元素，多项式按照降幂排列，创建方法实现两链表相加，打印多项式链表主类：提示输入第两个多项式的长度和数据，存贮数据在两个数组之中，创建两个链表，并分别将数组的头地址赋给该链表，使用循环将元素插入后输出连个多项式和结果。

多项式降幂排列的实现，链表的相加在代码中均有详细注释代码如下：主类PoloMainpackage Polo;import javax.swing.JOptionPane;public class PoloMain {public static void main(String[] args) {String lengths = JOptionPane.showInputDialog("请输入第一个多项式长度 ");int length = Integer.parseInt(lengths);Node[] a = new Node[length];for(int i=0;i<length;i++){String getc1s = JOptionPane.showInputDialog("请输入第一个多项式中第 "+(i+1)+ "项的系数 ");int getc1 = Integer.parseInt(getc1s);String gete1s = JOptionPane.showInputDialog("请输入第一个多项式中第 "+(i+1)+ "项的指数 ");int gete1 = Integer.parseInt(gete1s);a[i]=new Node(getc1,gete1);}String length2s = JOptionPane.showInputDialog("请输入第二个多项式长度 ");int leng2th = Integer.parseInt(length2s);Node[] b = new Node[leng2th];for(int i=0;i<leng2th;i++){String getc2s = JOptionPane.showInputDialog("请输入第二个多项式中第 "+(i+1)+ "项的系数 ");int getc2 = Integer.parseInt(getc2s);String gete2s = JOptionPane.showInputDialog("请输入第二个多项式中第 "+(i+1)+ "项的指数 ");int gete2 = Integer.parseInt(gete2s);b[i]=new Node(getc2,gete2);}// Node []a={new Node(10,8),new Node(-3,7),new Node(4,9),new Node(12,-1),new Node(8,4)};// Node []b={new Node(7,8),new Node(6,9),new Node(14,6),new Node(-7,7),new Node(21,3)};PoloList A= new PoloList(a[0] );PoloList B= new PoloList( b[0]);for(int i=1;i<a.length;i++){A.insert(a[i]);}for(int j=1;j<b.length;j++){B.insert(b[j]);}System.out.println("多项式A为：");A.printList();System.out.println();System.out.println("多项式B为：");B.printList();System.out.println();System.out.println("两式相加结果为：");PoloList result=A.AddtwoList(B);result.printList();System.out.println();}}链表类PoloListpackage Polo;public class PoloList {private Node header;// 构造函数public PoloList(){header=null;}public PoloList(Node h){header=h;}// 设置表头public void setheader(Node newheader){ header=newheader;}// 获得表头public Node getheader(){return header;//找到表中某结点的前一元素public Node findprevious(Node n){Node temp=header;if(n.equals(header)){return header;}else{while(temp.getNext()!=null&&temp!=null){if(temp.getNext().equals(n))return temp;elsetemp=temp.getNext();}}return null;}// 插入某节点（按照次数降序排列）public void insert(Node n) {//要插入的结点的次数int indegree=n.getdegree();if(header==null)header=n;else{for(Node temp=header;temp!=null;temp=temp.getNext()){//如果链表中已有相同次数项，只需将系数相加即可。

数据结构—多项式求和

实验一多项式求和实验一、程序验证1、源代码：#include<iostream.h>//cout,cin#include"process.h"//exit()#define Max 20typedef struct{float coef;int exp;}PolyArray[Max];struct PolyNode{float coef;int exp;PolyNode *next;};class Poly{private:PolyNode *head;public:Poly();//构造函数，建立空多项式~Poly();//析构函数，释放多项式void Create(PolyArray a,int n);//键盘输入，创建多项式链表void Disp();//多项式显示void Sort();//有序表排序void Add (Poly LB);//多项式加//void Substract(PolyNode * hbQ);//多项式减//void Multiply(PolyNode * hb);//多项式乘};Poly::Poly(){ //创建一空多项式head=new PolyNode;head->next=NULL;}Poly::~Poly(){//释放多项式所占空间PolyNode *p;while(head!=NULL){//从头结点开始，依次释放结点p=head;head=head->next;delete p;}head=NULL;//头结点指向空}void Poly::Disp (){PolyNode *p;p=head->next;while(p!=NULL){cout<<p->coef <<"x^"<<p->exp<<'\t' ;p=p->next ;}cout<<endl;}void Poly::Create (PolyArray a,int n){//由多项式数组创建多项式链表PolyNode *s,*r;int i;r=head;for(i=0;i<n;i++){s=new PolyNode;s->coef =a[i].coef;s->exp =a[i].exp;s->next =NULL;r->next =s;r=s;}}void Poly::Sort(){PolyNode *p,*q,*r;p=head->next ;if(p!=NULL){r=p->next ;//r指向p的后继结点p->next =NULL;//构造只有一个结点的有序表p=r;while(p!=NULL){r=p->next;q=head;while(q->next!=NULL && q->next ->exp < p->exp )q=q->next ;//在有序表中插入*p的前驱结点*q p->next =q->next ;//*p插入到*q之后q->next =p;p=r;}}}void Poly::Add(Poly LB){float sum;PolyNode *pa,*pb,*qa,*qb;pa=head;qa=pa->next;pb=LB.head ;qb=pb->next;while (qa!=NULL && qb!=NULL ){if (qa->exp < qb->exp ){//pa=qa;qa=qa->next; }else if ( qa->exp > qb->exp ){ //pb->next =qb->next;qb->next=qa;pa->next=qb;pa=qb;qb=pb->next;}else{//sum=qa->coef+qb->coef;if (sum==0 ){//pa->next=qa->next;delete qa;qa=pa->next;pb->next=qb->next;delete qb;qb=pb->next;}else{qa->coef=sum;pa=qa; qa=qa->next;pb->next=qb->next;delete qb;qb=pb->next;}}}//whileif(qb!=NULL)qa->next=qb;//}//Addvoid main(){Poly LA,LB;PolyArray a={{7.0,0},{3.0,1},{9.0,8},{5.0,16}};PolyArray b={{8.0,1},{22,7},{-9.0,8}};LA.Create (a,4);LB.Create (b,3);cout<<"原多项式A为：";LA.Disp ();cout<<"原多项式B为：";LB.Disp ();LA.Sort ();LB.Sort ();cout<<"有序多项式A为：";LA.Disp ();cout<<"有序多项式B为：";LB.Disp();LA.Add (LB);cout<<"和多项式为：";LA.Disp ();}2、运行结果：实验二有序表合并一、实验设计1、问题描述把两个有序表归并为一个有序表。

数据结构实验-多项式的相加减

集美大学数据结构课程实验报告课程名称：数据结构班级：网络0911实验成绩：指导教师：姓名：实验项目名称：多项式的相加减学号上机实践日期：实验项目编号：组号：上机实践时间：学时一、目的(本次实验所涉及并要求掌握的知识点)学习和掌握如何运用链表来实现一元稀疏多项式的相加减。

多项式的输入和输出的应注意的要点，规定输出的多项式的顺序。

二、实验内容与设计思想(设计思路、主要数据结构、主要代码结构、)实验内容：一元稀疏多项式的相加减设计思路：建立数据结构存放常数和系数以及指向下一个节点的指数，用链表存放各个节点，通过对常数和系数的的运算，实现多项式的相加减主要数据结构：结构体，链表主要代码结构：struct Polyn;void addPolyn(Polyn * a,Polyn * b,int add);void display( );void tip()’Polyn * CreatPolyn(int m);三、实验使用环境(本次实验所使用的平台和相关软件)Dev-C++、windows XP四、实验步骤和调试过程(实验步骤、测试数据设计、测试结果分析)需说明出，加入必要的截图说明。

#include<iostream>#include<vector>using namespace std;struct Polyn{float coef;int expn;Polyn *next;};//构建结构体vector <Polyn *> ve;void addPolyn(Polyn * a,Polyn * b,int add);void display(Polyn *n);//打印void tip();//屏幕显示Polyn * CreatPolyn(int m); //建立多项式int main(){tip();system("pause");}void tip(){Polyn *first, *second,*s;int m;for( int i=1;i;){cout<<" 多项式运算.\n";cout<<"======================="<<"\n"; cout<<" 1------ 构造多项式.\n";cout<<" 2------ 多项式相加.\n";cout<<" 3------ 多项式相减.\n";cout<<" 0------ 结束.\n";cout<<"======================="<<"\n"; cout<<" 请输入您的选择.\n";cin>>i;switch(i){case 1:cout<<"请输入多项式的项数.\n";cin>>m;s=CreatPolyn(m);display(s);ve.push_back(s);break;case 2:first=ve.back();ve.pop_back();second=ve.back();addPolyn(first,second,0);break;case 3:first=ve.back();ve.pop_back();second=ve.back();addPolyn( first,second,1);break;case 0:cout<<" 再见"<<"\n";break;};}}Polyn* CreatPolyn(int m){Polyn* px=new Polyn[m];cout<<" 输入系数.\n";for(int i=0;i<m;i++)cin>>px[i].coef;cout<<"输入与系数相对应的指数.\n";for(int i=0;i<m;i++){cin>>px[i].expn;if(i!=m-1)px[i].next=&px[i+1];elsepx[i].next=NULL;}return px;}void display(Polyn *n){int q=0;Polyn * r;r=n;for(;r;r=r->next){if(r->coef)q++;if(r==n){if(r->coef!=0)cout<<r->coef<<"X"<<"^"<<r->expn;}else{if( r->coef>0)cout<<"+"<<r->coef<<"X"<<"^"<<r->expn;if(r->coef<0)cout<<r->coef<<"X"<<"^"<<r->expn;}}cout<<"\n";if(q==0)cout<<"0"<<"\n";}void addPolyn(Polyn * a,Polyn * b,int add)//两个多项式的加减{float c;int a1=1,b1=1,s,e;Polyn *ha,*hb,*p,*r;ha=a;hb=b;p=ha;r=hb;for(int i=0;ha[i].next;++i)a1++;for(int i=0;hb[i].next;++i)b1++;ha[a1-1].next=hb;for(int j=0;j<b1;j++){for(int i=0;i<a1;i++){if(a[i].expn-b[j].expn==0){if(add)ha[i].coef=ha[i].coef-hb[j].coef;elseha[i].coef=ha[i].coef+hb[j].coef;if(hb!=&hb[j])hb[j-1].next=hb[j].next;else{hb=hb[j].next;ha[a1-1].next=hb;}i=a1;}}}for(;p;p=p->next){for( Polyn * t=p->next;t;t=t->next)if( p->expn>t->expn){e=p->expn;p->expn=t->expn;t->expn=e;c=p->coef;p->coef=t->coef;t->coef=c;}}display(ha);}五、实验小结(实验中遇到的问题及解决过程、实验体会和收获)至少两点1.刚开始实现多项式的相加减运算时，申请一个新的空间来存放结果，结果指针乱了，后来改成了现在的程序。

数据结构实验-一元多项式的加法运算

一元多项式加法一、实验目的通过实现多项式加法，对链表有更深入的了解二、实验内容问题描述：设计一个一元稀疏多项式简单的加法计算器实现要求：一元稀疏多项式简单计算器的基本功能是：（1）输入并建立多项式：1785937)(x x x x A +++=；879228)(x x x x B -+=（2）输出多项式（3）多项式A 和B 相加，建立多项式C ＝A ＋B ，并输出相加的结果多项式C（4）选作：多项式A 和B 相减，建立多项式C ＝A －B ，并输出相减的结果多项式D 方法说明：（1）多项式的输入与存储用带表头结点的单链表存储多项式，链表中的每个节点分别存储多项式各项的系数和指数，即每从键盘输入多项式的一对数（系数，指数），可对应建立链表的一个结点。

每个节点的结构为：建立两个链表，其中pa 和pb 分别为它们的头指针：pb结果链表Pa(或者是Pc)Pc（2）多项式数据类型的定义struct tagNode{float coef;int exp;struct tagNode *next;typedef struct tagNode Node;typedef struct tagNode* pNode;（3）主要算法①创建两个链表，分别存放多项式1和多项式2，这两个链表中的节点是按指数降序或者升序排列的②多项式相加，下面给出多项式相加的部分实现/*下面的函数实现两个多项式的相加，要相加的链表分别由pa和pb指向（其中，pa，pb都是分配了空间的头结点）。

相加的结果直接由pa指向的链表保存，即是在pa链表中添加或删除（当系数因为相加为0的情况下）一些结点，构成结果。

相加的链表中指数按从小到大的顺序排列好的，是升序链表。

*/void add_poly(Node *pa,Node *pb){Node *p=pa->pNext;//链表1，将来的结果也放在此Node *q=pb->pNext;//链表2Node *pre=pa;Node *u;//临时用float x;while (p!=NULL && q!=NULL)//当两个链表都不为空{if (p->exp<q->exp)//比较链表1跟链表2当前节点的指数大小，链表1也是存放结果的地方{pre=p;p=p->pNext;//p指向要比较的下一个结点。

数据结构多项式运算的程序（加减法和乘法）C语言版

数据结构多项式运算的程序（加减法和乘法）C语言版#include#includetypedef struct node{//定义节点类型float coef;int expn;struct node * next;}PLOY;void start()//用户选择界面{printf("************************************\n");printf(" 两个一元多项式的相加/相减，相乘:\n");printf("************************************\n");printf("请选择操作:\n");printf("0.退出\n");printf("1.两个一元多项式相加\n");printf("2.两个一元多项式相乘\n");printf("3.两个一元多项式相减\n");}void insert(PLOY *head,PLOY *inpt)//查找位置插入新链节程序{PLOY *pre,*now;int signal=0;pre=head;//pre定义为现在的前一个链节if(pre->next==NULL) {pre->next=inpt;}else {now=pre->next;while(signal==0){if(inpt->expnexpn)//当新链节小于现在的连接时向后移一个链节{if(now->next==NULL){now->next=inpt;signal=1;}else{pre=now;now=pre->next;}}elseif(inpt->expn>now->expn)//如果发现比现在的链节大了就插入到这个连接的前面{inpt->next=now;pre->next=inpt;signal=1;}else{now->coef=now->coef+inpt->coef;signal=1;free(inpt);//与当前链节相等指数if(now->coef==0){pre->next=now->next;free(now);}}}}}PLOY *creat(char ch)//输入多项式{PLOY *head,*inpt;float x;int y;head=(PLOY *)malloc(sizeof(PLOY));//创建链表头head->next=NULL;printf("请输入一元多项式%c:(格式是：系数指数；以0 0 结束！)\n",ch);scanf("%f %d",&x,&y);while(x!=0){inpt=(PLOY *)malloc(sizeof(PLOY));//创建新链节inpt->coef=x;inpt->expn=y;inpt->next=NULL;insert(head,inpt);//不然就查找位置并且插入新链节printf("请输入一元多项式%c的下一项:(以0 0 结束！)\n",ch);scanf("%f %d",&x,&y);}return head;}PLOY *addPLOY(PLOY *head,PLOY *pre)//多项式相加{PLOY *inpt;int flag=0;while(flag==0){if(pre->next==NULL)flag=1;//当现在指向空时跳出循环else{pre=pre->next;inpt=(PLOY *)malloc(sizeof(PLOY));//创建新链节inpt->coef=pre->coef;inpt->expn=pre->expn;inpt->next=NULL;insert(head,inpt);}//否则把当前"g(x)"的链节插入到"y(x)"中}return head;}PLOY *minusPLOY(PLOY *head,PLOY *pre)//多项式相加{PLOY *inpt;int flag=0;while(flag==0){if(pre->next==NULL)flag=1;//当现在指向空时跳出循环else{pre=pre->next;inpt=(PLOY *)malloc(sizeof(PLOY));//创建新链节inpt->coef=0-pre->coef;inpt->expn=pre->expn;inpt->next=NULL;insert(head,inpt);}//否则把当前"g(x)"的链节插入到"y(x)"中}return head;}PLOY *byPLOY(PLOY *head1,PLOY *head2)//多项式相乘{PLOY *inpt,*res,*pre;int flag=0;res=(PLOY *)malloc(sizeof(PLOY));//创建链表头res->next=NULL;head1=head1->next;pre=head2;while(flag==0){if(pre->next==NULL){pre=head2;//当现在指向空时跳出循环head1=head1->next;continue;}if(head1==NULL){flag=1;//当现在指向空时跳出循环continue;}pre=pre->next;inpt=(PLOY *)malloc(sizeof(PLOY));//创建新链节inpt->coef=pre->coef*head1->coef;inpt->expn=pre->expn+head1->expn;inpt->next=NULL;insert(res,inpt);//把当前"g(x)"的链节插入到"y(x)"中}return res;}void print(PLOY *fun)//输出多项式{PLOY *printing;int flag=0;printing=fun->next;//正在被打印的链节if(fun->next==NULL)//如果函数为空打印0{printf("0\n");return;}while(flag==0){if(printing->coef>0&&fun->next!=printing) printf("+");//为正数时打印"+"号if(printing->coef==1);//如果为"1"就不用打印系数了else if(printing->coef==-1)printf("-");//如果为"-1"就打印"-"号就行了elseprintf("%f",printing->coef);//其余情况都得打印if(printing->expn!=0) printf("x^%d",printing->expn);//如果指数为"0"不打印指数项else if((printing->coef==1)||(printing->coef==-1))printf("1");if(printing->next==NULL)flag=1;//如果现在的链节没有下一个就结束elseprinting=printing->next;}printf("\n");}void main(){PLOY *f,*g;int sign=-1;//设置标志start();while(sign!=0){scanf("%d",&sign);switch(sign){case 0:break;//退出case 1:printf("你选择的操作是多项式相加:\n"); f=creat('f');//输入多项式f(x)printf("f(x)=");print(f);g=creat('g');//输入多项式g(x)printf("g(x)=");print(g);printf("F(x)=f(x)+g(x)=");f=addPLOY(f,g);//两个多项式相加print(f);sign=-1;//复位标志start();//回复用户选择界面break;}case 2:{printf("你选择的操作是多项式相乘:\n"); f=creat('f');//输入多项式f(x)printf("f(x)=");print(f);g=creat('g');//输入多项式g(x)printf("g(x)=");print(g);printf("F(x)=f(x)*g(x)=");f=byPLOY(f,g);//两个多项式相加print(f);sign=-1;//复位标志start();//回复用户选择界面break;case 3:{printf("你选择的操作是多项式相减:\n");f=creat('f');//输入多项式f(x)printf("f(x)=");print(f);g=creat('g');//输入多项式g(x)printf("g(x)=");print(g);printf("F(x)=f(x)-g(x)=");f=byPLOY(f,g);//两个多项式相加print(f);sign=-1;//复位标志start();//回复用户选择界面break;}default:{printf("输入有误!请重新选择操作!\n");//选择错误,返回选择界面start();break;}}}}。

数据结构多项式相加实验报告

试验一多项式相加一. 实验内容：多项式相加二.实验目的和要求：利用双向链表实现通讯录的建立、删除、检索和列表，并可保存至文件，可重新装入。

用链式存储结构实现一元多项式的相加运算。

三．算法思想描述:1. 以单链表为存储结构插入多项式: 多项式输入：多项式按幂从高到低，以“系数，幂”的格式输入，并以“0，0”结束。

printf("Please input coef:");scanf("%d",&i);printf("Please input exp: ");scanf("%d",&j);while(i!=0){q=(pnode)malloc(sizeof(struct node));q->coef=i;q->exp=j;p->link=q;p=q;printf("Please input coef:");scanf("%d",&i);printf("Please input exp: ");scanf("%d",&j);}p->link=NULL;2. 多项式相加单链表合并:由两个多项式对应的单链表头节点开始，依次扫描各节点。

(1)若两表的节点均非空：比较二者的幂，按幂大者先入表。

如果幂相等，则系数相加再入表。

具体由以下代码实现：while(p!=NULL && q!=NULL){if(p->exp==q->exp){x=p->coef+q->coef;if(x!=0){s=(pnode)malloc(sizeof(struct node));s->coef=x;s->exp=p->exp;r->link=s;r=s;}p=p->link;q=q->link;}else if(p->exp<q->exp){s=(pnode)malloc(sizeof(struct node));s->coef=q->coef;s->exp=q->exp;r->link=s;r=s;q=q->link;}else{s=(pnode)malloc(sizeof(struct node));s->coef=p->coef;s->exp=p->exp;r->link=s;r=s;p=p->link;}(2). 若有一链表已空，则将非空链表插入新表：while(p!=NULL){s=(pnode)malloc(sizeof(struct node));s->coef=p->coef;s->exp=p->exp;r->link=s;r=s;p=p->link;}while(q!=NULL){s=(pnode)malloc(sizeof(struct node));s->coef=q->coef;s->exp=q->exp;r->link=s;r=s;q=q->link;}3. 输出合并后的链表:while(head->link!=NULL){head=head->link;printf(" %d*x^%d",head->coef,head->exp);}4. 主函数调用，完成多项式相加。

数据结构-实验2-多项式求和

数据结构-实验2-多项式求和数据结构实验 2 多项式求和在计算机科学和数学领域中，多项式的操作是一个常见且重要的任务。

本次实验 2 的重点是实现多项式的求和。

首先，让我们来理解一下什么是多项式。

简单来说，多项式就是由变量、系数和运算符组成的表达式。

例如，3x^2 ＋ 2x 1 就是一个多项式，其中 3、2 和－1 是系数，x 是变量，＾2 表示幂次。

那么为什么要进行多项式求和呢？在实际的应用中，我们经常会遇到需要对多个多项式进行运算的情况。

比如在数学建模中，通过对不同的多项式进行求和，可以得到更复杂的数学表达式，从而更准确地描述实际问题。

接下来，我们来探讨一下如何实现多项式的求和。

在数据结构中，有多种方式可以表示多项式。

常见的有顺序表和链表两种方式。

使用顺序表来表示多项式时，我们可以将多项式的每一项的系数和指数存储在数组的相应位置。

比如，数组的第一个元素存储第一项的系数和指数，第二个元素存储第二项的系数和指数，以此类推。

这种方式的优点是随机访问速度快，但是在进行多项式的加法运算时，可能需要移动大量的元素，效率较低。

相比之下，链表的方式则更加灵活。

我们可以为每一项创建一个节点，节点中包含系数、指数和指向下一项的指针。

在进行多项式的加法运算时，只需要遍历链表，根据指数的大小进行相应的操作即可。

下面我们通过一个具体的例子来看看如何进行多项式的求和。

假设有两个多项式：P1(x) ＝ 2x^3 ＋ 3x^2 1 和 P2(x) ＝ x^3 ＋ 2x 5 。

首先，我们创建两个链表分别表示这两个多项式。

然后，同时遍历这两个链表。

在遍历的过程中，比较当前节点的指数大小。

如果两个节点的指数相等，那么将它们的系数相加，创建一个新的节点，其系数为相加后的结果，指数不变，并将其插入到结果链表中。

如果一个节点的指数大于另一个节点的指数，那么将指数较小的节点直接插入到结果链表中，并继续遍历。

如果一个链表遍历完了，而另一个链表还有剩余的节点，那么将剩余的节点直接插入到结果链表中。

数据结构多项式求和

数据结构多项式求和多项式求和是数据结构中的一个重要问题，其中给定一个多项式，我们需要计算它的和。

在本文中，我们将讨论多项式求和的算法和数据结构。

多项式是一个数学表达式，由一系列项组成，每个项由一个系数和一个指数组成。

例如，多项式3x^2 + 2x + 1由三个项组成，分别是3x^2、2x和1。

在多项式求和问题中，我们需要计算给定多项式的所有项的总和。

为了解决多项式求和问题，我们可以使用两种主要的数据结构：链表和数组。

这两种数据结构都可以用来表示多项式，并且具有不同的优势和劣势。

链表是一种动态数据结构，可以方便地插入和删除元素。

在链表中，每个节点包含一个项的系数和指数，并且通过指针连接到下一个节点。

通过遍历链表，我们可以计算多项式的总和。

链表的一个主要优点是它可以适应多项式的大小变化，但它的缺点是访问指定位置的项的效率较低。

数组是一种静态数据结构，具有固定大小。

在数组中，每个元素存储一个项的系数和指数。

通过遍历数组，我们可以计算多项式的总和。

数组的一个主要优点是它可以提供快速的随机访问，但它的缺点是它的大小是固定的，无法适应多项式的大小变化。

基于链表的多项式求和算法如下：1. 创建一个空链表来存储多项式的和。

2. 遍历第一个多项式的链表。

3. 将每个项的系数和指数与第二个多项式的链表中的对应项相加。

4. 将结果项插入和链表中。

5. 遍历第二个多项式的链表，将未处理的项插入和链表中。

6. 返回和链表。

基于数组的多项式求和算法如下：1. 创建一个空数组来存储多项式的和。

2. 遍历第一个多项式的数组。

3. 将每个项的系数和指数与第二个多项式的数组中的对应项相加。

4. 将结果项存储在和数组的对应位置。

5. 遍历第二个多项式的数组，将未处理的项存储在和数组的对应位置。

6. 返回和数组。

无论使用链表还是数组，多项式求和的时间复杂度都是O(n)，其中n是多项式的项数。

但是，链表的空间复杂度是O(n)，而数组的空间复杂度是O(k)，其中k是多项式的最高指数。

多项式相加的函数（数据结构_C语言版）

多项式相加的函数（数据结构_C语言版）一、编写一个程序用单链表存储多项式，并实现两个多项式相加的函数。

【源程序】#include#include#define MAX 20typedef struct{ float coef;int exp;}PolyArray[MAX];typedef struct pnode{ float coef;//系数int exp;//指数struct pnode *next;}PolyNode;void DispPoly(PolyNode *L)//输出多项式{ PolyNode *p=L->next;while(p!=NULL){ printf("%gx^%d",p->coef,p->exp);p=p->next;}printf("\n");}void CreateListR(PolyNode *&L,PolyArray a,int n)//尾插法建立单链表{ PolyNode *s,*r;int i;L=(PolyNode *)malloc(sizeof(PolyNode)); //创建头结点L->next=NULL;r=L; //r始终指向终端结点,开始时指向头结点for (i=0;i<n;i++)< p="">{s=(PolyNode *)malloc(sizeof(PolyNode));//创建新结点s->coef=a[i].coef;s->exp=a[i].exp;r->next=s; //将*s插入*r之后r=s;}r->next=NULL;}void Sort(PolyNode *&head)//按exp域递减排序{ PolyNode *p=head->next,*q,*r;if(p!=NULL){ r=p->next;p->next=NULL;p=r;while(p!=NULL){ r=p->next;q=head;while(q->next!=NULL&&q->next->exp>p->exp)q=q->next;p->next=q->next;q->next=p;p=r;}}}void Add(PolyNode *ha,PolyNode *hb,PolyNode *&hc)//求两个有序集合的并{PolyNode *pa=ha->next,*pb=hb->next,*s,*tc;float c;hc=(PolyNode *)malloc(sizeof(PolyNode));tc=hc;while(pa!=NULL&&pb!=NULL){ if(pa->exp>pb->exp){ s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=pa->coef;tc->next=s;tc=s;pa=pa->next;}else if(pa->expexp){ s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pb->exp;s->coef=pb->coef;tc->next=s;tc=s;pb=pb->next;}else{ c=pa->coef+pb->coef;if(c!=0)//系数之和不为0事创建新结点{ s=(PolyNode *)malloc(sizeof(PolyNode));s->exp=pa->exp;s->coef=c;tc->next=s;tc=s;}pa=pa->next;pb=pb->next;}}if(pb!=NULL)pa=pb;//复制余下的结点while(pa!=NULL){ s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=pa->coef;tc->next=s;tc=s;pa=pa->next;}tc->next=NULL;}void main(){PolyNode *ha,*hb,*hc;PolyArray a={{1.5,0},{2.5,1},{3.3,3},{-2.5,5}};PolyArray b={{-1.5,0},{2.5,1},{3.7,3},{-2.5,5},{5.6,7}};CreateListR(ha,a,4);CreateListR(hb,b,5);printf("原多项式A为：");DispPoly(ha);printf("原多项式B为：");DispPoly(hb);Sort(ha);Sort(hb);printf("有序多项式A：");DispPoly(ha);printf("有序多项式B：");DispPoly(hb);Add(ha,ha,hc);printf("多项式相加结果：");DispPoly(hc); printf("\n");}</n;i++)<>。