线性表应用---多项式计算

合集下载

DS线性表--多项式相加

Description对于一元多项式p(x)=p0+p1x+p2x2+ …+p n x n，每个项都有系数和指数两部分，例如p2x2的系数为p2,指数为2编程实现两个多项式的相加例如5+x+2x2+3x3，-5-x+6x2+4x4，两者相加结果：8x2+3x3+4x4其中系数5和-5都是x的0次方的系数，相加后为0，所以不显示。

x的1次方同理不显示。

可用顺序表或单链表实现Input第1行：输入t表示有t组测试数据第2行：输入n表示有第1组的第1个多项式包含n个项第3行：输入第一项的系数和指数，以此类推输入n行接着输入m表示第1组的第2个多项式包含m项同理输入第2个多项式的m个项的系数和指数参考上面输入第2组数据，以此类推输入t组假设所有数据都是整数Output对于每1组数据，先用两行输出两个原来的多项式，再用一行输出运算结果，不必考虑结果全为0的情况输出格式参考样本数据，格式要求包括：1.如果指数或系数是负数，用小括号括起来2.如果系数为0，则该项不用输出3.如果指数不为0，则用符号^表示，例如x的3次方，表示为x^34.多项式的每个项之间用符号+连接，每个+两边加1个空格隔开Sample Input245 01 12 23 34-5 0-1 16 24 43-3 0-5 12 249 -12 03 1-2 2Sample Output5 + 1x^1 + 2x^2 + 3x^3(-5) + (-1)x^1 + 6x^2 + 4x^4 8x^2 + 3x^3 + 4x^4(-3) + (-5)x^1 + 2x^29x^(-1) + 2 + 3x^1 + (-2)x^2 9x^(-1) + (-1) + (-2)x^1。

数据结构线性表多项式加减实验报告

数据结构实验报告实验名称：实验一——线性表日期：2013年10月28日1．实验要求实验目的1、熟悉C++语言的基本编程方法，掌握集成编译环境的调试方法2、学习指针、模板类、异常处理的使用3、掌握线性表的操作的实现方法4、学习使用线性表解决实际问题的能力实验内容利用线性表实现一个一元多项式Polynomialf(x) = a0 + a1x + a2x2 + a3x3+ … + a n x nPolynomial的结点结构如下：struct term{float coef; //系数int expn; //指数};要求：1、能够实现一元多项式的输入和输出2、能够进行一元多项式相加3、能够进行一元多项式相减4、能够计算一元多项式在x处的值5、能够计算一元多项式的导数（选作）6、能够进行一元多项式相乘（选作）7、编写测试main()函数测试线性表的正确性2. 程序分析考虑到数据结构的实现，因为多项式是线性结构因此选择线性表，而本次实验中涉及到多项式的加减，要进行节点的添加或者删除，用顺序表显然不能满足要求，而且由于不知道多项式的项数，很容易造成空间的浪费，当两个多项式指数相差很远时，操作要移动很多项，步骤很麻烦繁琐。

综上，我选择了单链表，每个节点有三个部分，分别储存系数、指数、和指针，这样在计算加减或者指数不等时，只需要简单的摘连加链即可，而且不会造成空间的太多浪费。

每次利用尾插法将结点插入基准多项式。

2.1 存储结构本次实验采取的多项式加减算法是将一个多项式作为基准，把另一个多项式加到基准多项式中去，求和后的多项式仍然存储在第一个线性表中，因此用单链表的数据结构更为方便。

单链表存储结构在本次实验中，因为形式的特殊性，每个节点如下图表示：空链表非空链表其中每个结点前两个分别储存float 型系数coef 和int 型指数expn ，第三个作为指针指向下一个节点（不是最后一个结点时，否则为NUll ）2.2 关键算法分析1、输入多项式自然语言描述：1) 指定多项式的项数n2) 建立一个叫term 的struct 结构类型，用来储存指定多项式的系数和指数的数据。

云南大学软件学院数据结构实验二实验报告——多项式计算器

云南大学软件学院数据结构实验报告2010秋季学期（本实验项目方案受“教育部人才培养模式创新实验区（X3108005）”项目资助）学号：姓名：专业：指导老师：实验难度A□B□ C □承担任务（难度为C时填写）指导教师评分（签名）【实验题目】实验2. 线性表及其应用【问题描述】用C或C++语言设计并实现一个一元稀疏多项式的简单计算器。

【基本要求】一元稀疏多项式简单计算器的基本功能是：1、输入并建立多项式2、输出多项式，序列按指数降序排列3、多项式A(x)和B(x)相加，并建立多项式A(x)+B(x)4、多项式A(x)和B(x)相减，并建立多项式A(x)-B(x)5、给定 x 的值，计算多项式6、多项式A(x)和B(x)相乘，建立多项式A(x)*B(x) （* 选做，作为难度B的操作）【CDIO项目要求】1、有完整的CDIO四个阶段描述2、有友好美观的操作界面3、有软件使用说明或帮助文档4、项目成员分工明确，团结协作【实现提示】一、【实验构思（Conceive）】(10%)本实验通过C语言实现了多项式加法、减法、乘法、多项式求导、多项式积分的功能。

利用了冒泡排序的算法作为排序的核心算法。

运用了高等数学中多项式的求导积分的知识。

二、【实验设计(Design)】(15%)本程序定义了抽象数据结构listnode，用于存储多项式的系数和指数并存储指向下一个listnode的指针来构成链表。

本程序包含如下*个函数：Main函数：调用input函数—>调用bubble_sort函数—>调用operplus函数—>调用oper_minus函数—>调用oper_mul函数—>调用oper_dy函数—>调用oper_jifen 函数。

Oper_plus函数：将两个链表的相应项系数相加，指数不同项不操作，存入新链表，再调用排序算法，使之为降序排列。

Oper_minus函数：将两个链表的相应项系数相减，指数不同项不操作，存入新链表，再调用排序算法，使之为降序排列。

线性表——一元多项式的求和

线性表——⼀元多项式的求和♥注：未经博主同意，不得转载。

多项式的表⽰与求和是线性表应⽤的典型案列。

在数学上，⼀元多项式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．掌握线性表的典型应用----多项式表示与计算。

二. 实验内容1．设用线性表( (a1, e1), (a2, e2), ……, (am, em) ) 表示多项式P(x) = a1*x e1 + a2*x e2+…+ am*x em，其中：a1～am为非零系数，0≤e1＜e2＜…..＜em，请编写用链式存储结构（带表头附加结点的单链表）存储该多项式时，多项式基本操作的实现函数。

多项式基本操作应包括初始化多项式、清除多项式、输出多项式、插入一项、删除一项、多项式求值、多项式相加等。

要求：把多项式线性表的结构定义及多项式基本操作实现函数存放在头文件Linkpoly.h中，主函数存放在主文件test6_1.cpp中，在主函数中通过调用Linkpoly.h中的函数进行测试。

2．选做：编写用顺序存储结构存储多项式时，多项式基本操作的实现函数。

要求：把多项式线性表的结构定义及多项式基本操作实现函数存放在文件Seqpoly.h中，在主文件test6_1.cpp中增加测试语句对Seqpoly.h中的函数进行测试。

3．填写实验报告，实验报告文件取名为report1.doc。

4．上传实验报告文件report1.doc与源程序文件test6_1.cpp及Linkpoly.h、Seqpoly.h（若有）到Ftp服务器上自己的文件夹下。

