实验一 线性表应用---多项式计算
1数据结构-实验报告一(线性表的基本操作)
实验一 线性表的基本操作及其应用一、实验目的1、帮助读者复习C++语言程序设计中的知识。
2、熟悉线性表的逻辑结构。
3、熟悉线性表的基本运算在两种存储结构上的实现。
4、掌握顺序表的存储结构形式及其描述和基本运算的实现。
5、熟练掌握动态链表结构及有关算法的设计二、实验内容求两个多项式的相加运算[问题描述]用单链表存储一元多项式,并实现两个多项式的相加运算。
[基本要求](1)本程序需要基于线性表的基本操作来实现一元多项式的加法,也可以用数组实现。
;(2)两个多项式都有键盘输入相应的系数和指数[测试数据] 由学生任意指定。
三、源代码#include <stdio.h>#include <malloc.h>#define MAX 20 //多项式最多项数typedef struct //定义存放多项式的数组类型{double coef; //系数int exp; //指数} PolyArray[MAX];typedef struct pnode //定义单链表结点类型{double coef; //系数int exp; //指数struct pnode *next;} PolyNode;void DispPoly(PolyNode *L) //输出多项式{bool first=true; //first为true表示是第一项PolyNode *p=L->next;while (p!=NULL){if (first)first=false;else if (p->coef>0)printf("+");if (p->exp==0)printf("%g",p->coef);else if (p->exp==1)printf("%gx",p->coef);elseprintf("%gx^%d",p->coef,p->exp);p=p->next;}printf("\n");}void DestroyList(PolyNode *&L) //销毁单链表{PolyNode *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}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++){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; //终端结点next域置为NULL}void Sort(PolyNode *&head) //按exp域递减排序{PolyNode *p=head->next,*q,*r;if (p!=NULL) //若原单链表中有一个或以上的数据结点{r=p->next; //r保存*p结点后继结点的指针 p->next=NULL; //构造只含一个数据结点的有序表 p=r;while (p!=NULL){r=p->next; //r保存*p结点后继结点的指针 q=head;while (q->next!=NULL && q->next->exp>p->exp)q=q->next; //在有序表中找插入*p的前驱结点*qp->next=q->next; //将*p插入到*q之后q->next=p;p=r;}}}void Add(PolyNode *ha,PolyNode *hb,PolyNode *&hc) //求两有序集合的并{PolyNode *pa=ha->next,*pb=hb->next,*s,*tc;double 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->exp<pb->exp){s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pb->exp;s->coef=pb->coef;tc->next=s;tc=s;pb=pb->next;}else //pa->exp=pb->exp{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={{2.3,0},{-2.8,2},{5.6,3},{-10.9,7},{7.6,10}};PolyArray b={{-1.2,0},{8.6,1},{-13.9,3},{15.5,5},{5.6,9}};CreateListR(ha,a,5);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,hb,hc);printf("多项式相加: ");DispPoly(hc);DestroyList(ha);DestroyList(hb);DestroyList(hc);}四、测试结果五、心得体会两个简单的的多项式用相加,编程却需要线性表各种用法显得很复杂。
实验一:线性表应用
实验报告学院(系)名称:计算机与通信工程学院 姓名**学号 ********专业计算机科学与技术班级 2015级*班 实验项目实验一:线性表应用课程名称 数据结构与算法 课程代码 0661013 实验时间2017年3月9日第一节实验地点 7-219 考核标准 实验过程 25分程序运行 20分回答问题15分 实验报告30分 特色 功能5分考勤违纪情况 5分 成绩成绩栏其它批改意见: 教师签字:考核内容 评价在实验课堂中的表现,包括实验态度、编写程序过程等内容等。
□功能完善,□功能不全□有小错□无法运行○正确 ○基本正确○有提示○无法回答○完整 ○较完整○一般 ○内容极少 ○无报告○有 ○无 ○有 ○无一、实验目的? (1)将多项式各项的系数和指数分别存在A、B两个链表的中。
? (2)用指针Pa、Pb分别指向连个链表的首元素。
? (3)遍历两个链表,比较各元素的指数,若相同则相加减,将结果插入新表中,若不相等则将指数较小的插入新表中,继续向后遍历,直到其中一个链表到达表尾。
? (4)将另一表中的剩余元素按指数大小顺序全部插入到新表中。
? (5)新表中的元素按规定格式输出既为相加或相减后的多项式。
? 3、?? (1)通过构造函数创建单链表? (2)通过循环变量temp找到第一个链表的尾部设为p。
? (3)使p的next指向第二个链表的第一个元素? (4)将连接后的两链表输出? 4、? (1)用两个变量minZ,maxZ分别存储输入的最小值和最大值? (2)遍历整个单链表,将小于minZ和大于maxZ的节点删除? (3)输出操作后的单链表? 算法的实现和测试结果:包括算法运行时的输入、输出,实验中出现的问题及解决办法等? 出现问题? 无法返回操作后的单链表? 解决办法? 经老师直到后,在相关函数前面加*成功返回操作后的单链表? 1、3、4、? 算法时间复杂度分析? 1、O(1表长度+2表长度)---------------可视为O(n)? 3、O(1表长度+2表长度)---------------可视为O(n)? 4、O(n)?四、收获与体会线性表分为顺序表和链表,其中顺序表已相当熟悉,主要练了新接触的链表,感觉现在才真正体会到指针的魅力之处。
数据结构线性表多项式加减实验报告
数据结构实验报告实验名称:实验一——线性表日期: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 结构类型,用来储存指定多项式的系数和指数的数据。
南邮数据结构上机实验一线性表的基本运算和多项式的基本运算资料
实验报告(2015 / 2016学年第二学期)课程名称数据结构A实验名称线性表的基本运算和多项式的基本运算实验时间2016 年 3 月10 日指导单位计算机科学与技术系指导教师骆健学生姓名班级学号学院(系) 管理学院专业信息管理与信息系统实习题名:线性表的基本运算班级姓名学号日期2016.03.10一、问题描述深入理解线性表数据结构,熟练掌握顺序表的各种基本操作。
在顺序表类SeqList 中增加成员函数void Reverse(),实现顺序表的逆置;在顺序表类SeqList中增加成员函数bool DeleteX(const T &x),删除表中所有元素值等于x元素。
若表中存在这样的元素,则删除之,且函数返回true,否则函数返回false。
二、概要设计文件Inverse.cpp中定义了Linearlist类, SeqList类继承Linearlist类。
在顺序表类SeqList中通过函数void Reverse()实现顺序表的逆置,通过函数boolDeleteX(const T &x),删除表中所有元素值等于x元素。
三、详细设计1.类和类的层次设计程序使用了两个类, 线性表Linearlist类和顺序表SeqList类和一个主函数mian。
Linearlist类里包括常见的线性表运算,在类SeqList里面新增成员函数void Reverse()和bool DeleteX(const T &x)。
TLinearlist#int n+virtual bool IsEmpty() const = 0;+virtual int Length() const = 0;+virtual bool Find(int i,T& x) const = 0;+virtual int Search(T x) const = 0;+virtual bool Insert(int i,T x) = 0;+virtual bool Delete(int i) = 0;+virtual bool Update(int i,T x) = 0;+virtual void Output(ostream& out) const = 0;TSeqList-int maxLength;-T *elements;+IsEmpty() const;+Length() const;+Find(int i,T& x) const;+Search(T x) const;+Insert(int i,T x);+Delete(int i);+Update(int i,T x);+Output(ostream& out) const;+Reverse();+DeleteX(const T& x);2.核心算法顺序表SeqList类中,私有段封装了两个私有数据成员maxLength和elements,公有段封装了构造、析构、查找、删除、逆置等函数。
实验一 线性表应用---多项式计算
浙江大学城市学院实验报告课程名称数据结构与算法实验项目名称实验一线性表应用---多项式计算实验成绩指导老师(签名)日期一.实验目的和要求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.撰写实验报告的目的对本次实验情况进行总结,加强对实验内容的理解,对实验过程有一个系统的认识,从中获得本次试验的经验,并对实验结果进行适当的分析,加深对栈和队列的理解和认识。
二、内容1.说明实验次数及实验内容本次实验用一次实验课时完成实验内容:节点定义:typedef struct node{int idx;int age;struct node *next;}Node,*List;本次实验的对象的存储内容包括ID和AGE,所以定义了如上的结构体,idx用于存储ID 号,age用于存储年龄,next用于形成链式结构,Node定义了该类型的一个节点,List定义了该类型的一个链表。
(1)、编写函数CreateList()和PrintList(),从给定数组创建链表,打印链表。
int idx[8] = {1,2,3,4,5,6,7,8};int age[8] = {15,18,13,22,50,18,30,20};List CreatList(int idx[], int age[],int len){} int PrintList(List L){}(2)、编写函数DeleteNode(List L, int delete_age),完成以下操作。
int DeleteNodeAge(List L, int delete_age){} 该函数传入List L,可以直接修改链表的节点,建议返回值为int 或void类型,无需为List类型,3,4题同上。
2.1删除年龄为18的成员,打印链表。
2.2删除年龄为20的成员,打印链表。
2.3删除年龄为15的成员,打印链表。
2.4(可选)删除年龄为21的成员(因无此成员,报错),打印链表。
“线性表及其应用”实验报告
序号73 学号2013112000 姓名张三实验 2 实验名称线性表及其应用难度等级B+一、需求分析1、问题描述设计一个一元稀疏多项式简单计算器.2、基本要求一元稀疏多项式基本功能包括:1)输入并建立多项式⏹一元n次多项式:P(x)=c m+c m-1+…+c1,其中n=e m>e m-1>…>e1≥0,c i≠0(i=1,2,m)n⏹输入(c m,e m)(c m-1,e m-1)…(c1,e1)构建一元n次m项多项式2)输出多项式:c m x^e m+c m-1x^e m-1+…+c1x^e13)多项式a和b相加,建立a+b4)多项式a和b相减,建立a-b3、测试数据1)(-3.1x11+5x8+2x)+(11x9-5x8+7)=(-3.1x11+11x8+2x+7)2)(-1.2x9+6x-3+4.4x2-x)-(7.8x15+4.4x2-6x-3)=(-7.8x15-1.2x9+12x-3-x)3)(x5+x4+x3+x2+x+1)-(-x4-x3)=(x5+x2+x+1)4)(x3+x)-(-x3-x)=05)(x100+x)+(x200+x100)=(x200+2x100+x)6)(x3+x2+x)+0=x3+x2+x7)互换上述测试数据中的前后多项式.二、概要设计ADT Polynomial{数据对象: D={a i|a i∈TermSet, i=1,2,…,m,m≥0,TermSet中的每个元素包含一个表示系数的实数和表示指数的整数}数据对象: R1={<a i,a i-1>|a i,a i-1∈D,且a i-1中的指数值小于ai中的指数,i=2,…,m}基本操作:createPoly(&p,m,(*input)())Result: 指数由大到小输入m项的系数和指数,建立一元多项式pdestroyPoly(&p)Condition: 一元多项式p已存在Result: 销毁一元多项式ptraversePoly(p)Result: 输出一元多项式addPoly(&pa,&pb);Condition: 一元多项式pa,pb已存在Result: 完成多项式相加运算,即pa=pa+pb,并销毁一元多项式pb.subtractPoly(&pa,&pb)Condition: 一元多项式pa,pb已存在Result: 完成多项式相减运算,即pa=pa-pb,并销毁一元多项式pb.}ADT Polynomial三、详细设计1、 数据类型定义typedef struct{float coef; int expn;}ElemType;//定义存放多项式中项的系数和指数 typedef struct LNode{ElemType data;struct LNode *next; }LNode, *LNodePtr; typedef struct{LNodePtr hp; int length;}LinkList;//定义链表typedef LinkList Poly;//将链表定义为多项式类型 2、 函数原型定义Status createPoly(Poly &p, int m, Status (*input)(int, float *, int *)); Status traversePoly(Poly p, Status (*visit)(int, int, float, int)); Status destroyPoly(Poly &p);Status addPoly(Poly &pa, Poly &pb);//下面的函数可以根据需要由用户在main()函数中定义 Status input(int, float *, int *); Status visit(int, int, float, int);3、 核心算法描述⏹ createPoly()Status createPoly(Poly &p, int m, Status (*input)(int, float *, int *)){ int i,expn; float coef; LNodePtr s,hp;p.hp =(LNodePtr)malloc(sizeof(LNode)); if(!p.hp) exit(OVERFLOW); p.hp->next=NULL; p.length=0; hp=p.hp;for(i=1;i<=m;i++){(*input)(i,&coef,&expn);s=(LNodePtr)malloc(sizeof(LNode)); if(!s) exit(OVERFLOW); s->data.coef=coef; s->data.expn=expn; s->next=NULL; hp->next=s; hp=s; }p.length=m; return OK; }⏹ traversePoly()Status traversePoly(Poly p, Status (*visit)(int,int, float, int)){ int m;LNodePtr q;构建链表头结点,完成链表初始化 根据用户输入多项式的项信息构建多项式,hp 指向当前创建结点q=p.hp->next;for(m=1;m<=p.length;m++){(*visit)(p.length,m,q->data.coef,q->data.expn);q=q->next;}return OK;}⏹destroyPoly()Status destroyPoly(Poly &p){LNodePtr q;while(p.hp){q=p.hp;p.hp=q->next;free(q);}p.length=0;return OK;}⏹addPoly()Status addPoly(Poly &pa, Poly &pb){LNodePtr q,ap,bh,bp,s;float tcoef;int result;q=pa.hp; ap=q->next; bh=pb.hp; bp=bh->next;while(ap&&bp){result=ap->data.expn-bp->data.expn;if(result<0){s=bp; bp=bp->next; bh->next=bp;q->next=s; s->next=ap; q=s;pa.length++; pb.length--;}else if(result>0){q=ap; ap=ap->next;}else{tcoef=ap->data.coef+bp->data.coef;if(!tcoef){q->next=ap->next; free(ap);ap=q->next;pa.length--;}else{ap->data.coef=tcoef; q=ap;ap=ap->next;}bh->next=bp->next; free(bp);bp=bh->next; pb.length--;}//result=0}//while 根据用户定义的输出函数遍历多项式的每一项并将项和系数输出if(bp) {q->next=bp; pa.length += pb.length; bh->next=NULL; pb.length=0;}free(pb.hp);return OK;}4、函数调用关系main()首先调用createPoly(),traversePoly(),addPoly(),而createPoly()调用用户自定义input()输入多项式信息,traverPoly()调用用户自定义visit()输出多项式信息.四、运行记录测试数据预期结果实际结果分析(-3.1,11) (5,8) (2,1) -3.1x^11+5x^8+2^x -3.1x^11-3.1x^11-3.1x^11 scanf(“(%f,%d)”)(-3.1,11)(5,8)(2,1) -3.1x^11+5x^8+2^x -3.1x^11+5.0x^8+2.0x^1 剔除输入数据项括号之间的空格测试addPoly()pa:(-3.1,11)(5,8)(2,1) pb:(11,9)(-5,8)(7,0) -3.1x^11+11x^9+2x^1+7 -3.1x^11+11x^9+2x^1原因算法中忽略了对pa和pb长度的处理,另外,在将剩余元素加到pa上,忘记对pb头结点的处理即pb.hp->next=NULL五、总结这次实验的难度和复杂度高于第一次实验,第一次实验是熟悉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.⽤顺序表和链表分别分别编程实现教材中例⼦2-1与2-2。
要求:(1)只能⽤C语⾔编程实现;(2)完全保持书中算法2.1与算法2.2形式,不允许有任何变化,除⾮语法上不允许;所调⽤各函数参照书中19页的功能描述,其中函数名、参数个数及性质、函数功能必须与书中完全⼀致,不能有变化。
2.利⽤线性表表⽰⼀元多项式完成多项式的加、减、乘、求导、求值运算。
要求:(1)输⼊的⼀元多项式可以采⽤只输⼊各项的系数与指数这种简化的⽅式。
如对于多项式2x2+6x5,输⼊可为: 2,2 6,5 这样的简单形式。
(2)遇到有消项时应当处理,如2x2+6x5与3x2-6x5进⾏相加时,结果为5*x^2。
(3)当给定x的值时,能计算表达式相加或相减的结果。
(4)操作的结果放⼊⼀个新线性表中,原来的两个表达式存储表⽰不变,也可以不是产⽣新的线性表,⽽是将两上线性表合并为⼀个。
(5)要求程序功能模块划分合理(每个函数功能单⼀、可重⽤性好),使⽤空间尽可能少,算法尽可能⾼效。
实验报告1.实现功能描述使⽤线性表表⽰⼀元多项式完成多项式的加、减,乘,求导、求值运算。
2.⽅案⽐较与选择(1)因为使⽤的是线性表,所以主要⽅案有数组法和链表法。
(2)从时间复杂度来说,使⽤数组法更优;从空间复杂度来说,链表法更优。
因为数组法是指定好空间的,若式⼦⼤⼩超出设置⼤⼩,那程序必然出错;若式⼦⼤⼩⼩于设置⼤⼩,那就意味着有多余的空间被浪费了。
综合来讲,若计算式⼦较为庞⼤,使⽤链表法更佳;相反,若计算式⼦较⼩,数组法更佳。
3.设计算法描述(1)单个项式的数据存储使⽤了结构体,数组法是在⼀个结构体中定义两个⼀维数组;链表法是通过⼀个结构体作为⼀个节点,通过next指针连接起来。
线性表的基本运算及多项式的算术计算
实验报告
(/ 学年第一学期)
课程名称数据结构A
实验名称线性表的基本运算及多项式的算术计算实验时间年月日指导单位
指导教师
学生姓名班级学号
学院(系) 专业
实验报告
○2删除表中所有元素值等于x的元素:
思路:遍历顺序表,没搜索到一次x,就将其后所有结点前移,考虑到x连续存在的情况,将所有结点前移之后,i自减,再循环进行。
代码:
template <class T>
bool SeqList<T>::DeleteX(const T &x)
流程图:
cout<<endl<<"起始: ";
a.Output(cout);
a.Reverse();
cout<<"逆置后:";
a.Output(cout);
a.DeleteX(k);
cout<<"删除后:";
a.Output(cout);
return 0;
}
(3)测试用例和结果:
输入顺序表长度为10:
输入十个数分别为1 3 5 5 6 8 4 2 5 9 :输入要删除的元素 5 :
实验报告流程图:
(2)完整代码:
#include <iostream>
using namespace std;
class Term
{
输入5x^5+4x^3:
输
输入4x^5+2x^3,并求出多项式的和:选择多项式相乘的功能:
输入4x^3+3x^2:
输入5x^5+6x^3+2x^2, 输出多项式的乘积:。
实验 线性表的应用
实验报告实验项目:线性表的运用实验器材: Vc++6.0编程工具系别: 电子信息工程系学号: 0632323姓名: 赵烨昕实验日期: 2008.10.17指导老师:______________________张玲_________________________________ 实验成绩:____________________________________________________________实验一线性表的应用一.实验目的:掌握线性链表的存储、运算及应用。
利用链表实现一元多项式计算。
二.实验步骤:(1)编写函数,实现用链表结构建立多项式;(2)编写函数,实现多项式的加法运算;(3)编写函数,实现多项式的显示;(4)测试:编写主函数,它定义并建立两个多项式,显示两个多项式,然后将它们相加并显示结果。
变换测试用的多项式,检查程序的执行结果。
三.程序清单:#include <stdio.h>#include <malloc.h>typedef struct node{ float coef; /*序数*/int expn; /*指数*/struct node *next; /*指向下一个结点的指针*/} PolyNode;void InitList(PolyNode *&L) /*初始化多项式单链表*/{L=(PolyNode *)malloc(sizeof(PolyNode)); /*建立头结点*/L->next=NULL;}int GetLength(PolyNode *L) /*求多项式单链表的长度*/{int i=0;PolyNode *p=L->next;while (p!=NULL) /*扫描单链表L,用i累计结点个数*/{i++;p=p->next;}return i;}PolyNode *GetElem(PolyNode *L,int i) /*返回多项式单链表中第i个结点的指针*/{int j=1;PolyNode *p=L->next;if (i<1 || i>GetLength(L))return NULL;while (j<i) /*沿next域找第i个结点*/{p=p->next;j++;}return p;}PolyNode *Locate(PolyNode *L,float c,int e) /*在多项式单链表中按值查找*/ {PolyNode *p=L->next;while (p!=NULL && (p->coef!=c ||p->expn!=e))p=p->next;return p;}int InsElem(PolyNode *&L,float c,int e,int i) /*在多项式单链表中插入一个结点*/ {int j=1;PolyNode *p=L,*s;s=(PolyNode *)malloc(sizeof(PolyNode));s->coef=c;s->expn=e;s->next=NULL;if (i<1 || i>GetLength(L)+1)return 0;while (j<i) /*查找第i-1个结点*p*/{p=p->next;j++;}s->next=p->next;p->next=s;return 1;}int DelElem(PolyNode *L,int i) /*在多项式单链表中删除一个结点*/{int j=1;PolyNode *p=L,*q;if (i<1 || i>GetLength(L))return 0;while (j<i) /*在单链表中查找第i-1个结点,由p指向它*/{p=p->next;j++;}q=p->next; /*q指向被删结点*/p->next=q->next; /*删除*q结点*/free(q);return 1;}void DispList(PolyNode *L) /*输出多项式单链表的元素值*/{PolyNode *p=L->next;while (p!=NULL){printf("(%g,%d) ",p->coef,p->expn);p=p->next;}printf("\n");}void CreaPolyList(PolyNode *&L,float C[],int E[],int n){int i;InitList(L);for (i=0;i<n;i++)InsElem(L,C[i],E[i],i+1);}void SortPloy(PolyNode *&L) /*对L的多项式单链表按expn域递增排序*/ {PolyNode *p=L->next,*q,*pre;L->next=NULL;while (p!=NULL){if (L->next==NULL) /*处理第1个结点*/{L->next=p;p=p->next;L->next->next=NULL;}else /*处理其余结点*/{pre=L;q=pre->next;while (q!=NULL && p->expn>q->expn) /*找q->expn刚大于或等于p->expn的结点*q的前驱结点*pre*/{pre=q;q=q->next;}q=p->next; /*在*pre结点之后插入*p*/p->next=pre->next;pre->next=p;p=q;}}}PolyNode *AddPoly(PolyNode *pa,PolyNode *pb){PolyNode *pc,*p1=pa->next,*p2=pb->next,*p,*tc,*s;pc=(PolyNode *)malloc(sizeof(PolyNode)); /*新建头结点*pc*/ pc->next=NULL; /*pc为新建单链表的头结点*/tc=pc; /*tc始终指向新建单链表的最后结点*/while (p1!=NULL && p2!=NULL){if (p1->expn<p2->expn) /*将*p1结点复制到*s并链到pc尾*/{s=(PolyNode *)malloc(sizeof(PolyNode));s->coef=p1->coef;s->expn=p1->expn;s->next=NULL;tc->next=s;tc=s;p1=p1->next;}else if (p1->expn>p2->expn) /*将*p2结点复制到*s并链到pc尾*/{s=(PolyNode *)malloc(sizeof(PolyNode));s->coef=p2->coef;s->expn=p2->expn;s->next=NULL;tc->next=s;tc=s;p2=p2->next;}else /*p1->expn=p2->expn的情况*/{if (p1->coef+p2->coef!=0) /*序数相加不为0时新建结点*s并链到pc尾*/{s=(PolyNode *)malloc(sizeof(PolyNode));s->coef=p1->coef+p2->coef;s->expn=p1->expn;s->next=NULL;tc->next=s;tc=s;}p1=p1->next;p2=p2->next;}}if (p1!=NULL) p=p1; /*将尚未扫描完的余下结点复制并链接到pc单链表之后*/else p=p2;while (p!=NULL){s=(PolyNode *)malloc(sizeof(PolyNode));s->coef=p->coef;s->expn=p->expn;s->next=NULL;tc->next=s;tc=s;p=p->next;}tc->next=NULL; /*新建单链表最后结点的next域置空*/return pc;}void main(){PolyNode *L1,*L2,*L3;float C1[]={3,6,5,7},C2[]={-9,8,11};int E1[]={2,0,15,4},E2[]={9,1,6};InitList(L1);InitList(L2);InitList(L3);CreaPolyList(L1,C1,E1,4);CreaPolyList(L2,C2,E2,3);printf("两多项式相加运算\n");printf(" 原多项式A:");DispList(L1);printf(" 原多项式B:");DispList(L2);SortPloy(L1);SortPloy(L2);printf("排序后的多项式A:");DispList(L1);printf("排序后的多项式B:");DispList(L2);L3=AddPoly(L1,L2);printf("多项式相加结果:");DispList(L3);}实验结果如下:选作题:从终端输入多项式实现多项式相加。
数据结构 多项式 实验报告
数据结构实验报告实验名称:实验一——多项式的实现学生姓名:班级:班内序号:学号:日期:2011年10月29日1.实验要求实验目的:1.熟悉C++语言的基本编程方法,掌握集成编译环境的调试方法2.学习指针、模板类、异常处理的使用3.掌握线性表的操作的实现方法4.学习使用线性表解决实际问题的能力实验内容:利用线性表实现一个一元多项式Polynomialf(x) = a0 + a1x + a2x2 + a3x3+ … + a n x n要求:1.能够实现一元多项式的输入和输出2.能够进行一元多项式相加3.能够进行一元多项式相减4.能够计算一元多项式在x处的值5.能够计算一元多项式的导数(选作)6.能够进行一元多项式相乘(选作)7.编写测试main()函数测试线性表的正确性2. 程序分析由于多项式是线性结构,故选择线性表来实现,在这个程序中我采用的是单链表结构,每个结点代表一个项,多项式的每一项可以用其系数和指数唯一的表示。
如果采用顺序存储,那么对于结点的插入和删除的操作会比较麻烦,而且顺序表的结点个数固定,对于可能发生的情况无法很好的处理,而采用链表就会简单许多,还能自由控制链表的长度。
两个多项式要进行多次的计算,为了保护原始的数据,方便进行以后的计算,故选择把结果存储在一个新建的链表里。
本程序完成的主要功能:1.输入和输出:需要输入的信息有多项式的项数,用来向系统动态申请内存;多项式各项的系数和指数,用来构造每个结点,形成链表。
输出即是将多项式的内容向屏幕输出。
2.多项式相加与相减:多项式的加减要指数相同即是同类项才能实现,所以在运算时要注意判断指数出现的各种不同的情况,分别写出计算方法。
将每项运算得到的结果都插入到新的链表中,形成结果多项式。
3.多项式的求导运算:多项式的求导根据数学知识,就是将每项的系数乘以指数,将指数减1即可,将每项得到的结果插入到结果多项式的链表中。
4.多项式在某点的值:由用户输入x的值,然后求出每项的值相加即可。
实验一线性表操作实验报告
实验一_线性表操作_实验报告实验一:线性表操作一、实验目的1.理解线性表的基本概念和特点。
2.掌握线性表的基本操作,包括插入、删除、查找等。
3.通过实验,提高动手能力和解决问题的能力。
二、实验原理线性表是一种较为常见的数据结构,它包含零个或多个数据元素,相邻元素之间有前后关系。
线性表具有以下特点:1.元素之间一对一的顺序关系。
2.除第一个元素外,每个元素都有一个直接前驱。
3.除最后一个元素外,每个元素都有一个直接后继。
常见的线性表有数组、链表等。
本实验主要针对链表进行操作。
三、实验步骤1.创建链表:首先创建一个链表,并给链表添加若干个节点。
节点包括数据域和指针域,数据域存储数据,指针域指向下一个节点。
2.插入节点:在链表中插入一个新的节点,可以选择在链表的头部、尾部或中间插入。
3.删除节点:删除链表中的一个指定节点。
4.查找节点:在链表中查找一个指定数据的节点,并返回该节点的位置。
5.遍历链表:从头节点开始,依次访问每个节点的数据。
四、实验结果与分析1.创建链表结果:我们成功地创建了一个链表,每个节点都有数据域和指针域,数据域存储数据,指针域指向下一个节点。
2.插入节点结果:我们成功地在链表的头部、尾部和中间插入了新的节点。
插入操作的时间复杂度为O(1),因为我们只需要修改指针域即可。
3.删除节点结果:我们成功地删除了链表中的一个指定节点。
删除操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要删除的节点。
4.查找节点结果:我们成功地在链表中查找了一个指定数据的节点,并返回了该节点的位置。
查找操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要查找的节点。
5.遍历链表结果:我们成功地遍历了整个链表,并访问了每个节点的数据。
遍历操作的时间复杂度为O(n),因为我们可能需要遍历整个链表。
通过本次实验,我们更加深入地理解了线性表的基本概念和特点,掌握了线性表的基本操作,包括插入、删除、查找等。
实习一 线性表及其应用 (题目:一元稀疏多项式的加法运算 )
实习一线性表及其应用(题目:一元稀疏多项式的加法运算)一、需求分析1.输入并建立两个多项式;2.多项式a与b相加,建立和多项式c;3.输出多项式abc。
输出格式:比如多项式a为:A(x)=c1xe1+c2xe2+…+ cmxem,其中,ci和ei分别为第i项的系数和指数,且各项按指数的升幂排列,即0≤e1<e2<…<em。
多项式bc类似输出。
4测试数据(1)(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5)(2)(x+x100)+(x100+x200)=(x+2x100+x200)(3)(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11)实习一线性表及其应用题目:一元稀疏多项式的加法运算实习时间:2012/9/20.10.12一、需求分析1.输入并建立两个多项式;2.多项式a与b相加,建立和多项式c;3.输出多项式abc。
输出格式:比如多项式a为:A(x)=c1xe1+c2xe2+…+ cmxem,其中,ci和ei分别为第i项的系数和指数,且各项按指数的升幂排列,即0≤e1<e2<…<em。
多项式bc类似输出。
4测试数据(1)(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5)(2)(x+x100)+(x100+x200)=(x+2x100+x200)(3)(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11)二、设计1. 设计思想(1)存储结构用带头结点的单链表存储多项式。
三个多项式链表中都只存储非零系数项。
若多项式a与b中指数相等的两项相加后,系数为零,则在和多项式c中不存储该指数项。
(2)主要算法基本思想按照链表的基本操作,初始化三个链表,在两个链表中按指数由小到大分别插入a和b的多项式(系数和指数),将多项式a的链表复制给多项式c的链表,再调用求和函数(b的链表和c的链表相加),将求和的结果插入到c的链表中(作为多项式c)最后输出多项式a,b,c三个多项式。
线性表的基本运算
实习题目:线性表的基本运算及多项式的算术运算。
班级:姓名:学号日期: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的链表)。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
浙江大学城市学院实验报告课程名称数据结构与算法实验项目名称实验一线性表应用---多项式计算学生姓名专业班级学号实验成绩指导老师(签名)日期一.实验目的和要求1.进一步掌握线性表的的基本操作。
2.掌握线性表的典型应用----多项式表示与计算。
二. 实验内容1.设用线性表( (a1, e1), (a2, e2), ……, (am, em) )表示多项式P(x) = a1*x e1 + a2*x e2 +…+ am*x em,请编写用链式存储结构(带表头附加结点的单链表)存储该多项式时,多项式基本操作的实现函数。
要求:把多项式线性表的结构定义及多项式基本操作实现函数存放在文件Linkpoly.h中。
说明:基本操作可包括如下①初始化多项式InitPoly(p)②输出多项式TraversePoly(p)③清除多项式ClearPoly(p)④插入一项InsertPoly(p, a, e)⑤删除一项DeletetPoly(p, a, e, pos)⑥多项式求值PolySum(p, x)⑦多项式相加PolyAdd(p1, p2)2.建立主程序文件test1.cpp,在主函数main()中通过调用Linkpoly.h中的函数进行测试。
3.选做:编写用顺序存储结构存储多项式时,上述各多项式基本操作的实现函数。
要求:把多项式线性表的结构定义及多项式基本操作实现函数存放在文件Seqpoly.h中,在主程序文件test1.cpp中增加测试语句对Seqpoly.h 中的函数进行测试。
4.填写实验报告,实验报告文件取名为report1.doc。
5.上传实验报告文件report1.doc与源程序文件test1.cpp及Linkpoly.h、Seqpoly.h(若有)到Ftp服务器上自己的文件夹下。
三. 函数的功能说明及算法思路包括每个函数的功能说明,及一些重要函数的算法实现思路初始化多项式InitPoly(p)输出多项式TraversePoly(p)清除多项式ClearPoly(p)插入一项InsertPoly(p, a, e)删除一项DeletetPoly(p, a, e, pos)多项式求值PolySum(p, x)多项式相加PolyAdd(p1, p2)PolyAdd(p1, p2):将两个多项式中每一项进行比较,将小项放在前面,若一个多项式插完就直接插入另一个。
四. 实验结果与分析包括运行结果截图等五. 心得体会记录实验感受、上机过程中遇到的困难及解决办法、遗留的问题、意见和建议等。
这次的实验是利用线性表来存储多项式并进加法计算和求值【附录----源程序】Test1.cpp#include<iostream.h>#include<math.h>#include<stdlib.h>#include "Linkpoly.h" //链式结构库函数,调试时只打开一个//#include"Seqpoly.h" //顺序结构库函数,调试时只打开一个// 下列main函数采用链式结构实现,调试时只打开一个void main(){LNode *a,*b;double x;int e,pos;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=0;i<4;i++) InsertPoly(a,ra[i]);for(i=0;i<6;i++) InsertPoly(b,rb[i]);cout<<"多项式a为:";TraversePoly(a);cout<<"请输入要删除的项(系数)"<<endl;cin>>x;cout<<"请输入要删除的项(指数)"<<endl;cin>>e;cout<<"请输入要删除的项(参数)(-1:最后项0:指定项default:按顺序)"<<endl;cin>>pos;DeletetPoly(a,x,e,pos);//删除指定的项cout<<"修改后a为:";TraversePoly(a);cout<<"多项式b为:";TraversePoly(b);cout<<"输入多项式求值参数x:";cin>>x;cout<<"当x="<<x<<"时多项式a 的值为:"<<PolySum(a,x)<<endl;cout<<"当x="<<x<<"时多项式b 的值为:"<<PolySum(b,x)<<endl;cout<<"多项式a+多项式b的结果为:";LNode *c=PolyAdd(a,b);TraversePoly(c);ClearPoly(a);ClearPoly(b);}/*// 下列main函数采用顺序结构实现void main(){SeqList a,b;double x;int e,pos;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=0;i<4;i++) InsertPoly(a,ra[i]);for(i=0;i<6;i++) InsertPoly(b,rb[i]);cout<<"多项式a为:";TraversePoly(a);cout<<"请输入要删除的项(系数)"<<endl;cin>>x;cout<<"请输入要删除的项(指数)"<<endl;cin>>e;cout<<"请输入要删除的项(参数)(-1:最后项0:指定项default:按顺序)"<<endl;cin>>pos;DeletetPoly(a,x,e,pos);//删除指定的项cout<<"修改后a为:";TraversePoly(a);cout<<"多项式b为:";TraversePoly(b);cout<<"输入多项式求值参数x:";cin>>x;cout<<"当x="<<x<<"时多项式a 的值为:"<<PolySum(a,x)<<endl;cout<<"当x="<<x<<"时多项式b 的值为:"<<PolySum(b,x)<<endl;cout<<"多项式a+多项式b的结果为:";SeqList c=PolyAdd(a,b);TraversePoly(c);ClearPoly(a);ClearPoly(b);}*/Linkpoly.h//采用链式存储结构表示的多项式,链表不带表头结点的typedef struct{double coef;int exp;}ElemType;typedef struct Node{ElemType data;Node *next;} LNode;void InitPoly(LNode *&p) //初始化多项式链式结构P{p=new LNode;if(p==NULL)exit(1);p->next=NULL;}void TraversePoly(LNode *p) //输出多项式p{LNode *t=p->next;if(t==NULL)cout<<"多项式为空"<<endl;else{while (t!=NULL){cout<<"("<<t->data.coef<<","<<t->data.exp<<") ";t=t->next;}cout<<endl;}}void ClearPoly(LNode *&p)//清除多项式p{LNode *cp,*np;cp=p->next;while(cp!=NULL){np=cp->next;delete cp;cp=np;}p=NULL;}void InsertPoly(LNode *&p, ElemType item) //插入一项item,按指数顺序插入{LNode *np,*t;t=p;np=new LNode;np->data=item;while(t->next){if(t->next->data.exp>item.exp)break;t=t->next;}np->next=t->next;t->next=np;}void DeletetPoly(LNode *&p, double a, int e,int pos)//删除:系数为a、指数为e的这一项{if(p->next==NULL){cout<<"多项式为空"<<endl;return;}if(pos<-1){cout<<"参数不合法!!!"<<endl;return;}LNode*cp,*ap;cp=p->next;ap=p;if(pos==0){while(cp!=NULL){if((cp->data.coef==a)&&(cp->data.exp==e)) break;else{ap=cp;cp=cp->next;}}if(cp==NULL){cout<< "没有相应的项可删除!"<<endl;return;}}else if(pos == -1)while ( cp->next != NULL){ap=cp;cp=cp->next;}else{int i=0;while ( cp != NULL){i++;if (i==pos) break;else{ap=cp;cp=cp->next;}}if ( cp==NULL){cout<<"参数不合法!!!"<<endl;return;}}ap->next=cp->next;delete cp;}double PolySum( LNode *p, double x ) //多项式求值{LNode *t = p->next;double sum = 0;int e;while ( t!= NULL){e = t->data.exp;sum = sum + t->data.coef * pow(x, e);t = t->next;}return sum;}LNode* PolyAdd( LNode *p1, LNode *p2) //两个多项式相加{LNode *p3;p3 = new LNode; //p3为相加后的多项式,带有头结点LNode *t1=p1->next, *t2=p2->next, *t3=p3;double a;while ( t1 && t2 ){//把指数项小的插入到p3链表的表尾中if ( t1->data.exp < t2->data.exp ){t3->next = new LNode;t3 = t3->next;t3->data = t1->data;t1= t1->next;}else if ( t1->data.exp > t2->data.exp ){t3->next = new LNode;t3 = t3->next;t3->data = t2->data;t2= t2->next;}else{a = t1->data.coef + t2->data.coef;if (a!=0){ //加后系数为0时,不需要插入t3->next = new LNode;t3 = t3->next;t3->data.coef = a;t3->data.exp = t1->data.exp;}t1= t1->next;t2= t2->next;}}while ( t1 ){ //复制t1,t2中的剩余项(结点)t3->next = new LNode;t3 = t3->next;t3->data = t1->data;t1= t1->next;}while ( t2 ){t3->next = new LNode;t3 = t3->next;t3->data = t2->data;t2= t2->next;}t3->next = NULL;return p3;}Seqpoly.h//采用顺序存储结构表示的多项式typedef struct{double coef;int exp;} ElemType;typedef struct{ElemType* list; //动态存储空间的首地址int size; //当前元素的个数int MaxSize; //动态存储空间的大小} SeqList;void InitPoly(SeqList &p) //初始化多项式顺序结构P{p.MaxSize=10;p.list=new ElemType[p.MaxSize];if(p.list==NULL){cout<<"空间不足,退出"<<endl;exit(1);}p.size=0;}void TraversePoly(SeqList p) //输出多项式p{if(p.size==0)cout<<"多项式为空"<<endl;else{for(int i=0;i<p.size;i++)cout<<"("<<p.list[i].coef<<","<<p.list[i].exp<<") ";cout<<endl;}}void ClearPoly(SeqList &p)//清除多项式p{if(p.list!=NULL){delete []p.list;p.list=NULL;}p.size=0;p.MaxSize=0;}void InsertPoly(SeqList &p, ElemType item) //插入一项item,且每次均在表尾插入{if(p.size==p.MaxSize){p.list =(ElemType *)realloc(p.list ,2*p.MaxSize*sizeof(ElemType));//扩大,原数据不变if(p.list==NULL){cout<<"动态可分配的存储空间用完,退出运行!"<<endl;exit(1);}p.MaxSize=2*p.MaxSize ;//新分配的线性表大小}for(int i=0;i<p.size;i++){if(p.list[i].exp>item.exp)break;}for(int j=p.size-1;j>=i;j--){p.list[j+1]=p.list[j];}p.list[i]=item;p.size++;}void DeletetPoly(SeqList &p, double a, int e,int pos){int i;if ( p.size == 0){cout<<"多项式为空!!!"<<endl;return;}if ( pos < -1 || pos > p.size ){cout<<"参数pos不合法!!!"<<endl;return;}//找删除位置,赋值给posif (pos == 0){for ( i=0; i <p.size; i++)if((p.list[i].coef==a )&&(p.list[i].exp==e ))break;if (i == p.size){cout<<"没有相应的项可删除!"<<endl;return;}pos = i+1;}else if( pos == -1 )pos = p.size;//删除数据元素for ( i = pos; i <p.size ; i++)p.list[i-1] = p.list[i];p.size--;// 若线性表空余空间太多,重新分配压缩if (float (p.size) / p.MaxSize < 0.4 && p.MaxSize > 10 ){p.list= (ElemType *) realloc(p.list, p.MaxSize *sizeof(ElemType) / 2 );p.MaxSize /= 2;}}double PolySum( SeqList p, double x ){double sum=0;int e;for (int i=0; i<p.size; i++){e = p.list[i].exp;sum = sum + p.list[i].coef * pow(x, e);}return sum;}SeqList PolyAdd(SeqList p1, SeqList p2) //两个多项式相加{SeqList p3; //p1,p2为需相加的两个多项式,不带头InitPoly(p3);int k1=0,k2=0;double a;while ( k1<p1.size && k2<p2.size ){//把指数项小的插入到p3链表的表尾中if ( p1.list[k1].exp < p2.list[k2].exp ){InsertPoly(p3,p1.list[k1]);k1++;}else if ( p1.list[k1].exp > p2.list[k2].exp ){InsertPoly(p3,p2.list[k2]);k2++;}else{a = p1.list[k1].coef + p2.list[k2].coef;if (a!=0){ //加后系数为0时,不需要插入ElemType item;item.coef=a;item.exp=p1.list[k1].exp;InsertPoly(p3,item);}k1++;k2++;}}while ( k1<p1.size ) //复制p1,p2中的剩余项InsertPoly(p3,p1.list[k1++]);while ( k2<p2.size )InsertPoly(p3,p2.list[k2++]);return p3;}。