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

一元多项式的加法数据结构一元多项式是数学中常见的一种代数表达式形式,由多个单项式按照一定的规则相加而成。
在计算机科学中,为了方便对一元多项式进行处理,需要定义一种合适的数据结构来表示和操作一元多项式的加法运算。
一元多项式的加法数据结构可以使用链表来实现。
每个节点表示一个单项式,包含两个成员变量:系数和指数。
系数表示单项式的系数,指数表示单项式的指数。
通过将多个单项式的系数和指数组织成一个链表,即可表示一个一元多项式。
在链表中,每个节点按照指数从小到大的顺序排列。
这样可以方便进行多项式的加法运算。
当两个一元多项式相加时,只需按照指数的大小依次比较两个链表中的节点,并根据指数的大小关系进行相应的操作。
具体的加法算法如下:1. 创建一个新的链表作为结果链表。
2. 初始化两个指针分别指向两个原始链表的头节点。
3. 循环比较两个链表中的节点,直到其中一个链表遍历完为止。
4. 比较当前节点的指数大小关系:- 如果两个节点的指数相等,将它们的系数相加,并将结果添加到结果链表中。
- 如果第一个链表中的节点指数较小,将第一个链表的节点添加到结果链表中,并将指针指向下一个节点。
- 如果第二个链表中的节点指数较小,将第二个链表的节点添加到结果链表中,并将指针指向下一个节点。
5. 当其中一个链表遍历完后,将另一个链表中剩余的节点依次添加到结果链表中。
6. 返回结果链表作为两个一元多项式相加的结果。
通过上述算法,可以实现对一元多项式的加法运算。
这种链表结构的一元多项式加法数据结构具有以下优点:- 灵活性:可以表示任意长度的一元多项式,不受固定数组长度的限制。
- 高效性:在添加节点和遍历节点时,时间复杂度为O(n),其中n 为一元多项式的项数。
- 可扩展性:可以方便地扩展其他操作,如乘法、求导等。
除了链表结构,还可以使用数组等数据结构来表示一元多项式的加法。
不同的数据结构适用于不同的应用场景。
链表结构适合于插入和删除操作较多的情况,而数组结构适合于随机访问和内存占用较小的情况。
数据结构——一元多项式的建立与相加

#include <cmath>
using namespace std;
typedef struct PolyNode
{
int coef; //系数
int expn; //指数
struct PolyNode *next;
} *PNode; //多项式结点的指针
void InitPoly(PNode &head,PNode &p)
{
int n;
PNode s,p;
pa=pa->next;
pb=pb->next;
p=pc;
while (pa!=NULL && pb!=NULL)
{
if (pa->expn>pb->expn)
{
s=(PNode)malloc(sizeof(struct PolyNode));
s->coef=pa->coef;
{
if(i) //显示第一对的时候是不需要显示加号的
{
if (p->expn==1) cout<<p->coef<<"x";
else if (p->expn==0) cout<<p->coef<<endl;
else cout<<p->coef<<"x^"<<p->expn;
i=0;
}
else
{
if (p->expn==1) cout<<p->coef<<"+x";
数据结构C语言实现之一元多项式的表示及相加(2)

数据结构 C 语言实现之一元多项式的表示及相加(2)
一元多项式的表示及相加 对于符号多项式的各种操作,实际上都可以利用线性表来处理。比较典型的是关于一元多项式的处理。在
} } e>next; /*将 q 结点加入到和多项式中*/ q =q->next; } }
} if(p!=NULL)/*多项式 A 中还有剩余,则将剩余的结点加入到和多项式中*/
pre->next=p;
else /*否则,将 B 中的结点加入到和多项式中*/ pre->next=q; }
算法 2.24 多项式相加 假设 A 多项式有 M 项,B 多项式有 N 项,则上述算法的时间复杂度为 O(M+N) 图 2.20 所示为图 2.19 中两个多项式的和,其中孤立的结点代表被释放的结点。
通过对多项式加法的介绍,我们可以将其推广到实现两个多项式的相乘,因为乘法可以分解为一系列的加 法运算。
“中的结点无需另生成,则可看成是将多项式 B 加到多项式 A 中,由此得到下列运算规则(设 p、q 分别 指向多项式 A,B 的一项,比较结点的指数项)
若 p->exp< q->exp,则结点 p 所指的结点应 是“和多项式”中的一项,令指针 p 后移;若 p>exp>q->exp,则结点 q 所指的结点应是“和多项式”中的一项,将结点 q 插入在结点 p 之前, 且令指针 q 在原来的链表上后移;
(1)用单链表存储多项式的结点结构如下: struct Polynode { int coef; int exp; Polynode *next; } Polynode , * Polylist;
线性表——一元多项式的求和