三. 函数的功能说明及算法思路typedef struct{double coef;int exp;}ElemType;typedef struct Node{ElemType data;struct Node *next;}LNode;//初始化多项式void InitPoly(LNode *&H)//清除多项式void ClearPoly(LNode *&H)//输出多项式void TraversePoly(LNode *H)//插入一项多项式bool InsertPoly(LNode *H,int pos,double a,int e) {if(pos==0) //按指数有序插入{……}else //按pos值插入{……}}//删除一项多项式bool DeletePoly(LNode* H,int pos,double &a, int &e) {if(pos==0) //按系数或指数删除{……}else //按pos值删除{……}}//多项式求值double PolySum(LNode *H,double x)//多项式相加LNode *PolyAdd(LNode *a,LNode *b){while(pa!=a&&pb!=b)//当两个表同时不为空时{if(pa->data.exp==pb->data.exp){if((v=pa->data.coef+pb->data.coef)!=0){……}}else if(pa->data.exp<pb->data.exp)//将pa所指结点插入c链表{}else//将pb所指结点插入c链表{}}while(pa!=a)//将a链表中剩余结点复制到c链表{}while(pb!=b) //将b链表中剩余结点复制到c链表{}}四. 实验结果与分析五. 心得体会【附录----源程序】test6_1.cpp#include<stdio.h>#include<iostream.h> #include<stdlib.h> typedef struct{double coef;int exp;}ElemType;typedef struct Node{ ElemType data;struct Node *next; }LNode;#include"LinkPoly.h"void main(){LNode *a,*b,*c;//初始化InitPoly(a);InitPoly(b);ElemType ra[4]={{5,0},{3,2},{-6,3},{2,5}};ElemType rb[6]={{3,0},{4,1},{-2,2},{3,3},{-2,5},{9,6}};int i;for(i=3;i>=0;i--)InsertPoly(a,1,ra[i].coef,ra[i].exp);for(i=5;i>=0;i--)InsertPoly(b,1,rb[i].coef,rb[i].exp);//遍历cout<<"Poly_A(x)=";TraversePoly(a);cout<<endl;cout<<"Poly_B(x)=";TraversePoly(b);cout<<endl;//求和cout<<"多项式Poly_A与多项式Poly_B相加得："<<endl;c=PolyAdd(a,b);cout<<"Poly_C(x)=";TraversePoly(c);cout<<endl;int pos;char u,v,w;ElemType T;//插入cout<<"按指数有序插入一项多项式："<<endl;cout<<"请输入待插入项：";cin>>u>>T.coef>>v>>T.exp>>w;if(InsertPoly(c,0,T.coef,T.exp)){cout<<endl<<"插入后，多项式Poly_C为："<<endl;cout<<"Poly_C(x)=";TraversePoly(c);}cout<<endl;cout<<"按pos值插入一项多项式："<<endl;cout<<"请输入pos值：";cin>>pos;cout<<"请输入待插入项：";cin>>u>>T.coef>>v>>T.exp>>w;if(InsertPoly(c,pos,T.coef,T.exp)){cout<<endl<<"插入后，多项式Poly_C为："<<endl;cout<<"Poly_C(x)=";TraversePoly(c);}cout<<endl;//删除cout<<"请输入待删除项的pos值：";cin>>pos;if(DeletePoly(c,pos,T.coef,T.exp)){cout<<"删除项为"<<"{"<<T.coef<<","<<T.exp<<"}"<<endl<<endl;cout<<"删除后，多项式Poly_C为："<<endl;cout<<"Poly_C(x)=";TraversePoly(c);}cout<<endl;cout<<"请输入待删除项的系数：";cin>>T.coef;if(DeletePoly(c,0,T.coef,T.exp)){cout<<"删除项为"<<"{"<<T.coef<<","<<T.exp<<"}"<<endl<<endl;cout<<"删除后，多项式Poly_C为："<<endl;cout<<"Poly_C(x)=";TraversePoly(c);}cout<<endl;cout<<"请输入待删除项的指数：";cin>>T.exp;if(DeletePoly(c,0,T.coef,T.exp)){cout<<"删除项为"<<"{"<<T.coef<<","<<T.exp<<"}"<<endl<<endl;cout<<"删除后，多项式Poly_C为："<<endl;cout<<"Poly_C(x)=";TraversePoly(c);}cout<<endl;//求值double x;cout<<"请输入待求值的x：";cin>>x;cout<<"Poly_C(x)="<<PolySum(c,x)<<endl<<endl;//清除ClearPoly(a);ClearPoly(b);ClearPoly(c);}Linkpoly.h//初始化多项式void InitPoly(LNode *&H){if((H=new LNode)==NULL)exit(0);H->next=H;}//清除多项式void ClearPoly(LNode *&H){LNode *cp=H->next;LNode *np;while(cp!=H){np=cp->next;delete cp;cp=np;}H->next=H;}//输出多项式void TraversePoly(LNode *H){LNode *p=H->next;if(p!=H){cout<<p->data.coef<<'x'<<'^'<<p->data.exp;p=p->next;while(p!=H){if(p->data.coef>0)cout<<'+';cout<<p->data.coef<<'x'<<'^'<<p->data.exp;p=p->next;}}cout<<endl;}//插入一项多项式bool InsertPoly(LNode *H,int pos,double a,int e){LNode *newptr;if((newptr=new LNode)==NULL)return false;newptr->data.coef=a;newptr->data.exp=e;LNode *cp=H->next;LNode *ap=H;if(pos==0){while(cp!=H){if(e>ap->data.exp&&e<cp->data.exp)break;else if(e==cp->data.exp){cp->data.coef+=a;return true;}else{ap=cp;cp=cp->next;}}newptr->next=cp;ap->next=newptr;}else{int i=0;while(cp!=H){i++;if(i==pos)break;else{ap=cp;cp=cp->next;}}if(cp==H&&i+1<pos){cout<<"pos值无效！"<<endl;return false;}newptr->next=cp;ap->next=newptr;}return true;}//删除一项多项式bool DeletePoly(LNode* H,int pos,double &a, int &e) {if(H->next==H)return false;LNode *cp=H->next;LNode *ap=H;if(pos==0){while(cp!=H){if(a==cp->data.coef||e==cp->data.exp)break;else{ap=cp;cp=cp->next;}}if(cp==H){cout<<"不存在符合条件的项！"<<endl;return false;}}else{int i=0;while(cp!=H){i++;if(i==pos)break;else{ap=cp;cp=cp->next;}}if(cp==H){cout<<"pos值无效！"<<endl;return false;}}a=cp->data.coef;e=cp->data.exp;ap->next=cp->next;delete cp;return true;}//多项式求值double PolySum(LNode *H,double x){int i=0;double sum=0,w=1;LNode *p=H->next;while(p!=H){while(i<p->data.exp){w*=x;i++;}sum+=p->data.coef*w;p=p->next;}return sum;}//多项式相加LNode *PolyAdd(LNode *a,LNode *b){double v;LNode *c;InitPoly(c);LNode *pc=c,*pa=a->next,*pb=b->next;while(pa!=a&&pb!=b){if(pa->data.exp==pb->data.exp){if((v=pa->data.coef+pb->data.coef)!=0){InsertPoly(pc,1,v,pa->data.exp);pc=pc->next;}pa=pa->next;pb=pb->next;}else if(pa->data.exp<pb->data.exp){InsertPoly(pc,1,pa->data.coef,pa->data.exp);pc=pc->next;pa=pa->next;}else{InsertPoly(pc,1,pb->data.coef,pb->data.exp);pc=pc->next;pb=pb->next;}}while(pa!=a){InsertPoly(pc,1,pa->data.coef,pa->data.exp);pc=pc->next;pa=pa->next;}while(pb!=b){InsertPoly(pc,1,pb->data.coef,pb->data.exp);pc=pc->next;pb=pb->next;}return c;}。

