链表实现多项式相加实验报告
(2023)数据结构利用链表计算一元多项式课程设计实验报告(一)
(2023)数据结构利用链表计算一元多项式课程设计实验报告(一)2023数据结构课程设计实验报告——利用链表计算一元多项式实验背景和目的在本课程设计实验中,我们旨在通过使用链表数据结构,实现对一元多项式的计算功能。
通过本次实验,我们将深入学习和掌握链表的基础知识和应用技能,掌握实现链表操作的代码实现方式,提高编程实践能力和解决问题的能力。
思路和方法首先,我们需要定义链表节点数据结构,包含多项式中的系数和指数两个数据成员。
然后,我们需要实现一元多项式的相加、相减、求导、求值等基本操作。
其中,相加和相减操作需要利用链表遍历的方式,比较两个多项式中的指数,进行对应系数的加减,并将结果存储到新的链表中。
求导操作只需要遍历链表,将每一项的指数减一,系数乘以指数值,再将其插入到新的链表中即可。
求值操作仅需要遍历链表,根据指数和系数计算多项式值即可。
在具体实现过程中,我们需要注意边界条件的判断和处理,如何处理空链表、单项式情况等。
还需要精细设计代码逻辑,避免重复遍历链表,浪费时间和空间资源。
结果分析和展示经过数次测试和调试,我们最终实现了一元多项式的链表计算功能。
我们在终端输入多项式的系数和指数,再根据指令进行相应的操作。
结果能够准确输出,并且经过大量数据测试,程序运行稳定,没有出现崩溃和错误的情况。
总结和反思通过本次实验,我们进一步深入学习了链表数据结构的应用方法和相关算法。
我们学会了如何通过遍历链表实现复杂计算操作,如一元多项式的求导、求值等。
在实现过程中,我们对代码结构和逻辑设计进行反复思考和优化,提高了自己的编程能力和解决问题的能力。
同时,我们也需要进一步加强数据结构的学习,提升自己的算法水平,为后续的专业学习和职业发展打下坚实的基础。
可能的改进和优化方案虽然我们已经实现了一元多项式链表计算功能,但是我们也发现了以下几点可以改进和优化的方案:•异常处理:在用户输入有误或者数据不规范的情况下,程序可能会出现崩溃或者不符合预期的结果。
多项式加法实验报告
题目:多项式加法多项式加法一、课题概述线性表是一种最简单、最基本,也是最常用的数据结构,其用途十分广泛,例如,用带表头结点的单链表求解一元整系数多项式加法和乘法运算。
现给两个一元整系数多项式,请求解两者之和。
输入两组数据,每一组代表一个一元整系数多项式,有多行组成,其中每一行给出多项式每一项的系数和指数,这些行按指数递减次序排序,每一组结束行为0 -1。
输出三组数据,前两组为一元整系数多项式,最后一组为两个多项式的和。
一元整系数多项式输出形式如下:(1)多项式项4x输出为4X(2)多项式项4x2输出为4X^2(3)第一项系数为正数时,加号不要输出(4)除常系数项外,项系数为1不显式输出,-1输出为-例如,4x3- x2+x-1正确输出形式为4X^3-X^2+X-1,错误输出形式为+4X^3-1X^2+1X-1二、设计与实现1、类的层次关系及核心算法分析:项节点类Trem中定义了三个私有变量,系数coef、指数exp和指向下一个项节点的指针域link。
多项式类Polynominal被声明成项节点类Trem类的友元类。
公有函数InsertAfter构造一个新的项节点,其系数为c指数为e,并将新节点插入在调用该函数的项节点及后继节点之间。
多项式类Polynominal中包含了3个公有成员函数:AddTerms,Output和PolyAdd。
AddTerms函数通过输入流in,输入多项式的各项构造一个多项式的单循环链表;Output函数将多项式按降幂方式送输出流;PolyAdd函数实现将多项式r加到指针this指示的多项式上。
AddTerms函数从输入流in按降幂输入各项(c,e)来构造多项式的单循环链表,当输入(0,-1)是构造过程结束。
Output函数遍历单循环链表将多项式按降幂方式送输出流,它调用项类Trem 上重载的“<<”操作符实现按项输出。
多项式加法,设有多项式p(x)和q(x),分别用单循环链表表示。
实验三链表及其多项式相加 - 副本
实验三、链表及其多项式相加一、实验目的1.了解线性表的链式存储结构,熟练掌握链表。
2.了解作为链表的多项式存贮方式。
3.熟悉掌握多项式加法的算法。
二、实验原理顺序存储的线性表有一些弱点,其一,插入与删除元素需要大量移动元素;其二,预先分配存储空间时必须按最大的空间来分配。
其三,表长难以扩充。
所以,必须引入链式存储结构。
链式存储结构的特点是用一组任意的存储单元存储线性链表的数据元素,与顺序表的区别在于链式存储的存储单元可以是连续的,也可以是不连续的。
为了实现这种结构,链表采取由两部分信息组成数据元素a i的存储映像,称为结点。
结点包括两个域,其中存储数据信息的域称为数据域,存储直接后继信息的称为指针域。
指针域中存储的信息叫做指针或链。
这样,n个结点链接成一个链表,即为线性表(a1,a2,a3,···,a n)。
1.符号多项式的操作,已经成为表处理的典型用例,在数学上,一个一元多项式pn(x)可以按升幂写成:pn(x)=p0+p1·x+p2·(x的2次幂)+···+p n·(x的n次幂)。
它由n+1个系数唯一确定。
因此,在计算机里,它可用一个线性表P来表示:P=(p0,p1,p2,···,p n), 显然,此种表示仅适于顺序存储结构,在通常的应用中,多项式的次数变化很高且很大,将造成内存的很大浪费。
2.实现单链表就地逆置。
三、实验要求1.参照书上的原理说明分析程序,深入理解链表的物理存储模式和逻辑模式。
2.看懂书上算法,参考实验程序编出程序上机调试。
3.参考书上的程序,编写建立链表存储多项式,并实现两多项式相加。
四、代码实现:1.# include<stdio.h># include<stdlib.h>typedef struct Polynode{int coef;int exp;Polynode *next;}Polynode,* Polylist;Polylist polycreate(){Polynode * head,*rear,*s;int c,e;head=(Polynode *)malloc(sizeof(Polynode)); rear=head;scanf("%d,%d",&c,&e);while(c!=0){s=(Polynode *)malloc(sizeof(Polynode));s->coef=c;s->exp=e;rear->next=s;rear=s;scanf("%d,%d",&c,&e);}rear->next=NULL;return (head);}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);}}else{tail->next=q;tail=q;q=q->next;}}if(p==NULL)tail->next=p;elsetail->next=q;}void main(){Polynode *p;printf("请输入第一个多项式,次数从低到高:\n"); Polylist A=polycreate();printf("\n多项式创建完成!\n");printf("\n请输入第二个多项式,次数从低到高:\n"); Polylist B=polycreate();printf("\n多项式创建完成!\n\n");polyadd(A,B);p=A->next;while(p!=NULL){printf("[%d %d] ",p->coef,p->exp);p=p->next;}printf("\n\n");}2.# include<stdio.h># include<stdlib.h>typedef struct Node{char data;struct Node * next;}Node,* Linklist;void Initlist(Linklist *L){*L=(Linklist)malloc(sizeof(Node));(*L)->next=NULL;}void CreateFromHead(Linklist L){Node *s;char c;int flag=1;while(flag){c=getchar();if (c!='$'){s=(Node *)malloc(sizeof(Node));s->data=c;s->next=L->next;L->next=s;}else flag=0;}}void Reverselist(Linklist L){Linklist p,q;p=L->next;L->next=NULL;while(p!=NULL){q=p->next;p->next=L->next;L->next=p;p=q;}}void main (){Linklist p;Linklist L;Initlist(&L);printf("Please input datas:\n");CreateFromHead(L);p=L;while (p->next!=NULL){p=p->next;printf("%c ",p->data);}Reverselist(L);printf("\n\n");}五:结果验证:1.2。
多项式相加相乘链表实现模板
实验一:两个多项式相加相乘链表实现学生姓名:#班级:@12学号:完成时间:2015.06.25本人郑重声明:本实验的程序代码编写与调试、实验报告的撰写均由本人独立完成,如被发现抄袭或与其他同学作业雷同,同意取消该实验成绩!声明人:#2015.06.25【实验内容】I.设计构造两个链式线性表,用来表示两个一元多项式II.程序允许用户手工输入这两个线性表,每个线性表中的每个数据元素包含两个值,系数Pi和幂qi;输入方式自定;III.程序对两个多项式进行相加,然后输出一个相加后的一元多项式。
IV.两个多项式相乘(选做)。
【编程思路】1.创建链表:先分别输入两个多项式的项数以及调用Createlist()函数按降幂顺序输入各项的系数和次数,构建出两个多项式的链表。
两个多项式的系数和次数同样按降幂顺序存入两个线性表a、b中,头结点分别为head_a,head_b。
2.多项式相加:创建一个新链表,作为相加后所得结果的多项式的链表寄存处。
定义两个临时链表节点指针pa和pb,分别指向两个链表头结点的下一位(注:链表的头结点不存项)。
通过比较两个多项式的首项确定最高次幂,用max_qi记录。
然后用一个for循环从两个链表中寻找,判断pa和pb当前位置有无次数为i(i为循环变量)的项,有则合并同类项。
如果pa、pb次数等于i,两对应系数相加,和其系数一起存入新节点中,再将新节点插入新链表中,pa、pb随后后移一个单位;如果pa的次数小于i,pb次数等于i,则只加pb项,也存入新节点并插入新链表中,随后pb向后移动一个单位;如果pb的次数小于i,pa次数等于i,处理方法与上一种情况类似。
如果pa和pb次数均小于i,则i减小1,进入下一次循环,再作比较。
若pa或pb为空,则将不为空的多项式链表的剩余项逐一赋给新链表即可。
3.多项式相乘:创建一个新链表,作为相乘后所得结果的多项式的链表寄存处。
定义两个临时链表节点指针pa和pb,分别指向两个链表头结点的下一位。
多项式加法的链表设计与实现
printf("coef:");
scanf("%d",&c); /*输入系数*/
printf("exp: ");
scanf("%d",&e); /*输入指针*/
while(c!=0) /*输入系数为0时,表示多项式的输入结束*/
//////补充代码......
pre->next=p;
}
else if(p->exp==q->exp) /*若指数相等,则相应的系数相加*/
{
sum=p->coef+q->coef;
if(sum!=0)
{/*将p结点加入到和多项式中,删除结点q*/
p->coef=sum;
pre->next=p;pre=pre->next;p=p->next;
polyb=create(); /*调用建立链表函数,创建多项式B*/
print(polyb);
printf("Sum of the poly is:\n");
polyadd(polya,polyb); /*调用一元多项式相加函数*/
print(polya); /*调用输出函数,打印结果*/
printf("\n");
存放在多项式polya中,并将多项式ployb删除*/
{
node *p,*q,*pre,*temp;
int sum;
p=polya->next;/*令p和q分别指向polya和polyb多项式链表中的第一个结点*/
(链表实现)写出两个一元多项式相加的算法
(链表实现)写出两个⼀元多项式相加的算法int c, e;head=new node; //⽣成头结点head->next=NULL;cout<<"请分别输⼊新的⼀项的系数、指数(以输⼊9999作为结束):"<<endl;cin>>c>>e;while(c!=9999 && e!=9999) //输⼊并检测结束{s=new node; //⽣成新结点s->co = c; //装⼊数据s->exp = e;p=head;while(p->next!=NULL){p=p->next;}p->next = s; //插到最后⼀个结点后s->next = NULL;cout<<"请分别输⼊新的⼀项的系数、指数(以输⼊9999作为结束):"<<endl;cin>>c>>e;}return head;}void Display(node * head){if(head==NULL){cout<<"多项式不存在!"<<endl;return ;}node* p;p=head->next;while(p!=NULL){if(p->co>0)cout<<p->co<<"x^"<<p->exp;elsecout<<"("<<p->co<<")"<<"x^"<<p->exp;if(p->next!=NULL)cout<<"+";p=p->next;}cout<<endl<<endl;}node* Add(node * A, node * B){node * C=new node;C->next=NULL;node * p1=A->next;node * p2=B->next;node * p3;node * rearC=C;while(p1!=NULL && p2!=NULL){。
数据结构多项式相加实验报告doc
数据结构多项式相加实验报告篇一:数据结构实验多项式加法数据结构实验报告实验名称:多项式加减法学号:1XX10419姓名:林强实验日期:XX.5.05一、实验目的通过实现多项式的加减法,对链表有更深入的了解二、实验具体内容1、实验题目1:(1)题目设计一个一元稀疏多项式简单的加减法计算器实现要求:一元稀疏多项式简单计算器的基本功能是:(1)输入并建立多项式:A(x)?7?3x?9x8?5x17;B(x)?8x?22x7?9x8(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->expnexpn){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 请输入数据:" 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){coutnext->coefnext->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链表各项相乘的新生成节点单独构成一链表,并将第一个链表加入另一新链表,循环此操作将后生成的链表加之先前的链表,即可实现排序问题。
用链表实现多项式及其操作
通信韩若冰222010315220106实验项目:线性表及其应用实验内容:用单链表存储多项式;实现多项式的输出显示、相加、相乘、求导、求值运算。
算法设计与程序实现:由于存储多项式需要存储系数和指数,且其指数变化范围可能很大如果用顺序表就会浪费很大的空间,用单链表存取指针域,和数据域(系数和指数)就会节省很大空间。
要想实现多项式的显示,相加,相乘,求导,求值运算,首先得创建函数以实现上述功能,然后再在主函数中调用上述函数以得到运行结果。
算法描述:(实验内容的核心算法)创建链表:首先创建空表,然后将每个结点用尾插法依次插入。
每一项多项式的组成部分(系数和指数)输出程序:此程序需要遍历整个链表,通过判断p->next的系数的正负来确定输出“+”还是“-”很容易出现错误。
多项式相加:这个程序需要按照幂的排列顺序依次遍历寻找一个多项式与另一个多项式指数相同的,将其系数相加比较简单。
该程序写成升幂比较,其中可能出现如A多项式的前几项都比B中的指数小,那么以一个pre为头结点的链表先将其穿起来,找到相等的进行运算再串起来,最后可能会有链表剩余的指数更大的项不能和另一个相加再将剩余的串起来。
(第一项要先串起来,因为第一项之前没有多项式不用判断+ —号)多项式相乘:此程序需要循环语句,即将一个多项式的每一项分别和另一个多项式相乘,依次调用多项式相加的程序叠加起来。
多项式求导:需要依次将多项式的每一项的系数和指数相乘,指数减1,形成一个链表多项式求值:需要有x的幂次的表示,C语言不能识别“^”,所以需要用一个循环实现x^exp相乘的结果,容易出错核心程序:运行结果:实验总结:本次试验做了很长时间,也出现了很多错误。
总起来说有以下几种错误:1.输入错误:中英文状态下输入错误,其中还有运行时在中文状态下输入数据回车后就不能输了,应在英文状态下输入data , data↙2.多项式表示需要判断下一个多项式系数是正还是负然后分别写+, —(fabs),但是第一项必须先输出,因为第一项不需要写+ —号3.多项式相加,要注意写的程序是怎么比较的,升幂的话则p->exp < q->exp 则把p结点指数小的先穿起来。
实验报告编写一个程序用单链表存储多项式,并实现两个多项式相加的函数
实验报告编写一个程序用单链表存储多项式,并实现两个多项式相加的函数/*多项式加法和乘法示例*/#include<list>#include<iostream>#include<cassert>usingnamespacestd;//定义多项式的项类classterm{public:intcoef;//多项式系数intexp;//多项式指数//初始化项的系数和指数term(intc=0,inte=0):coef(c),exp(e){}};//定义多项式类classPolyArith{private:list<term>m_poly_list_first;//存储第一个多项式list<term>m_poly_list_second;//存储第二个多项式list<term>m_poly_list_result;//用以存储运算结果//多项式私有成员函数,用以乘法时的调用list<term>Poly_add(list<term>&poly_list_first,\list<term>&poly_list_second){list<term>poly_list_result;//用以存储运算结果list<term>::iteratoriter_first=poly_list_first.begin();list<term>::iteratoriter_second=poly_list_second.begin();//该while循环针对两个链表迭代器都没有指到结尾的情形while(iter_first!=poly_list_first.end()&&\iter_second!=poly_list_second.end()){termt_temp;termt_first=(term)*iter_first;termt_second=(term)*iter_second;if(t_first.exp>t_second.exp){poly_list_result.push_back(t_first);iter_first++;}elseif(t_second.exp>t_first.exp){poly_list_result.push_back(t_second);iter_second++;}else{t_temp.coef=t_first.coef+t_second.coef;t_temp.exp=t_first.coef;poly_list_result.push_back(t_temp);iter_first++;iter_second++;}}//该for循环针对第一个多项式的迭代器没有指到结尾//第二个指到结尾的情形for(;iter_first!=poly_list_first.end();iter_first++){poly_list_result.push_back(*iter_first);}//该for循环针对第二个多项式的迭代器没有指到结尾//第一个指到结尾的情形for(;iter_second!=poly_list_second.end();iter_second++){poly_list_result.push_back(*iter_second);}returnpoly_list_result;}public://输入函数,用以输入多项式voidPoly_input(){intn;cout<<"请输入第一个多项式的项数:"<<endl;cin>>n;cout<<"按降幂输入第一个多项式的每一项的系数和指数:"; cout<<endl;for(inti=1;i<=n;i++){termt_temp;cout<<"请输入第"<<i<<"项系数和指数,以'enter'为界:"; cout<<endl;cin>>t_temp.coef;cin>>t_temp.exp;m_poly_list_first.push_back(t_temp);}n=0;cout<<"请输入第二个多项式的项数:"<<endl;cin>>n;cout<<"按降幂输入第二个多项式的每一项的系数和指数:"; cout<<endl;for(intj=1;j<=n;j++){termt_temp;cout<<"请输入第"<<j<<"项系数和指数,以'enter'为界:"; cout<<endl;cin>>t_temp.coef;cin>>t_temp.exp;m_poly_list_second.push_back(t_temp);}}//输出函数,用以输出多项式voidPoly_output(){//用以指向输出多项式的第一个元素list<term>::iteratoriter=m_poly_list_result.begin();//输出多项式的每一项for(;iter!=m_poly_list_result.end();){termt_temp=*iter;cout<<t_temp.coef<<"x^"<<t_temp.exp;if(++iter!=m_poly_list_result.end())cout<<"+";}cout<<endl;}//加法函数,其基本思想同上边的私有成员函数Poly_add() //此处不带参数,多项式运算对象为私有数据成员voidPoly_add(){list<term>::iteratoriter_first=m_poly_list_first.begin();list<term>::iteratoriter_second=\m_poly_list_second.begin();while(iter_first!=m_poly_list_first.end()&&\iter_second!=m_poly_list_second.end()){termt_temp;termt_first=(term)*iter_first;termt_second=(term)*iter_second;if(t_first.exp>t_second.exp){m_poly_list_result.push_back(t_first);iter_first++;elseif(t_second.exp>t_first.exp){m_poly_list_result.push_back(t_second);iter_second++;}else{t_temp.coef=t_first.coef+t_second.coef;t_temp.exp=t_first.exp;m_poly_list_result.push_back(t_temp);iter_first++;iter_second++;}}for(;iter_first!=m_poly_list_first.end();iter_first++){m_poly_list_result.push_back(*iter_first);}for(;iter_second!=m_poly_list_second.end();iter_second++) {m_poly_list_result.push_back(*iter_second);}}//乘法函数,用以作多项式乘法voidPoly_multi(){list<term>poly_list_result;list<term>::iteratoriter_first=m_poly_list_first.begin();for(;iter_first!=m_poly_list_first.end();iter_first++){list<term>poly_list_temp;//用以存储多项式的中间运算结果list<term>::iteratoriter_second=\m_poly_list_second.begin();for(;iter_second!=m_poly_list_second.end();\iter_second++){termt_temp;//用以存储项的中间运算结果termt_first=(term)*iter_first;termt_second=(term)*iter_second;//此处实现多项式项的相乘t_temp.coef=t_first.coef*t_second.coef;//系数相乘t_temp.exp=t_first.exp+t_second.exp;//指数相加poly_list_temp.push_back(t_temp);//此处调用私有成员函数Poly_add()poly_list_result=\Poly_add(poly_list_temp,poly_list_result);}//将运算结果赋值给私有数据成员,用以输出m_poly_list_result=poly_list_result;}};//测试函数intmain(){cout<<"************本程序实现多项式的加法与乘法************"; cout<<endl;PolyArithpoly_a;poly_a.Poly_input();//输入多项式poly_a.Poly_add();//多项式加法cout<<"多项式加法的运算结果:"<<endl;poly_a.Poly_output();//输出多项式cout<<endl;poly_a.Poly_multi();//多项式乘法cout<<"多项式乘法的运算结果:"<<endl;poly_a.Poly_output();system("pause");return0;}。
数据结构:链表的应用-求两个一元多项式之和
!= NULL && p2 == NULL) || (p1 == NULL && p2 != NULL)) || p1 != NULL || p2 != NULL) { if(p1 == NULL && p2 != NULL) {
Pnode pnew = (Pnode)malloc(sizeof(Pnode)); if(NULL == pnew) { exit(-1); }
printf("\n"); }
int main(void) {
Pnode p1,p2; int a,b; char x;
printf("输入未知字母(如 x,y,z 等):"); scanf("%c",&x);
精美文档
5
printf("输入第一个多项式的项数:"); scanf("%d",&a); p1 = init(a);
printf("输入幂数:"); scanf("%d",&b); pnew->mi = b;
精美文档
2
ptail->next = pnew; pnew->next = NULL;
ptail = pnew; }
return phead; }
Pnode jia(Pnode p1,Pnode p2) {
构建中止 未命名 2: 15 个错误, 1 个警告
2.最后一次调试
--------------------配置: mingw5 - CUI Debug, 编译器类型: MinGW--------------------
链式存储结构实现多项求和实验报告
链式存储结构实现多项求和实验报告课题设计目的:了解数据结构与算法的设计方法,独立分析和设计一元多项式加减的程序编码,通过程序编写掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能,提高综合运用所学的理论知识和方法独立分析和解决问题的能力,通过这次实践将实际问题中所涉及的对象在计算机中表示出来并对它们进行处理,掌握线性表的链式存储如何实现一元多项式的加减。
课题设计意义:通过完成此次课题,可以了解各种数据结构内在的逻辑关系,讨论它在计算机中的存储表示,以及在其上进行各种运算时的算法实现,并对算法的效率和优化进行简单的分析和讨论,不仅加强了学生对于线性表链式存储的理解,也提高了学生的思维能力,促进学生的综合应用能力和专业素质的提高。
线性表的链式存储,多项式的加减乘除四则运算报告
多项式实验报告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;}/*乘法,先用第一个链表的第一个数据乘以第二个链表里的所有值,储存在新的链表中,之后遍历一中所有的值,最后把这些多项式加在一起。
数据结构多项式相加实验报告
试验一多项式相加一. 实验内容:多项式相加二.实验目的和要求:利用双向链表实现通讯录的建立、删除、检索和列表,并可保存至文件,可重新装入。
用链式存储结构实现一元多项式的相加运算。
三.算法思想描述: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. 主函数调用,完成多项式相加。
数据结构利用线性表链式存储实现一元多项式相加减课程方案实验报告
数据结构课程设计设计题目:利用线性表链式存储实现一元多项式相加减目录第一章、课题描述1第二章、课题设计目的1第三章、课题设计意义1第四章、设计思路1第五章、需求分析2第六章、概要设计26.1、存储结构:26.2、基本算法:26.2.1、输入输出26.2.2、构造数据类型36.2.3、多项式的加法46.2.4、多项式的减法4第七章、程序结果及截图4第八章、算法的时间复杂度及改进5 第九章、总结及心得体会5第十章、附录6第十一章、参考文献13第一章、课题描述能够完成两个或多个多项式的输出,并且实现两个多项式的相加和相减,并且输出结果。
第二章、课题设计目的了解数据结构与算法的设计方法,独立分析和设计一元多项式加减的程序编码,通过程序编写掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能,提高综合运用所学的理论知识和方法独立分析和解决问题的能力,通过这次实践将实际问题中所涉及的对象在计算机中表示出来并对它们进行处理,掌握线性表的链式存储如何实现一元多项式的加减,通过不断探索程序的算法,不断优化程序,使得学生的知识掌握更加牢固,实践能力加强,也激发了学生对于数据结构这门课的兴趣,为以后这门课的深入研究做了准备,这次实践使同学更加深入了解了数据结构内在的逻辑关系。
第三章、课题设计意义通过完成此次课题,可以了解各种数据结构内在的逻辑关系,讨论它在计算机中的存储表示,以及在其上进行各种运算时的算法实现,并对算法的效率和优化进行简单的分析和讨论,不仅加强了学生对于线性表链式存储的理解,也提高了学生的思维能力,促进学生的综合应用能力和专业素质的提高,解决了现实生活中复杂繁琐的计算过程,不仅提高了效率,也增加了正确率,学生对于线性表和指针等知识的理解更加深入深刻,也灵活运用了理论知识解决了实际问题,活学活用,加强了学生的实践能力,同时完成作业还需要与同学的讨论,增强了学生的团队合作能力。
第四章、设计思路这个程序的关键是多项式的创建和排列,以及相加时相同指数的系数相加。
链表-实验报告
实验2 链表实验概述:一、实验目的本次实习的主要目的是为了使学生熟练掌握链表的基本操作以及在链式存储结构上的实现,包括创建、插入、删除、查找、以及合并等操作。
二、实验要求掌握链表存储方式,熟悉链式存储结构。
三、实验步骤用链表结构实现对多项式初始化、创建、插入、删除等运算。
步骤:输入第一个多项式:7x+2x3输入第二个多项式:8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果:15x+2x3+9x5实验结果如图:四、实验环境(使用的软件和设备)(1)实习器材:多媒体计算机。
(2)实习地点:校内多媒体机房。
(3)实习软件: Win-TC实验内容:【实验过程】(实验步骤、记录、数据、分析)实验过程(提示)输入第一个多项式:7x+2x3输入第二个多项式:8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果:15x+2x3+9x5【结果实验记录】(图形或图像)1.说明掌握情况#include<stdio.h>#include<stdlib.h>typedef struct{int sat1,sat2,sat3,sat4;}ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;LinkList InitList(){ LinkList L;L=(LinkList)malloc(sizeof(LNode)); L->next=NULL;return(L);}void InsLNode(LinkList L,ElemType x){ LinkList s,p;s=(LinkList)malloc(sizeof(LNode));s->data=x;p=L;while(p->next)p=p->next;s->next=NULL;p->next=s;}void AddPolyn(LinkList La,LinkList Lb){int sum;int a,b;LinkList pa,pb;pa=La->next;pb=Lb->next;a=pa->data.sat1;b=pb->data.sat1;sum=a+b;printf(" %dx%d exp",sum,pa->data.sat2);printf("+");printf(" %dx%d exp+",pa->data.sat3,pa->data.sat4); printf(" %dx%d exp\n",pb->data.sat3,pb->data.sat4);}void Print(LinkList L){ LinkList p;p=L->next;printf(" %dx%d exp",p->data.sat1,p->data.sat2); printf("+");printf(" %dx%d exp",p->data.sat3,p->data.sat4);}main() {LinkList La,Lb;ElemType c,b;int a,i;La=InitList();Lb= InitList();printf("Please input polynomial La:\n");scanf("%d %d",&c.sat1,&c.sat2);scanf("%d %d",&c.sat3,&c.sat4);InsLNode(La,c);printf("Please input polynomial Lb:\n");scanf("%d %d",&b.sat1,&b.sat2);scanf("%d %d",&b.sat3,&b.sat4);InsLNode(Lb,b);printf("polynomial La:");printf("\n");Print(La);printf("\n");printf("polynomial Lb:");printf("\n");Print(Lb);printf("\n");printf("La+Lb:");printf("\n");AddPolyn(La,Lb);printf("\n");getch();}2.裁图说明实验结果【心得体会、问题和建议】成绩:指导教师签名批阅日期:。
多项式的链表表示及运算实验报告
多项式的链表表示及运算实验报告
一、实验目的
本次实验旨在了解多项式的链表表示及运算,学习应用链表实现多项式的加减乘除运算。
二、实验原理
多项式是数学中一种常见的运算方式,它由若干个单项式(即常数、未知数以及未知数不同次幂的积)求和组成。
多项式通常可以用数组或链表来表示。
本实验采用链表表示多项式。
链表表示多项式可以用一个链表来存储多项式中的每一项,链表节点存储着每一项的系数和指数。
链表的头节点指向第一项。
在链表表示多项式时,我们可以定义一个结构体来表示节点,包含两个成员变量:系数和指数。
当我们对多项式进行加减乘除运算时,首先需要将多项式转换成链表形式,然后按照运算规则进行运算,最后将运算结果转换为多项式形式。
三、实验步骤
1、定义多项式节点结构体,包含系数和指数两个成员变量;
2、编写函数从命令行读取用户输入的多项式,按照指数降序的方式将多项式转换成链表形式;
3、编写函数完成多项式相加、相减、相乘、相除等运算,每种运算均需要将两个多项式转换成链表形式后进行;
4、编写函数将链表形式的多项式转换成多项式字符串;
5、在主函数中调用上述函数,进行多项式的读取、运算、转换并输出结果。
四、实验总结
本次实验学习了多项式的链表表示及运算,掌握了链表的基本操作,了解了多项式的四则运算的实现。
在实验中,我们成功地用链表实现了多项式的加减乘除运算,实现了从命令行读取多项式,并将其转换为链表,最后将链表转换为多项式字符串输出。
通过本次实验,我更加深刻地理解了链表及其应用,学会了运用链表实现算法,提高了编码能力。
数据结构单链表实现多项式加法的算法实现
上机实习三一,实验题目:单链表多项式加法算法实现二,实验目的:结合实际问题掌握线性表链式存储结构的C语言描述及运算算法的实现。
设计一个一元多项式加法器,界面为菜单形式。
程序功能:1、(菜单)主程序2、输入并建立多项式3、多项式a和b相加,建立多项式a+b。
4、输出多项式,输出形式为整数序列n,c1,e1,c2,e2,…,cn,en。
n是多项式的项数,ci、ei分别是第i项的系数和指数。
三,功能层次图主函数调用创建函数创建A和B多项式调用加多项式函数加A和B调用输出函数程序结束四,运行结果创建A表创建B表加两个A,B的多项赋给C式A,B,C的结果五,小结在做这个程序的时候,虽然遇到一些问题,但最后都被我解决,自信心上得到比较大的提升,这也是这次实践最大的收获。
同时,知识上的收获也是不可忽视的,亲手解决问题的过程也是很好的学习过程,并且积累了一些经验,相信会为以后的学习发展带来非常积极的帮助。
源代码:#include<stdio.h>#include<conio.h>#include<alloc.h>#include<stdlib.h>typedef struct pnode{float coef; /* xishu */int exp; /* zhishu */struct pnode *next;}polynode;polynode *createList(){float xishu;int zhishu;polynode *head,*r;r=malloc(sizeof(polynode));r->coef=0;r->exp=-1;r->next=r;head=r;printf("<<Input XiShu 111 to stop>>\n");printf("Input XiShu:");scanf("%f",&xishu);printf("Input ZhiShu:");scanf("%d",&zhishu);while(1){r->next=malloc(sizeof(polynode));r=r->next;r->coef=xishu;r->exp=zhishu;printf("Input XiShu:");scanf("%f",&xishu);if(xishu==111) break;printf("Input ZhiShu:");scanf("%d",&zhishu);}r->next=head;return head;}void display(polynode *head){int i=1;polynode *t;if(head==NULL){printf("List is empty\n");return;}t=head->next;printf("[%0.0f][%d]\t",head->coef,head->exp);while(1){printf("[%0.0f][%d]\t",t->coef,t->exp);t=t->next;i++;if(t==head) break;}}polynode *POLYADD(polynode *A,polynode *B) {int i,j,k;polynode *ptr,*q,*q1,*q2;float x;q1=A;q2=B;q=malloc(sizeof(polynode));q->coef=0;q->exp=-1;q->next=q;ptr=q;q1=q1->next;q2=q2->next;while((q1!=A)&&(q2!=B)){if(q1->exp==q2->exp){x=q1->coef+q2->coef;if(x!=0){q->next=malloc(sizeof(polynode));q=q->next;q->coef=x;q->exp=q1->exp;}q1=q1->next;q2=q2->next;}else{q->next=malloc(sizeof(polynode));q=q->next;if(q1->exp>q2->exp){q->coef=q2->coef;q->exp=q2->exp;q2=q2->next;}else{q->coef=q1->coef;q->exp=q1->exp;q1=q1->next;}}}while(q1!=A){q->next=malloc(sizeof(polynode));q=q->next;q->coef=q1->coef;q->exp=q1->exp;q1=q1->next;}while(q2!=B){q->next=malloc(sizeof(polynode));q=q->next;q->coef=q2->coef;q->exp=q2->exp;q2=q2->next;}q->next=ptr;return ptr;}char caiDan(){char ch;do{printf("1:Create A list\n");printf("2:Create B list\n");printf("3:Add Two Polylist\n");printf("4:Display Polylist\n");printf("5:Exit\n");printf("Please Choose:");}while(ch=getch(),ch!='1'&&ch!='2'&&ch!='3'&&ch!='4'&&ch!='5');return ch;}void main(){polynode *a,*b,*c;char ch;do{clrscr();ch=caiDan();printf("%c",ch);getch();printf("\n");switch(ch){case '1': printf("Create A list\n");a=createList();printf("A list was created successfully");getch();break;case '2': printf("Create B list\n");b=createList();printf("B list was created successfully");getch();break;case '3': c=POLYADD(a,b);printf("C(C=A+B) list was created successfully\n");getch();break;case '4': printf("A List:\t");display(a);printf("\nB List:\t");display(b);printf("\nC List:\t");display(c);getch();break;case '5': exit(0);}}while(ch!='5');}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验报告
课程名称:数据结构
题目:链表实现多项式相加
班级:
学号:
姓名:
完成时间:2012年10月17日
1、实验目的和要求
1)掌握链表的运用方法;
2)学习链表的初始化并建立一个新的链表;
3)知道如何实现链表的插入结点与删除结点操作;
4)了解链表的基本操作并灵活运用
2、实验内容
1)建立两个链表存储一元多项式;
2)实现两个一元多项式的相加;
3)输出两个多项式相加后得到的一元多项式。
3、算法基本思想
数降序存入两个链表中,将大小较大的链表作为相加后的链表寄存处。
定义两个临时链表节点指针p,q,分别指向两个链表头结点。
然后将另一个链表中从头结点开始依次与第一个链表比较,如果其指数比第一个小,则p向后移动一个单位,如相等,则将两节点的系数相加作为第一个链表当前节点的系数,如果为0,则将此节点栓掉。
若果较大,则在p前插入q,q向后移动一个,直到两个链表做完为止。
4、算法描述
用链表实现多项式相加的程序如下:
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
struct node{
int exp;
float coef;
struct node*next;
};
void add_node(struct node*h1,struct node*h2);
void print_node(struct node*h);
struct node*init_node()
{
struct node*h=(struct node*)malloc(sizeof(struct node)),*p,*q;
int exp;
float coef=1.0;
h->next=NULL;
printf("请依次输入多项式的系数和指数(如:\"2 3\";输入\"0 0\"时结束):\n");
p=(struct node*)malloc(sizeof(struct node));
q=(struct node*)malloc(sizeof(struct node));
for(;fabs(coef-0.0)>1.0e-6;)
{
scanf("%f %d",&coef,&exp);
if(fabs(coef-0.0)>1.0e-6)
{
q->next=p;
p->coef=coef;
p->exp=exp;
p->next=NULL;
add_node(h,q);
}
}
free(p);
free(q);
return(h);
}
void add_node(struct node*h1,struct node*h2)
{
struct node*y1=h1,*y2=h2;
struct node*p,*q;
y1=y1->next;
y2=y2->next;
for(;y1||y2;)
if(y1)
{
if(y2)
{
if(y1->exp<y2->exp)
y1=y1->next;
else if(y1->exp==y2->exp)
{
y1->coef+=y2->coef;
if(y1->coef==0)
{
for(p=h1;p->next!=y1;p=p->next);
p->next=y1->next;
free(y1);
y1=p->next;
}
else
y1=y1->next;
y2=y2->next;
}
else if(y1->exp>y2->exp)
{
for(p=h1;p->next!=y1;p=p->next);
q=(struct node*)malloc(sizeof(struct node));
q->exp=y2->exp;
q->coef=y2->coef;
q->next=y1;
p->next=q;
y2=y2->next;
}
}
else
return;
}
else if(y2)
do{
q=(struct node*)malloc(sizeof(struct node));
q->exp=y2->exp;
q->coef=y2->coef;
q->next=NULL;
for(p=h1;p->next!=y1;p=p->next);
p->next=q;
y1=q;
y2=y2->next;
}while(y2);
else
return;
}
void print_node(struct node*h)
{
if(h->next==NULL)
printf("y=0\n");
else
{
printf("y=");
for(;h->next;)
{
h=h->next;
if(h->exp==0)
{
printf("%f",h->coef);
if(h->next&&h->next->coef>0.0)
printf("+");
}
else
{
printf("%fx%d",h->coef,h->exp);
if(h->next&&h->next->coef>0.0)
printf("+");
}
}
printf("\n");
}
}
main()
{
struct node*y1=(struct node*)malloc(sizeof(struct node));
struct node*y2=(struct node*)malloc(sizeof(struct node));
y1=init_node();
printf("第一个多项式为:\n");
print_node(y1);
y2=init_node();
printf("第二个多项式为:\n");
print_node(y2);
printf("两个多项式的和为:\n");
add_node(y1,y2);
print_node(y1);
}
5、测试数据与运行结果
输入多项式系数和指数后计算得到结果的截图为:
6、实验总结
此次上机实验应用了链表实现了一次实际操作,完成了一个一元多项式的简单相加,不仅对此次编译程序的算法思想有了新的认识,还让我深刻的体会到了链表的重要性以及其应用的方便,并且对指针加深了印象,应用了书本中的算法思想,对我以后的编译以及完成新的程序有很大的帮助。