线性表——⼀元多项式的求和♥注:未经博主同意,不得转载。
多项式的表⽰与求和是线性表应⽤的典型案列。
在数学上,⼀元多项式P(x)的表⽰为:P(x)=a0+a1x+a2x2+…+anxn其中,n为⼤于或等于0的整数,表⽰x的幂:a o,a1,…a n为系数,a n≠0,a0,a1,…,a n-1可以为0,也可以不为0。
⼀元多项式的表⽰ 为了表⽰⼀元多项式,可以将其所有项的系数⽤⼀个线性表来表⽰:(a0,a1,…,a n)。
这个线性表可以使⽤顺序存储结构或链式存储结构来存储,从⽽进⾏多项式的有关运算。
若采⽤顺序存储结构,可使⽤⼀个⼀维数组存储这个线性表,即多项式的系数,⽽相应的幂则使⽤数组下标来表⽰。
⼀元多项式的顺序存储结构如下:1 typedef int DataType;2const int MaxPolySize=100;34class Polyn5 {6private:7 DateType data[MaxPolySize];8int size; //元素的个数910public:11 Polyn(){size = 0;} //构造⼀个空多项式12 ~Polyn();1314void Clear(){size=0;} //清空15 Polyn sum(Polyn a); //多项式相加16 Polyn sub(Polyn a); //多项式相减17 }; 但多项式的顺序存储有⼀个缺点:当存储形如P(x)=1+10x99的多项式时,由于a1到a98均为0,所以⽤来存储⼀元多项式的⼀维数组中的绝⼤部分单元存储的值都是0,导致存储效率低下,造成存储空间的浪费。
因此,⼀般采⽤链式存储结构来描述⼀元多项式。
⼀元多项式的链式存储必须显式地表达系数值和幂值,这是由于链式存储打破了顺序存储中原有的幂与数组下标间的⼀⼀对应关系,⼀元多项式的项的结点结构表⽰如图所⽰。
⼀元多项式的链式存储结构表⽰如下:12struct term3 {4double coef; //系数5int expn; //指数6 };7struct PNode8 {9 term data;10 PNode *next;11 };12class Ployn13 {14 PNode *phead;15public:16 Polyn()17 { //构造函数18 phead =new PNoed;19if(phead= =NULL)20 exit(0);21 phead->next=NULL;22 }23 ~Polyn(); //析构函数2425void PolynAdd(Ployn Pa,Ployn Pb); //两个多项式相加26void Print(); //打印多项式27void Create(); //建⽴多项式28 };29⼀元多项式的求和 本节以多项式的加法为例,讲述⼀元多项式操作的实现。
一元多项式的加法数据结构

一元多项式的加法数据结构一元多项式是数学中常见的一种表达形式,它可以表示为各个项的和,每个项由一个系数和一个幂次组成。
在实际应用中,一元多项式的加法操作非常常见,因此设计一个高效的数据结构来表示和计算一元多项式的加法是非常重要的。
在一元多项式的加法操作中,我们需要考虑的主要问题有两个:一是如何存储一元多项式的各个项,二是如何进行多项式的加法运算。
对于第一个问题,我们可以使用链表来存储一元多项式的各个项。
链表的每个节点可以表示一个多项式的项,其中包含两个数据成员:一个表示系数的值,一个表示幂次的值。
通过链表的链接关系,可以按照幂次的从小到大的顺序存储一元多项式的各个项,从而方便后续的加法运算。
对于第二个问题,我们可以设计一个函数来实现一元多项式的加法运算。
该函数接受两个参数,分别是待相加的两个一元多项式。
在函数内部,我们需要遍历两个链表,按照幂次的大小比较来确定相应的操作。
具体的步骤如下:1. 创建一个新的链表,用于存储相加后的结果。
2. 初始化两个指针,分别指向两个待相加的链表的头节点。
3. 进行循环遍历,直到两个链表均为空。
4. 比较两个链表当前节点的幂次大小。
- 若幂次相等,则将两个节点的系数相加,并将结果插入到新链表中。
- 若幂次不等,则将系数较小的节点插入到新链表中,并将指针指向下一个节点。
5. 遍历完其中一个链表后,将另一个链表剩余的节点依次插入到新链表中。
6. 返回新链表作为相加后的结果。
通过上述的设计,我们可以实现一元多项式的加法操作。
这种数据结构的好处是可以有效地存储一元多项式的各个项,并且在进行加法运算时可以按照幂次的大小进行有序操作,从而提高了计算效率。
除了加法操作,一元多项式的数据结构还可以支持其他常见的操作,例如减法、乘法、求导等。
这些操作可以通过类似的方式进行设计和实现,只需根据具体的需求进行相应的调整即可。
一元多项式的加法是数学中常见的操作,设计一个高效的数据结构来表示和计算一元多项式的加法对于数学计算和实际应用都具有重要意义。
c语言数据结构实现——一元多项式的基本运算

文章标题:深入理解C语言中的数据结构实现——一元多项式的基本运算在C语言中,数据结构是非常重要的一个概念,它为我们处理各种复杂的数据提供了便利。
其中,一元多项式的基本运算是数据结构中的一个重要内容,它涉及到多种数据结构的操作和算法,是我们学习C 语言中数据结构的一个重要入口。
在本文中,我们将深入探讨C语言中一元多项式的基本运算,帮助读者更深入地理解这一重要的概念。
一、一元多项式的表示方式在C语言中,一元多项式可以使用数组来表示。
每个数组元素对应一个项,数组的下标对应每一项的次数,数组的值对应该项的系数。
一个一元多项式可以表示为:```cfloat polynomial[10] = {0, 1, 2, 0, 4}; // 表示多项式 1 + 2x + 4x^4 ```二、一元多项式的基本运算1. 一元多项式的加法有两个多项式 A 和 B,它们分别表示为 `float polynomialA[10]` 和`float polynomialB[10]`,那么它们的加法运算可以表示为:```cfor (int i = 0; i < 10; i++) {polynomialC[i] = polynomialA[i] + polynomialB[i];}```2. 一元多项式的减法一元多项式的减法是指将两个多项式相减得到一个新的多项式。
与加法类似,多项式 A 和 B 的减法运算可以表示为:```cfor (int i = 0; i < 10; i++) {polynomialC[i] = polynomialA[i] - polynomialB[i];}```3. 一元多项式的乘法式 A 和 B 的乘法运算可以表示为:```cfor (int i = 0; i < 10; i++) {for (int j = 0; j < 10; j++) {polynomialC[i+j] += polynomialA[i] * polynomialB[j];}}```4. 一元多项式的除法一元多项式的除法涉及到较为复杂的算法,需要考虑余数和商的处理。
数据结构一元多项式的运算

数据结构一元多项式的运算正文: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 一元多项式的乘法一元多项式的乘法是指将两个多项式相乘,并合并同类项。
具体操作如下:- 遍历一个多项式的每一项,与另一个多项式的每一项相乘。
数据结构-实验一-一元多项式相加

数据结构实验报告实验一:一元多项式相加姓名:周成学号: 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", ¤t->coef, ¤t->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.实验总结本来我对编程很没有信心,做这样一个课程设计感觉有点吃力,虽然有些人觉得很简单,但是我还是坚持做下来了,我不断的看书,翻阅资料,询问同学,上网搜索,总算有模有样地把这个程序编的能运行了。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验一一元多项式的表示与相加实验目的: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;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->next;}if(p)return(1);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);}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=p1;}while(q){q1=q->next;caseinsert(lc,q);q=q1;}}11)将减项多项式转化为系数为相反数的多项式便于转化为加法运算void reverse(Linklist &l){Linklist p;p=l->next;while(p){p->cof*=-1;p=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(" I nput 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(" I nput 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(" I nput 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语言有些生疏和遗忘,在编程过程中出现很多错误。