数据结构《线性表的应用》实验报告

实验报告——线性表应用一、实验目的用单链表储存一元多项式，并实现两个多项式的相加运算。

二、实验内容1.先创建链表，存储多项式；2.输出多项式；3.两个多项式相加；4.输出多项式。

三、程序代码#include <stdio.h>#include <stdlib.h>#include <math.h>//一元多项式链式储存的节点结构typedef struct Polynode{float coef;int exp;struct Polynode * next;} Polynode , * Polylist;//建立一元多项式的链表Polylist polycreate(){Polynode * head,* rear,* s;float c;int e;head=(Polynode* )malloc(sizeof(Polynode));rear=head;scanf("%f,%d",&c,&e);while(c!=0){s=(Polynode * )malloc(sizeof(Polynode));s->coef=c;s->exp=e;rear->next=s;rear=s;scanf("%f,%d",&c,&e);}rear->next=NULL;return(head);}//输出多项式void print(Polynode*L){Polynode*p;p=L->next;printf("a=");if(p&&p->coef!=0)printf("%.2f*x^%d",p->coef,p->exp);while(p->next!=NULL){if((p->next->coef)>0&&p)printf("+");elseprintf("-");p=p->next;printf("%.2f*x^%d",fabs(p->coef),p->exp);}}//多项式相加void polyadd(Polylist polya,Polylist polyb){Polynode*p,*q,*tail,*temp;int sum;p=polya->next;q=polyb->next;tail=polya;while (p!=NULL&&q!=NULL){if(p->exp<q->exp){tail ->next=p; tail=p;p=p->next;}else if (p->exp==q->exp);{sum=p->coef+q->coef;if(sum!=0){p->coef=sum;tail->next=p;tail=p;p=p->next;temp=q;q=q->next;free(temp);}else{temp=p;p=p->next;free(temp);temp=q;q=q->next;free(temp);}}{tail ->next=q;tail=q;q=q->next;}}if(p!=NULL)tail->next=p;elsetail->next=q;}void main(){Polynode*a,*b;printf("输入a的系数和指数:\n");a = polycreate();print(a);printf("\n");printf("输入b的系数和指数:\n");b = polycreate();print(b);printf("\n");polyadd(a,b);printf("两个多项式的和为:\n");print(a);}四、实验结果五、实验过程中遇到的问题及处理方法程序运行时，在中文状态下输入“，”回车后就不能再输入了，应在英文状态下输入“,”。

应用线性表实现多元式的加减法

课程设计题目：应用线性表实现多元式的加减法姓名：学号：学院：班级：目录一．程序设计思路二．程序源代码三．运行截图一．程序设计思路1.什么是线性表线性表（linear list）是数据结构的一种，一个线性表是n 个具有相同特性的数据元素的有限序列。

数据元素是一个抽象的符号，其具体含义在不同的情况下一般不同。

在稍复杂的线性表中，一个数据元素可由多个数据项（item）组成，此种情况下常把数据元素称为记录（record），含有大量记录的线性表又称文件（file）。

线性表中的个数n定义为线性表的长度，n=0时称为空表。

在非空表中每个数据元素都有一个确定的位置，如用ai表示数据元素，则i称为数据元素ai在线性表中的位序。

线性表的相邻元素之间存在着序偶关系。

如用（a1，…，ai-1，ai，ai+1，…，an）表示一个顺序表，则表中ai-1领先于ai，ai领先于ai+1，称ai-1是ai的直接前驱元素，ai+1是ai的直接后继元素。

当i=1,2，…，n-1时，ai有且仅有一个直接后继，当i=2，3，…，n时，ai有且仅有一个直接前驱 [1] 。

2.线性表的顺序存储实现3.线性表的顺序结构定义4.线性表的顺序结构初始化5.用线性表实现一元多项式加减法思路将一元多项式存储为链式结构的线性表，表中数据元素存储有两个数据项（系数项和指数项）。

其中，线性表按照指数升序存储。

分别用Pa和Pb表示两个一元多项式。

Pa=Pa+Pb，“和多项式”链表中的结点无需另生成，而应该是从两个多项式的链表中摘取。

其运算规则如下：假设指针qa和qb分别指向A，两个多项式中当前进行比较的某个结点，则比较两个结点中的指数项，有下列3种情况：1指针qa所指结点的指数值小于指针qb所指结点的指数值，则应摘取qa所指的结点插入到“和多项式”链表中去；2指针qa所指结点的指数值大于指针qb所指结点的指数值，则应摘取qb所指的结点插入到“和多项式”链表中去；3指针qa所指结点的指数值等于指针qb所指结点的指数值，则应将两个结点的系数项相加，若和数不等于零，则修改qa所指结点的系数值，同时释放qb所指的结点，反之，从多项式A的链表中删除相应的结点，并且释放qa,qb所指结点。

线性表及其应用-一元稀疏多项式的加法运算

{if(p->zhishu==1)printf("x");
else printf("x^%d",p->zhishu);
}
else if(p->xishu==-1) //系数为-1时输出-X^zhishui或-x
{if(p->zhishu==1)printf("-x");
else printf("-x^%d",p->zhishu);
}
else if(p->xishu>0) //系数大于0时
}
else if(p->xishu==-1)
{if(p->zhishu==1)printf("-x");
else printf("-x^%d",p->zhishu);
{
if(p->zhishu==0) //当指数为时，只输出系数xishu
printf("%d",p->xishu);
else if(p->xishu==1) //系数为1时输出X^zhishui或x
}
else if(p->xishu==1)
{if(p->zhishu==1)printf("+x");
else printf("+x^%d",p->zhishu);
}
else{ //多项式的其余项都前带符号输出
if(p->zhishu==0)
{if(p->xishu!=0)
printf("+%d",p->xishu);

线性表的链式存储,多项式的加减乘除四则运算报告

多项式实验报告2011-4-9实验题目：一元多项式的表示及四则运算实验目的：1.了解线性表的链式存储结构，熟悉掌握链表2.了解作为链表的多项式存储方式3.熟悉掌握多项式加减乘除四则运算的算法实验内容:一、抽象数学模型：ADT Polynomial{数据对象：D={ai|ai∈TermSet,i=1,2,···，m, m>=0TermSet中的每个元素包含一个表示系数的实数和表示指数的整数} 数据关系：R1={<ai-1,ai>|ai-1,ai∈D,且ai-1中的指数值<ai中的指数值，i=2,···，n}基本操作：Insert(p,h);初始条件：多项式p与h已存在操作结果：合并指数相同的项CreatePolyn(& head, m)操作结果：建立一个头指针为head、项数为m的一元多项式DestroyPolyn(& p)初始条件：一元多项式P已存在操作结果：销毁多项式pPrintPolyn( P)初始条件：一元多项式P已存在操作结果：打印输出一元多项式PAddPolyn(&pa,& pb)初始条件：一元多项式Pa和Pb已存在操作结果：求解并建立多项式Pa=Pa+Pb, 返回其头指针SubtractPolyn(& pa，& pb)初始条件：一元多项式Pa和Pb已存在操作结果：求解并建立多项式Pa=Pa-Pb，返回其头指针MultiplyPolyn(& pa,& pb)初始条件：一元多项式Pa和Pb已存在操作结果：求解并建立多项式Pa=Pa*Pb，返回其头指针DevicePolyn(& pa,& pb)初始条件：一元多项式Pa和Pb已存在操作结果：求解并建立多项式Pa=Pa/Pb，返回其头指针}ADT Polynomial二、算法描述：为了实现上述程序功能，根据一元多项式的特点，可以构造链式存储的线性表存放一元多项式各式的信息。

(完整word版)链表线性结构(多项式的加减乘除)

哈尔滨工业大学计算机科学与技术学院实验报告课程名称：数据结构与算法课程类型：必修实验项目：线性结构及其应用实验题目：多项式的加减乘除和特定值带入实验日期：2017/11/5班级：1603001学号：**********姓名：***一、实验目的设计线性表的链式存储结构，并实现一元多项式的代数运算。

二、实验要求及实验环境（1）实验要求：以链表存储一元多项式，在此基础上完成对多项式的代数操作。

1.能够输入多项式（可以按各项的任意输入顺序，建立按指数降幂排列的多项式）和输出多项式（按指数降幂排列）,以文件形式输入和输出，并显示。

2.能够计算多项式在某一点 x=x0 的值，其中 x0 是一个浮点型常量，返回结果为浮点数。

3.能够给出计算两个多项式加法、减法、乘法和除法运算的结果多项式，除法运算的结果包括商多项式和余数多项式。

4.要求尽量减少乘法和除法运算中间结果的空间占用和结点频繁的分配与回收操作。

（提示：利用循环链表结构和可用空间表的思想，把循环链表表示的多项式返还给可用空间表，从而解决上述问题）。

（2）实验环境：windows下的CB;三、设计思想（本程序中的用到的所有数据类型的定义，主程序的流程图及各程序模块之间的调用关系）1．逻辑设计:struct polynode{int coef;int exp;struct polynode * link;};//建立链表typedef struct polynode poly;poly* Attch(int c,int e,poly *d);//多项式插入poly *newPoly();//新链表poly *padd(poly *p1,poly *p2);//多项式加法poly *pmul(poly *p1,poly *p2);//乘法poly *inputPoly();//输入多项式poly *psub(poly *p1,poly *p2);//减poly *pdiv(poly *p1,poly *p2);//除poly *inputPoly1();double caculate(double x,poly *p);//计算多项式void sortPoly(poly *p);//多项式排序void outputPoly(poly*p);//输出多项式void delPoly(poly*p);//清空多项式2．物理设计：四、测试结果五、经验体会与不足不能连续输入多个多项式函数设计不够简洁算法过于直接简单加注释后修改代码方便六、附录：源代码（带注释）#include <stdio.h>#include <stdlib.h>struct polynode{int coef;int exp;struct polynode * link;};//建立新链表typedef struct polynode poly;poly* Attch(int c,int e,poly *d);//插入链表poly *newPoly();//建立新链表poly *padd(poly *p1,poly *p2);//加法poly *pmul(poly *p1,poly *p2);//乘法poly *inputPoly();//输入多项式poly *psub(poly *p1,poly *p2);//减法poly *pdiv(poly *p1,poly *p2);//除法poly *inputPoly1();//输入double caculate(double x,poly *p);//计算void sortPoly(poly *p);//排序void outputPoly(poly*p);//输出多项式void delPoly(poly*p);//除法void Insert(poly *p,poly *h){if(p->coef==0)free(p);else{poly *q1,*q2;q1=h;q2=h->link;while(q2&&p->exp<q2->exp){q1=q2;q2=q2->link;}/*判断两个指数是否相等*/if(q2&&p->exp==q2->exp){q2->coef+=p->coef;free(p);if(!q2->coef){q1->link=q2->link;free(q2);}}/*相等就加系数*/else{p->link=q2;q1->link=p;}}/*不等就插在后面*/}int main(){poly *p1,*p2,*padd1,*psub1,*pmul1; p1=newPoly();printf("第一个多项式\n");p1->link=inputPoly();outputPoly(p1);p2=newPoly();printf("第二个多项式\n");p2->link=inputPoly1();outputPoly(p2);padd1=newPoly();pmul1=newPoly();psub1=newPoly();padd1->link=padd(p1,p2);printf("padd\n");outputPoly(padd1);psub1->link=psub(p1,p2);printf("psub\n");outputPoly(psub1);pmul1->link=pmul(p1,p2);printf("pmul\n");outputPoly(pmul1);printf("输入x的值！");int x;scanf("%d",&x);x=caculate(x,p1);printf("%d\n",x);pdiv(p1,p2);return 0;}poly *newPoly(){poly *x;x=(poly*)malloc(sizeof(poly)); x->link=NULL;x->coef=0;x->exp=0;return x;}poly* Attch(int c,int e,poly *d) {poly *x;x=newPoly();x->coef=c;x->exp=e;d->link=x;return x;}poly *padd(poly *p1,poly *p2){poly *a, *b,*c,*d,*p;c=newPoly();d=c;p=c;a=p1->link;b=p2->link;while(a!=NULL&&b!=NULL){if(a->exp>b->exp)//如果a的系数大于b把a先输入 {c=Attch(a->coef,a->exp,c);a=a->link;}else if(a->exp<b->exp)//小于相反{c=Attch(b->coef,b->exp,c);b=b->link;}else//相等{c=Attch(b->coef+a->coef,a->exp,c);a=a->link;b=b->link;}}/*a b比较完成开始遍历剩下的未插入的*/while(a!=NULL){c=Attch(a->coef,a->exp,c);a=a->link;}while(b!=NULL){c=Attch(b->coef,b->exp,c);b=b->link;}c->link=NULL;d=d->link;p->link=NULL;delPoly(p);return d;}poly *psub(poly*p1,poly*p2)//加和减思路相同，b的系数得输入相反值{poly *a, *b,*c,*d,*p;c=newPoly();d=c;p=c;a=p1->link;b=p2->link;while(a!=NULL&&b!=NULL){if(a->exp>b->exp){c=Attch(a->coef,a->exp,c);a=a->link;}else if(a->exp<b->exp){c=Attch(b->coef*(-1),b->exp,c);b=b->link;}else{if((a->coef-b->coef)>0){c=Attch(a->coef-b->coef,a->exp,c); a=a->link;b=b->link;}else{a=a->link;b=b->link;}}}while(a!=NULL){c=Attch(a->coef,a->exp,c);a=a->link;}while(b!=NULL){c=Attch(b->coef*(-1),b->exp,c);b=b->link;}c->link=NULL;d=d->link;p->link=NULL;delPoly(p);return d;}/*乘法，先用第一个链表的第一个数据乘以第二个链表里的所有值，储存在新的链表中，之后遍历一中所有的值，最后把这些多项式加在一起。

数据结构--线性表的基本运算及多项式的算术运算

数据结构:线性表的基本运算及多项式的算术运算一、实验目的和要求实现顺序表和单链表的基本运算，多项式的加法和乘法算术运算。

要求：能够正确演示线性表的查找、插入、删除运算。

实现多项式的加法和乘法运算操作。

二、实验环境(实验设备)X64架构计算机一台，Windows 7操作系统，IDE: Dev C++ 5.11编译器: gcc 4.9.2 64bit二、实验原理及内容程序一：实现顺序表和单链表的实现本程序包含了四个文件，分别是LinearListMain.cpp，linearlist.h，seqlist.h，singlelist.h。

分别是主程序，线性表抽象类，顺序储存线性表的实现，链表储存顺序表的实现。

文件之间的关系图：本程序一共包含了三个类：分别是LinearList（线性表抽象类），SeqList（顺序储存的线性表），SingleList（链表储存的线性表）。

类与类之间的关系图如下：其实，抽象类LinearList规定了公共接口。

分别派生了SeqList类和SingleList。

SingleList类与SingleList类分别实现了LinearList类中的所有接口。

程序代码以及分析：Linearlist类：#include <iostream>using namespace std;template <class T>class LinearList{protected:int n; //线性表的长度public:virtual bool IsEmpty() const=0; //判读是否是空线性表virtual int Length() const=0; //返回长度virtual bool Find(int i,T& x) const=0; //将下标为i的元素储存在x中，成功返回true，否则返回falsevirtual int Search(T x) const=0; //寻找值是x的元素，找到返回true，否则返回falsevirtual bool Insert(int i,T x)=0; //在下标为i的元素后面插入xvirtual bool Delete(int i)=0; //删除下标为i的元素virtual bool Update(int i,T x)=0;//将下标为i的元素更新为x virtual void Output(ostream& out)const=0; //将线性表送至输出流};包含了一个保护数据成员n，和8种运算，具体说明见注释。

线性表的基本运算

实习题目：线性表的基本运算及多项式的算术运算。

班级：姓名：学号日期：2013.9.30一、问题描述实现顺序表和单链表的基本运算，多项式的加法和乘法算术运算。

能够正确演示线性表的查找、插入、删除运算。

实现多项式的加法和乘法运算操作。

熟练掌握顺序表的各种基本操作。

学会使用线性表解决应用问题的方法；加深对抽象模板类、类的继承、代码重用、重载等C++语言机制的理解和使用。

二、概要设计为实现程序包含的文件如下：多项式：线性表：三、详细设计1、程序的类和类的层次结构在顺序表建立为类SeqList、在单链表建立类SingleList和类Node。

顺序表和单链表有一个共同的基类LinearList，并且，类SeqList、类SingleList均公有继承基类LinearList。

类SingleList 是类Node的友元类。

在多项式的加法和乘法中，使用了两个类，即类Term、类Polynominal，且类Polynominal 是类Term的友元类。

四、程序代码顺序表和单链表的基本运算以及多项式加法及乘法。

详细代码另附纸。

五、测试和调试以上结果为多项式的加法；以上结果为多项式的乘法。

六、实习小结（1）线性表的顺序存储结构具有2个弱点：其一，在进行插入和删除操作时，需移动大量元素；其二，必须预先分配较大的空间，但往往存储空间不能得到充分利用；但线性表的链式存储结构能有效克服这2个弱点。

其一，插入、删除只需修改指针无需移动元素；其二，链表中结点空间是动态申请的。

（2）程序必须有较强的健壮性。

程序在合法输入时正确只是一个最基本的要求，还需考虑当输入不合法时，应当给予错误提示，并作合理处理。

(完整版)数据结构线性表的应用实验报告

实验报告课程名称____数据结构上机实验__________ 实验项目______线性表的应用 ____________实验仪器________PC机___________________系别_____电子信息与通信学院___专业________ ___班级/学号______ __学生姓名______ ___________实验日期_______________________成绩_______________________指导教师_______________________实验一.线性表的应用1.实验目的：掌握线性链表的存储、运算及应用。

利用链表实现一元多项式计算。

2.实验内容：1)编写函数，实现用链表结构建立多项式；2)编写函数，实现多项式的加法运算；3)编写函数，实现多项式的显示；4)测试：编写主函数，它定义并建立两个多项式，显示两个多项式，然后将它们相加并显示结果。

变换测试用的多项式，检查程序的执行结果。

选做内容：修改程序，选择实现以下功能：5)多项式求值：编写一个函数，根据给定的x值计算并返回多项式f(x)的值。

测试该函数（从终端输入一个x的值，调用该函数并显示返回结果）。

6)多项式相减：编写一个函数，求两个多项式相减的多项式。

7)多项式相乘：编写一个函数，求两个多项式的乘积多项式。

3.算法说明：1)多项式的建立、显示和相加算法见讲义。

可修改显示函数，使输出的多项式更符合表达规范。

2)多项式减法：同次项的系数相减（缺项的系数是0）。

例如a(x)=-5x2+2x+3，b(x)= -4x3+3x，则a(x)-b(x)=4x3-5x2-x+3。

提示：a(x)-b(x) = a(x)+(-b(x))。

3)多项式乘法：两个多项式的相乘是“系数相乘，指数相加”。

算法思想是用一个多项式中的各项分别与另一个多项式相乘，形成多个多项式，再将它们累加在一起。

例如，a(x)=-5x2+2x+3，b(x)=-4x3+3x，则a(x)*b(x) = (-4x3)*(-5x2+2x+3)+(3x)*(-5x2+2x+3)= (20x5-8x4-12x3) + (-15x3+6x2+9x) =20x5-8x4-27x3+6x2+9x。

线性表及其应用(多项式相加、相乘)

福建农林大学计算机与信息学院（程序设计类课程）实验报告课程名称：数据结构*名：***系：计算机与信息专业：网络工程年级：09级学号：*********指导教师：***职称：副教授福建农林大学计算机与信息学院实验报告系：计算机与信息专业：网络工程年级：09级姓名：邓建国学号：091154050 实验室号：___ 计算机号：实验一线性表及其应用（多项式相加、相乘）一、实验目的和要求1、熟悉tc的运行环境，并可以熟练的使用tc；2、掌握链表存储的方法以及基本操作；3、掌握内存的动态分配和释放方法；4、熟悉C语言程序的基本格式与规范。

二、实验内容和原理1、实验内容：设计一个一元多项式的简单计算程序，其基本功能有：（1）输入并建立多项式；（2）输出多项式；（3）多项式的相加减；（4）多项式的相乘。

利用单链表实现。

2、实验原理：将两多项式存入链表lianbiao1、lianbiao2，用pointer1扫描lianbiao1，pointer2扫描lianbiao2，结果保存在lianbiao3中(用pointer3来创建lianbiao3)三、实验环境硬件：（1）学生用微机（2）多媒体实验教室（3）局域网环境软件：（1）Windows XP中文操作系统（2）Turbo C 3.0四、算法描述及实验步骤1、描述1.定义创建链表的函数，然后创建三个链表，一个用于存放结果。

2.定义多项式相加的函数实现多项式的相加功能，定义多项式的相乘功能。

3.定义打印链表和释放链表的函数。

4.最后在主函数里面调用这些函数，实现多项式的相加和相乘。

例子：A(X)=3X+7X6-9X9B(X)=2X-3+7-3X+8X3+X5（1）执行加法操作，输出“lianbiao1+lianbiao2:(2,-3) (7,0) (8,5) (1,5) (7,6) (-9,9)”（2）执行乘法操作，输出“lianbiao1*lianbiao2:(6,-2) (21,1) (-9,2) (14,3) (55,6) (3,6) (-21,7) (-63,9) (27,10) (56,11) (7,11) (-72,14) (-9,14)”2、框图3、代码(注释)#include "stdio.h" /* 输入输出函数的头文件*/#include "alloc.h" /* alloc.h是动态分配内存空间头文件*/typedef struct node /* 定义节点，包含两个数据域（c和e）和一个指针域（*next）*/ {int c,e; /*c是指多项式的系数, e是项的指数*/struct node *next; /* 定义next为指向下一个结点的指针*/}Pn; /*定义Pn类型*/Pn *create() /*创建链表*/{Pn *pointer,*lianbiao;int n;lianbiao=malloc(sizeof(Pn)); /*用malloc动态分配函数给链表分配内存空间*/printf("n:"); /*提示用户输入多项式的项数*/scanf("%d",&n); /*接收用户输入的多项式的项数*/pointer=lianbiao;while(n) /*对n进行判断，当n不为零时执行while循环语句*/{pointer->next=malloc(sizeof(Pn)); /*为链表新的节点申请空间*/pointer=pointer->next; /*将pointer下移*/printf("c e:");scanf("%d %d",&pointer->c,&pointer->e); /*将系数c,指数e存入链表中的新节点*/n--; /*没当输入一项时，项数n就减一*/ }pointer->next=NULL; /*如果pointer指向的下一个结点的指针域为空，说明链表已经创建好了*/ return lianbiao;}void OUT(Pn *lianbiao) /*打印输出链表*/{Pn *pointer=lianbiao->next;while(pointer) /*打印出当前的结点系数c和指数e, 直到链表为空*/{printf("(%d,%d) ",pointer->c,pointer->e); /*打印出多项式系数c和指数e*/pointer=pointer->next; /*打印出当前结点后,将指针移到下一个节点*/ }printf("\n"); /*用\n换行*/}void Free(Pn *lianbiao) /*释放链表空间*/{Pn *pointer=lianbiao; /*将pointer指向头节点*/while(pointer) /*释放链表中的结点,直到pointer链表为空时推出循体*/{lianbiao=lianbiao->next; /*删除当前节点*/free(pointer); /*释放当前结点的空间*/pointer=lianbiao; /* 当pointer指向头结点指针时结束循环*/}}Pn *add(Pn *lianbiao1,Pn *lianbiao2) /*多项式相加*/{Pn *lianbiao3,*pointer3,*pointer1=lianbiao1->next,*pointer2=lianbiao2->next; /*建立新的链表lianbia o3，用于存放lianbiao1与lianbiao2相加后的结果*/int c,e; /*这里的c为多项式相加后的系数,而e为结点相加后的指数*/ pointer3=lianbiao3=malloc(sizeof(Pn)); /*用malloc为lianbiao3申请空间*/lianbiao3->next=NULL;while(pointer1||pointer2) /*当pointer1或pointer2不为空时，分成3种情况*/{if(pointer1&&(pointer2==NULL||pointer1->e<pointer2->e)) /*第一种是当pointer1不空并且pointer2为空,或者pointer1所指的指数e小于pointer2所指的指数e时*/{c=pointer1->c; /*将pointer1当前所指结点的系数c赋值给c*/e=pointer1->e; /*将pointer1当前所指结点的系数e赋值给e*/pointer1=pointer1->next; /*将pointer1移到下一结点*/ }else if(pointer2&&(pointer1==NULL||pointer2->e<pointer1->e)) /*第二种是当pointer2不空且pointer1为空或者pointer2所指的指数e小于pointer1所指的指数e时*/{c=pointer2->c;e=pointer2->e;pointer2=pointer2->next;}else /*第三种是当pointer1、pointer2都不为空且pointer1的指数e等于pointer2的指数e时*/{c=pointer1->c+pointer2->c; /*将pointer1与pointer2所指的系数相加*/e=pointer1->e;pointer1=pointer1->next; /*将pointer1下移*/pointer2=pointer2->next; /*将pointer2下移*/}if(c){pointer3->next=malloc(sizeof(Pn)); /*申请新结点的空间*/pointer3=pointer3->next; /*pointer3下移*/pointer3->c=c; /*把系数c放入新结点*/pointer3->e=e; /*把指数e放入新结点*/}}pointer3->next=NULL; /*当所指的指针为NULL时，链表结束*/return lianbiao3; /* 返回两个多项式相加的结果lianbiao3 */ }Pn *mx1(Pn *pointer1,Pn *lianbiao2) /*多项式相乘*/{Pn *lianbiao3,*pointer3,*pointer2=lianbiao2->next; /*定义链表lianbiao3 */pointer3=lianbiao3=malloc(sizeof(Pn)); /*为lianbiao3申请空间, 并将pointer3指向lianbiao3*/ lianbiao3->next=NULL;while(pointer2) /* 当pointer2不为空时，执行while循环*/ {pointer3->next=malloc(sizeof(Pn)); /*为新创结点申请空间*/pointer3=pointer3->next; /*将pointer3指向新结点*/pointer3->c=pointer1->c*pointer2->c; /*将pointer1的系数乘以pointer2->c*/pointer3->e=pointer1->e+pointer2->e; /*将pointer1的指数乘以pointer2->e*/pointer2=pointer2->next; /*pointer2下移*/}pointer3->next=NULL;return lianbiao3; /*将结果lianbiao3返回*/}Pn *mxm(Pn *lianbiao1,Pn *lianbiao2) /*多项式相乘*/{Pn *lianbiao3,*pointer1=lianbiao1->next,*htemp;lianbiao3=malloc(sizeof(Pn));lianbiao3->next=NULL;while(pointer1) /*当pointer1不为空，执行while循环*/{htemp=mx1(pointer1,lianbiao2); /*将相乘结果放到链表htemp*/lianbiao3=add(lianbiao3,htemp); /*将htemp中的多项式加上lianbiao3中的多项式*/ pointer1=pointer1->next;Free(htemp); /*释放链表htemp*/}return lianbiao3; /*返回结果lianbiao3 */}main(){Pn *lianbiao1,*lianbiao2,*lianbiao3; /*定义三个链表lianbiao1,lianbiao2,lianbiao3*/ clrscr();printf("Create lianbiao1\n");lianbiao1=create(); /*创建链表lianbiao1*/printf("\nPrintf lianbiao1\n");OUT(lianbiao1); /*打印出链表lianbiao1*/printf("\nCreate lianbiao2\n");lianbiao2=create(); /*创建链表lianbiao2*/printf("\nPrintf lianbiao2\n");OUT(lianbiao2); /*打印出链表lianbiao2*/printf("\nlianbiao1+lianbiao2:");lianbiao3=add(lianbiao1,lianbiao2); /*把lianbiao1和lianbiao2相加的结果赋给lianbiao3*/ OUT(lianbiao3); /*打印出lianbiao3*/Free(lianbiao3); /*释放lianbiao3 */printf("\nlianbiao1*lianbiao2:");lianbiao3=mxm(lianbiao1,lianbiao2); /*把lianbiao1和lianbiao2相乘的结果赋给lianbiao3*/ OUT(lianbiao3); /*输出lianbiao3*/Free(lianbiao1); /*释放lianbiao1*/Free(lianbiao2);Free(lianbiao3);getch();}五、调试过程#include "malloc.h"语句出错，多了一个m，后来改为#include "alloc.h"，就编译通过了。

线性表在一元多项式运算中的应用

线性表在⼀元多项式运算中的应⽤实验题1-1 多项式运算【问题描述】有两个指数递减的⼀元多项式，写⼀程序先求这两个多项式的和，再求它们的积。

【提⽰】⽤带表头结点的单链表作为多项式的存储表⽰；要建⽴两个单链表；多项式相加就是要把⼀个单链表中的结点插⼊到另⼀个单链表中去，要注意插⼊、删除操作中指针的正确修改。

#include <iostream>using namespace std;int k = 1;typedef struct {float coef; //系数int expn; //指数}term;struct LNode{term data;struct LNode *next;};typedef struct LNode* Polynomial;//合并同类项Polynomial MergePolyn(Polynomial P){Polynomial p = NULL,q = NULL,r = NULL,Q = NULL;if(P == NULL||P->next == NULL){return NULL;}else{for(p = P->next;p!=NULL;p=p->next)for(q = p->next,r = p;q!=NULL;){if(p->data.expn == q->data.expn){p->data.coef+=q->data.coef;Q = q;r->next = q->next;q = r->next;//?⾄关重要delete Q;}elser=r->next,q = q->next;}return P;}}//1.创建⼀个⼀元多项式Polynomial CreatePolyn(int m){if(m>=0){Polynomial head = new LNode;head->next = NULL;Polynomial s,r = head;for(int i=0;i<m;i++){cout<<"第"<<i+1<<"项的系数和指数是:";float c;int e;cin>>c>>e;s = new LNode;s->data.coef = c;s->data.expn = e;r->next = s;r = r->next;}r->next = NULL;return head;}else{cout<<"输⼊m值⾮法，创建多项式失败\n";k = 0;return NULL;}}//2.两个⼀元多项式相加Polynomial AddPolyn(const Polynomial pa,const Polynomial pb){if(pa&&pa->next&&pb&&pb->next){Polynomial head = new LNode;Polynomial s = pa->next,t = pb->next,r = head;r->next = NULL;while(s!=NULL){Polynomial n = new LNode;n->next = NULL;n->data.coef = s->data.coef;n->data.expn = s->data.expn;r->next = n;r = r->next;s = s->next;}while(t!=NULL){Polynomial n = new LNode;n->next = NULL;n->data.coef = t->data.coef;n->data.expn = t->data.expn;r->next = n;r = r->next;t = t->next;}r->next = NULL;head = MergePolyn(head);return head;}else if((pa == NULL||pa->next == NULL)&&(pb!=NULL&&pb->next!=NULL)) return pb;else if((pb == NULL||pb->next == NULL)&&(pa!=NULL&&pa->next!=NULL)) return pa;elsereturn NULL;}//3.两个⼀元多项式相乘Polynomial MultiplyPolyn(const Polynomial pa,const Polynomial pb){if(pa==NULL||pa->next==NULL||pb==NULL||pb->next==NULL)return NULL;else{Polynomial head = new LNode;head->next = NULL;Polynomial p,q,r,s = head;for(p = pa->next;p!=NULL;p=p->next)for(q = pb->next;q!=NULL;q=q->next){r->data.coef = p->data.coef * q->data.coef;r->data.expn = p->data.expn + q->data.expn;r->next = NULL;//千万记住将new的结点指针域置空s->next = r;s = s->next;}s->next = NULL;head = MergePolyn(head);return head;}}//打印多项式void PrintPolyn(Polynomial P){if(P==NULL||P->next==NULL){cout<<"⽆项\n";}else{cout<<"Y=";int iszero = 1;Polynomial p = NULL,q = NULL;p = P->next;if(p->data.coef&&p->data.coef!=1&&p->data.coef!=-1&&p->data.expn&&p->data.expn!=1) {cout<<p->data.coef<<"X^"<<p->data.expn;iszero = 0;}else if(p->data.coef&&p->data.coef!=1&&p->data.coef!=-1&&p->data.expn==1){cout<<p->data.coef<<"X";iszero = 0;}else if(p->data.coef&&p->data.coef!=1&&p->data.coef!=-1&&p->data.expn==0){cout<<p->data.coef;iszero = 0;}else if(p->data.coef==1&&p->data.expn&&p->data.expn!=1){cout<<"X^"<<p->data.expn;iszero = 0;}else if(p->data.coef==1&&p->data.expn==1){cout<<"X";iszero = 0;}else if(p->data.coef==1&&p->data.expn==0){cout<<"1";iszero = 0;}else if(p->data.coef==-1&&p->data.expn&&p->data.expn!=1){cout<<"-X^"<<p->data.expn;iszero = 0;}else if(p->data.coef==-1&&p->data.expn==1){cout<<"-X";iszero = 0;}else if(p->data.coef==-1&&p->data.expn==0){cout<<"-1";iszero = 0;}else if(p->data.coef==0);else{cout<<p->data.coef<<"X^"<<p->data.expn;iszero = 0;}if(p->next)q = p->next;while(q){if(q->data.coef>0&&q->data.coef!=1&&q->data.expn&&q->data.expn!=1){cout<<"+"<<q->data.coef<<"X^"<<q->data.expn;iszero = 0;}else if(q->data.coef>0&&q->data.expn==0){cout<<"+"<<q->data.coef;iszero = 0;}else if(q->data.coef>0&&q->data.coef!=1&&q->data.expn==1){cout<<"+"<<q->data.coef<<"X";iszero = 0;}else if(q->data.coef==1&&q->data.expn&&q->data.expn!=1){cout<<"+"<<"X^"<<q->data.expn;iszero = 0;}else if(q->data.coef==1&&q->data.expn==1){cout<<"+"<<"X";iszero = 0;}else if(q->data.coef==1&&q->data.expn==0){cout<<"1";iszero = 0;}else if(q->data.coef<0&&q->data.coef!=-1&&q->data.expn==1){cout<<q->data.coef<<"X";iszero = 0;}else if(q->data.coef==-1&&q->data.expn&&q->data.expn!=1){cout<<"-X^"<<q->data.expn;iszero = 0;}else if(q->data.coef==-1&&q->data.expn==1){cout<<"-X";iszero = 0;}else if(q->data.coef==-1&&q->data.expn==0){cout<<"-1";iszero = 0;}else if(q->data.coef==0);else{cout<<q->data.coef<<"X^"<<q->data.expn;iszero = 0;}q=q->next;}if(iszero)cout<<"0";cout<<endl;}}int main(){Polynomial pa = NULL,pb = NULL,P = NULL,Q = NULL,R = NULL,T = NULL;do{cout<<"1.创建两个⼀元多项式"<<endl;cout<<"2.两个⼀元多项式相加得⼀新多项式"<<endl;cout<<"3.两个⼀元多项式相乘得⼀新多项式"<<endl;cout<<"请选择:";int n,m;cin >> n;switch(n){case 1:cout<<"请输⼊第⼀个多项式的项数:";cin>>m;P = CreatePolyn(m);pa = MergePolyn(P);PrintPolyn(pa);cout<<"请输⼊第⼆个多项式的项数:";cin>>m;Q = CreatePolyn(m);pb = MergePolyn(Q);PrintPolyn(pb);break;case 2:R = AddPolyn(pa,pb);PrintPolyn(R);break;case 3:T = MultiplyPolyn(pa,pb);PrintPolyn(T);break;default:k = 0;cout<<"输⼊了⽆效字符\n";break;}}while(k);return 0;}注意点：不能随意修改pa，pb的值，两多项式的加法运算与乘法运算应该互不⼲扰，尤其注意在多项式加法中不能采⽤两链表合为⼀个链表的算法（会改变pa的链表）。

数据结构线性表链接存储多项式计算

上一节介绍的单链表在做插入和删除运算时，要考虑一般情况和特殊情况，用带表头结点的单链表可以简化上述两种算法。
在原单链表的头结点之前增加一个结点，但它的 element域中不存放线性表中的任何元素，称该结点为表头结点。
first
a0
a1
a2
… an-1 ∧
非空表
first ∧
空表
带表头结点的单链表的类型定义
<=能否颠倒顺序？
双向链表的删除 1
2
删除操作的核心步骤是： (1) p->lLink->rLink=p->rLink;
p->rLink->lLink=p->lLink; <=能否颠倒顺序？ (2) free(p) ;
目录
线性表抽象数据类型线性表的顺序存储表示方法
线性表的链接存储表示方法多项式计算
if (!L->n) return ERROR; if (i<0 || i>L->n-1) return ERROR; q=L->first; p=L->first; for (j=0; j<i-1; j++) q=q->link; if (i==0)
L->first=q->link; //删除的是头结点 else
的后继结点ai; ②从单链表中删除p； ③释放p之空间； ④表长减1。
删除p：删除时只要修改一个指针： q->link=p->link
q
ai-1
p
first
a0
p
ai
a1
ai+1
a2
…
an-1 ∧
Status Delete(SingleList *L,int i) { int j; Node *p,*q;

用线性表实现多项式的加法和乘法

用线性表实现多项式的加法和乘法15．用线性表实现多项式的加法和乘法/*用线性表实现多项式的加法和乘法*/#include<iostream>#include<cstdlib>#include<Vector>#include<cmath>using namespace std;/*使用模板创建一个因子的结构*/template<typename T>struct Polynomia{T num; //num表示实系数；char ch; //ch表示未知数；int i; //i表示指数；};/*对加号的重载*/template<typename T>Polynomia<T> operator+(Polynomia<T> const& lhs,Polynomia<T> const& rhs){Polynomia<T> P1;if(lhs.ch==rhs.ch){P1.num=lhs.num+rhs.num;P1.ch=lhs.ch;if(lhs.i==rhs.i||lhs.i!=0){P1.i=lhs.i;}else{P1.i=rhs.i;}}return P1;}/*对乘号的重载*/template<typename T>Polynomia<T> operator*(Polynomia<T> const& lhs,Polynomia<T> const& rhs){Polynomia<T> P2;if(lhs.num==0||rhs.num==0){P2.num=0;P2.ch=lhs.ch;P2.i=0;}else{P2.num=lhs.num*rhs.num;P2.ch=lhs.ch;P2.i=lhs.i+rhs.i;}return P2;}/*找出最大指数*/template<typename T1>T1 max(T1 a,T1 b){if(a>=b) return a;else return b;}typedef Polynomia<double> PP;int main(){double x; //x存储实系数；char ch2,ch1,ch0; //ch0存储未知元，ch1存储括号，ch2存储运算符号；int a,count=0,Max=0; //Max存储最大指数；Polynomia<double> P,P0; //P，P0存储因子；std::vector<PP> vector1,vector2,vector3; //vector1,vector2,vector3分别存储参加运算的多项式//和得出的结果；vector1.reserve(1000);vector2.reserve(1000);vector3.reserve(1000); //给线性表分配空间；P.num=0;P.ch='y';P.i=0;P0.num=0;P0.ch='y';P0.i=0; //结构的初始化；for(count=0;count<100;count++){ //向量的初始化；vector1.push_back(P);vector2.push_back(P);vector3.push_back(P);}cout<<"请输入多项式（形如(5y2+2y1)*(4y4+3y1)=）"<<endl;cout<<"注意括号不可少！"<<endl<<endl;cin>>ch1;while(ch1!='(') {cin>>ch1;} //以括号区分两个多项式，并存入向量；while(ch1!=')'){cin>>x>>ch0>>a;P.num=x;P.ch=ch0;P.i=a;vector1.operator[](a)=P;Max=max(Max,a);cin>>ch1;}cin>>ch2; //第二个多项式；while(ch1!='(') {cin>>ch1;}while(ch1!=')'){cin>>x>>ch0>>a;P.num=x;P.ch=ch0;P.i=a;vector2.operator[](a)=P;Max=max(Max,a);cin>>ch1;}if(ch2=='+'){ //进行加法运算；for(count=0;count<=Max;count++){vector3.operator[](count)=vector1.operator[](count)+vector 2.operator[](count);}}if(ch2=='*'){ //进行乘法运算；for(int count1=0;count1<=2*Max;count1++){for(int count2=0;count2<=count1;count2++){P0=P0+(vector1.operator[](count2)*vector2.operator[](coun t1-count2));}vector3.operator[](count1)=P0;P0.num=0;P0.ch='y';P0.i=0;}}cout<<"结果为：";for(int m=0,n=0;m<=2*Max;m++){ //控制输出；if((vector3.operator[](m)).num!=0){n==0?cout<<" ":cout<<"+";n++;cout<<(vector3.operator[](m)).num<<(vector3.operator[](m )).ch<<(vector3.operator[](m)).i;}}cout<<endl<<endl<<endl;return 0;}。

线性表及多项式操作

实验报告实验报告int i;SeqList list;Init(&list,10);for(i=0;i<10;i++)Insert(&list,i-1,i);Output(list);printf("\n");Delete(&list,0);Output(list);Destroy(&list);}调用结果：实验报告Output(list);Find(list,0,&x);//printf("\nthe value is:");//printf("%d ",1);Destroy (&list);}调用结果:单链表的基本操作和逆置是在一篇代码中，所以主函数中已包括逆置函数的调用，调用结果如图也包括了逆置结果。

3.单链表逆置操作status Nizhi(headerList *L){Node *p,*q,*r;p=L->head;q=p->link;while(q){r=q->link;q->link=p;p=q;q=r;}L->head->link->link=NULL;L->head->link=p;return 0;}调用结果：4.单链表排序操作（冒泡）#include<stdio.h>#include<stdlib.h>typedef struct node{int element;struct node *next;}Node,*LinkList;5.多项式操作多项式的类型定义（struct.h）: typedef struct PNode{int coef;int exp;struct PNode* link;} PNode;typedef struct{struct PNode *head;}polynominal;多项式的创建（Create.c）: void Create(polynominal *p) {PNode *pn,*pre,*q;//Mult(&listC,&listD);Output(*Mult(&listC,&listD)); Destroy(&listC);Destroy(&listD);}break;}}运行结果：（1）多项式加法：（2）多项式乘法：实验报告四、实验小结（包括问题和解决方法、心得体会、意见与建议等）一、前面写顺序表的时候没有遇到什么问题，只是有两个地方有点小问题但很快解决了；（1）(void*)malloc(sizeof(PNode))在malloc前面漏掉强制类型转换。