【结构】数据结构多项式相加实验报告
数据结构实验2多项式求和
链式存储结构的实现调试结果如图所示：
6、结果分析与实验体会
本次实验是参考了X例程序，经过自己的改写，从而实现要求。
先做简单的输出，一步步的再做其它格式的设置。
而且，在具体操作中我对顺序存储结构和链式存储结构的优点和缺点有了更深刻的体会，顺序存储结构的算法较为简单，但是在输入的过程中有很大的局限性，必须从大到小依次且连续的输入多项式次数，所以，它只适合最高次数较小的多项式求和，而链式存储结构设计的算法则更灵活，输入时，不需要次数在数值上连续，所以，它更具有普遍性、实用性。
再从算法效率的角度来评价，顺序存储结构在做次数大小跨度大的多项式求和时，会浪费很多的存储空间，而链式存储结构则可以充分利用，不会浪费，即其空间复杂度较小。
最后，我想说，通过调试程序，我不光学会编程了的基本步骤、基本算法，也使自己更有耐心。
两个多项式相加实验报告
两个多项式相加实验报告主要实验内容：根据所学的数据结构中线性结构（线性表）的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加一、运行环境：visual C++二、需求分析(1)掌握线性结构的逻辑特性和物理特性(2)掌握线性结构的各种相关算法(3)掌握将算法转换成程序的方法和步骤(4)掌握采用线性结构解决实际问题。
三、概要设计1、抽象数据类型一元多项式的定义如下：ADT Polynomial { 数据对象：D＝{ a i | a i∈TermSet, i=1,2,...,m, m≥0TermSet 中的每个元素包含一个表示系数的实数和表示指数的整数 }数据关系：R1＝{ <a i-1 ,a i >|a i-1 ,a i∈D, i=2,...,n，且a i-1中的指数值＜a i中的指数值}基本操作：CreatPolyn ( &P, m )操作结果：输入 m 项的系数和指数，建立一元多项式 P。
DestroyPolyn ( &P )初始条件：一元多项式 P 已存在。
操作结果：销毁一元多项式 P。
PrintPolyn ( &P )初始条件：一元多项式 P 已存在。
操作结果：打印输出一元多项式 P。
PolynLength( P )初始条件：一元多项式 P 已存在。
操作结果：返回一元多项式 P 中的项数。
AddPolyn ( &Pa, &Pb )初始条件：一元多项式 Pa 和 Pb 已存在。
操作结果：完成多项式相加运算，即：Pa = Pa＋Pb，并销毁一元多项式 Pb。
SubtractPolyn ( &Pa, &Pb )… …} ADT Polynomial2、一元多项式的实现：typedef OrderedLinkList polynomial;// 用带表头结点的有序链表表示多项式结点的数据元素类型定义为:typedef struct { // 项的表示float coef; // 系数int expn; // 指数 term, ElemType;四、详细设计线性表的应用--多项式相加问题多项式的相加操作是线性表处理的典型例子。
数据结构线性表多项式加减实验报告
数据结构实验报告实验名称：实验一——线性表日期：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 结构类型，用来储存指定多项式的系数和指数的数据。
数据结构多项式实验报告
数据结构实验报告--Week05姓名：覃兆坤学号：10389355一、实验目的用线性表实现多项式的相关操作，加强对线性表的理解和练习，熟练对线性表的操作。
二、实验题目一个d阶多项式有如下形式：c d x d+c d−1x d−1+c d−2x d−2…+c0其中，c d≠0，指数都是非负数。
每一个c i x i是多项式中的一项。
设计一个C++的模板类Polynomial<T>，T给出系数的类型，要求能够实现多项式的表示和运算。
Polynomial类应该包括私有变量degree，和其他需要的变量。
对多项式的表示要求用线性表的形式，例如(c0,c1,c2,…,c d)表示系数表。
并设计以下成员函数和操作：(a) Polynomial()，创建零阶多项式，即构造函数(b) Degree()，返回多项式的阶数degree(c) Input()，输入多项式，指数升序依次输入每一项的指数和系数。
例如输入: 0 c0 1 c1 2 c2…d c d。
重载>>完成输入。
(d) Output()，输出多项式，和输入的格式相同。
重载<<完成输出。
(e) Add(b)，和b多项式相加，并返回结果多项式。
重载+。
(f) Subtract(b)，和b多项式相减返回结果多项式。
重载-。
(g) Multiply(b)，和b多项式相乘返回结果多项式。
重载*。
(h) Value(x)，返回x代入多项式的值。
重载( )，例如对于多项式对象P, P(x)能够返回代入x的多项式值。
三、实验设计设计方法：本次实现采用链表的结构，实现建立多项式，对多项式进行相加相减相乘求值的操作。
一共写了2个文件Polynomial.h和test.cpp文件。
其中前者实现多项式的相关功能，后者为人机交互式测试其功能。
1：Polynomial.h：共有2个类：Node为一个节点其中index; modulus; next 分别为指数，系数和指向下一个节点的指针。
数据结构多项式求和实验报告
1.实验题目设计一种用单链表存储多项式的结构（每个结点存储一项的系数和指数，类型都为int），并编写一个产生多项式链表的函数和一个实现两个多项式相加的函数。
2 .实验内容顺序存储结构的实现。
先输入多项式最高项数，然后按照（系数，指数）的格式输入顺序表类型定义如下：typedef struct term{int coef;int expn;struct term *next;}term,*Polynomial;3．实验要求（1）利用C语言完成算法设计和程序设计。
（2）上机调试通过实验程序。
（3）输入数据，检验程序运行结果。
（4）给出具体的算法分析，包括时间复杂度和空间复杂度。
（5）撰写实验报告。
4.实验步骤与源程序⑴实验步骤首先分析实验内容，要实现多项式求和，必须创建两个函数，然后先建立一个多项式a和多项式b，接着输入每个多项式的系数和指数，再实现多项式a和b的求和将求出的多项式放在多项式a中，最后输出求出的多项式的结果。
⑵源代码#include<stdio.h>#include<stdlib.h>#include<string.h>#include<time.h>#include<malloc.h>/*定义存储结构，用单链表存储多项式，链表中每个结点存储多项式中的一项。
*/typedef struct term{int coef;//定义多项式系数为coefint expn;//定义多项式指数为expnstruct term *next;}term,*Polynomial;void Create_Polynomial(Polynomial *P,int n){ /*建立多项式*/int i;term *t1,*t2;(*P)=(term *)malloc(sizeof(term));(*P)->coef=0;(*P)->expn=0;(*P)->next=NULL;t1=(*P);for(i=0;i<=n;i++){ /*输入每一项的系数和指数*/ t2=(term *)malloc(sizeof(term));scanf("%d,%d",&(t2->coef),&(t2->expn));t1->next=t2;t1=t1->next;}t2->next=NULL;}void Add_Polynomial(Polynomial *a,Polynomial *b){ /*多项式a和多项式b求和，结果存放在a中。
算法与数据结构实验报告实验一 完成多项式的相加运算
实验一：完成多项式的相加运算（验证性、4学时）一、实验目的完成多项式的相加、相乘运算。
（1）掌握线性表的插入、删除、查找等基本操作设计与实现（2）学习利用线性表提供的接口去求解实际问题（3）熟悉线性表的的存储方法二、实验内容设计一个一元多项式的简单计算程序，其基本功能有：（1）输入并建立多项式；（2）输出多项式；（3）多项式的相加运算。
利用单链表实现。
三、算法描述及实验步骤1描述1、创建两个单链表A、B，分别调用CreatePolyn（）；2、输出多项式，分别调用PrintPolyn（）；3、多项式相加运算AddPolyn（）。
2算法流程图4 65inputA-B inputA-B inputA-B end3代码(注释)#include<stdio.h>#include<malloc.h>#include<math.h>typedef struct Polynomial{float coef;//系数变量int exp;//指数变量struct Polynomial *next;//定义next指针}*Polyn,Polynomial; //Polyn为结点指针类型void Insert(Polyn p,Polyn h) //插入新的结点p{if(p->coef==0) free(p); //系数为0的话释放结点else{Polyn q1,q2;q1=h;q2=h->next;while(q2&&p->exp<q2->exp) //查找插入位置{q1=q2;q2=q2->next;}if(q2&&p->exp==q2->exp) //将指数相同相合并{q2->coef+=p->coef;free(p);if(!q2->coef) //系数为0的话释放结点{q1->next=q2->next;free(q2);}}else //指数为新时将结点插入{p->next=q2;q1->next=p;}}}//Insertint f(float x)//判断输入是否为整形{float a;a=x-(long int)x;if(a==0&&x==fabs(x))return 1;elsereturn 0;}Polyn CreatePolyn(Polyn head,int m) //建立一个头指针为head、项数为m的一元多项式{int i;Polyn p;p=head=(Polyn)malloc(sizeof(struct Polynomial));head->next=NULL;for(i=0;i<m;i++){p=(Polyn)malloc(sizeof(struct Polynomial));//建立新结点以接收数据printf("please input NO.%d coef and exp:",i+1);scanf("%f %d",&p->coef,&p->exp);while(!f(p->coef)&&!f(p->exp)){printf("输入有错，请重新输入: ");scanf("%f %d",&p->coef,&p->exp);}Insert(p,head); //调用Insert函数插入结点}return head;}//CreatePolynvoid DestroyPolyn(Polyn p) //销毁多项式p{Polyn q1,q2;q1=p->next;q2=q1->next;while(q1->next){free(q1);q1=q2;//指针后移q2=q2->next;}}void PrintPolyn(Polyn P)//输出多项式{Polyn q=P->next;int flag=1; //项数计数器if(!q) //若多项式为空，输出0{putchar('0');printf("\n");return;}while (q){if(q->coef>0&&flag!=1) putchar('+'); //系数大于0且不是第一项if(q->coef!=1&&q->coef!=-1) //系数非1或-1的普通情况{printf("%g",q->coef);if(q->exp==1) putchar('X');else if(q->exp) printf("X^%d",q->exp);}else{if(q->coef==1){if(!q->exp) putchar('1');else if(q->exp==1) putchar('X');else printf("X^%d",q->exp);}if(q->coef==-1){if(!q->exp) printf("-1");else if(q->exp==1) printf("-X");else printf("-X^%d",q->exp);}}q=q->next;flag++;}//whileprintf("\n");}//PrintPolynint compare(Polyn a,Polyn b){if(a&&b){if(!b||a->exp>b->exp) return 1;else if(!a||a->exp<b->exp) return -1;else return 0;}else if(!a&&b) return -1;//A多项式已空，但B多项式非空else return 1;//B多项式已空，但A多项式非空}//comparePolyn AddPolyn(Polyn pa,Polyn pb)//求解并建立多项式A+B，返回其头指针{Polyn qa=pa->next;Polyn qb=pb->next;Polyn headc,hc,qc;hc=(Polyn)malloc(sizeof(struct Polynomial)); //建立头结点hc->next=NULL;headc=hc;while(qa||qb){qc=(Polyn)malloc(sizeof(struct Polynomial));switch(compare(qa,qb)) //功能选择{ case 1:{qc->coef=qa->coef;qc->exp=qa->exp;qa=qa->next;break;}case 0:{qc->coef=qa->coef+qb->coef;qc->exp=qa->exp;qa=qa->next;qb=qb->next;break;}case -1:{qc->coef=qb->coef;qc->exp=qb->exp;qb=qb->next;break;}}//switchif(qc->coef!=0){qc->next=hc->next;hc->next=qc;hc=qc;}else free(qc);//当相加系数为0时，释放该结点}//whilereturn headc;}//AddPolynPolyn SubtractPolyn(Polyn pa,Polyn pb){//求解并建立多项式A-B，返回其头指针Polyn h=pb;Polyn p=pb->next;Polyn pd;while(p){ //将pb的系数取反p->coef*=-1;p=p->next;}pd=AddPolyn(pa,h);for(p=h->next;p;p=p->next) //恢复pb的系数p->coef*=-1;return pd;}//SubtractPolynPolyn MultiplyPolyn(Polyn pa,Polyn pb){//求解并建立多项式A*B，返回其头指针Polyn hf,pf;Polyn qa=pa->next;Polyn qb=pb->next;hf=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点hf->next=NULL;for(;qa;qa=qa->next){for(qb=pb->next;qb;qb=qb->next){pf=(Polyn)malloc(sizeof(struct Polynomial));pf->coef=qa->coef*qb->coef;pf->exp=qa->exp+qb->exp;Insert(pf,hf);//调用Insert函数以合并指数相同的项}}return hf;}//MultiplyPolynvoid DevicePolyn(Polyn pa,Polyn pb){//求解并建立多项式A/B，返回其头指针Polyn hf,pf,af,temp1,temp2,q;Polyn qa=pa->next;Polyn qb=pb->next;hf=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点,存储商hf->next=NULL;pf=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点，存储余数pf->next=NULL;temp1=(Polyn)malloc(sizeof(struct Polynomial));temp1->next=NULL;temp2=(Polyn)malloc(sizeof(struct Polynomial));temp2->next=NULL;temp1=AddPolyn(temp1,pa);while(qa!=NULL&&qa->exp>=qb->exp){temp2->next=(Polyn)malloc(sizeof(struct Polynomial));temp2->next->coef=(qa->coef)/(qb->coef);temp2->next->exp=(qa->exp)-(qb->exp);Insert(temp2->next,hf);pa=SubtractPolyn(pa,MultiplyPolyn(pb,temp2));qa=pa->next;temp2->next=NULL;}pf=SubtractPolyn(temp1,MultiplyPolyn(hf,pb));pb=temp1;printf("the quotient is :");PrintPolyn(hf);printf("the remainder is :");PrintPolyn(pf);}//DevicePolynint main(){int m,n,flag=0;float x;Polyn pa=0,pb=0,pc,pd,pe,pf;//定义各式的头指针，pa与pb在使用前付初值NULL printf("please input A number:");scanf("%d",&m);pa=CreatePolyn(pa,m);//建立多项式Aprintf("please input B number:");scanf("%d",&n);pb=CreatePolyn(pb,n);//建立多项式B//输出菜单printf("**********************************************\n");printf("choise：\n\t1.Output A and B\n\t2.CreatePolyn A+B\n");printf("\t3.CreatePolyn A-B\n\t4.CreatePolyn A*B\n");printf("\t5.CreatePolynA/B\n\t6.Return\n**********************************************\n");for(;;flag=0){printf("choise");scanf("%d",&flag);if(flag==1){printf("多项式A：");PrintPolyn(pa);printf("多项式B：");PrintPolyn(pb);continue;}if(flag==2){pc=AddPolyn(pa,pb);printf("多项式A+B：");PrintPolyn(pc);DestroyPolyn(pc);continue;}if(flag==3){pd=SubtractPolyn(pa,pb);printf("多项式A-B：");PrintPolyn(pd);DestroyPolyn(pd);continue;}if(flag==4){pf=MultiplyPolyn(pa,pb);printf("多项式a*b：");PrintPolyn(pf);DestroyPolyn(pf);continue;}if(flag==5){DevicePolyn(pa,pb);continue;}if(flag==6) break;if(flag<1||flag>6) printf("Error\n");continue;}//forDestroyPolyn(pa);DestroyPolyn(pb);return 0;}一、调试过程一次调试二次调试二、实验结果测试数据（1）多项式A:3x^4+11x^3+21x^2多项式B:2x^5+11x^4+12x^3+7x实验结果（1）多项式A+B=2x^5+14x^4+23x^3+21x^2+7x多项式A-B=-2x^5-8^4-x^3+21x^2-7x多项式A*B=6x^9+55x^8+199x^7+363x^6+273x^5+77x^4+147x^3多项式A/B=0实验截图（1）测试数据（2）：多项式A:2x^3+5x^-3多项式B:9x^2+6x^-2+11x^-3实验结果（2）：多项式A+B=2x^3+9x^2+6x^-2+16x^-3多项式A-B=2x^3-9x^2-6x^(-2)=16x^(-3)多项式A*B=18x^5+12x+22+45x^(-1)+30x^(-5)+55x^(-6)多项式A/B=0.222222x实验截图（2）：测试数据（3）多项式A:-x^7+3x^5多项式B:x^7-4x6%+7x^3实验结果（3）多项式A+B=-x^5+7x^3多项式A-B=-2x^7+7x^5-7x^3多项式A*B=-x^14+7x^12-19x^10+21x^8多项式A/B=-1实验截图（3）：三、总结1.在熟悉VC6.0环境的同时，对单链表的存储格式有了深刻的理解；2.复习C++语法的同时，对刚学的线性表进行综合性理解和表达，与之前所学融合。
数据结构《一元多项式》
一元多项式相加问题实验报告本实验的目的是进一步熟练掌握应用链表处理实际问题的能力。
一、问题描述通过键盘输入两个形如Po+P₁X¹+P₂X²+…+PX的多项式，经过程序运算后在屏幕上输出它们的相加和。
二、数据结构设计分析任意一元多项式的描述方法可知，一个一元多项式的每一个子项都由“系数-指数”两部份组成，因此可将其抽象为包含系数coef、指数 exp、指针域next 构成的链式线性表。
对多项式中系数为0的子项可以不记录它的指数值，将两个多项式分别存放在两个线性表中，然后经过相加后将所得多项式存放在一个新的线性表中，但是不用再开辟新的存储空间，只依靠结点的挪移来构成新的线性表，期间可以将某些不需要的空间回收。
基于这样的分析，可以采用不带头结点的单链表来表示一个一元多项式。
具体数据类型定义为：struct nodefloat coef;//系数域int exp; //指数域struct node *next;};三、功能函数设计1、输入并建立多项式的功能模块具体函数为node *in f un()此函数的处理较为全面，要求用户按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项，输入一个子项建立一个相关结点，当遇到输入结束标志时住手输入。
关键步骤具体如下：(1)控制用户按照指数递增的顺序输入r=a;while(r!=q->next)if(y<=r->exp)cout<<"请按照指数递增顺序输入，请重新输入";cin>>x>>y;break;r=r->next;从头开始遍历，若遇到目前输入的指数不是最大时，就跳出循环，让用户重新输入。
(2)当输入的系数为零时，不为其分配存储空间存储while(x==0){cin>>x>>y;continue;}即若系数为0,再也不进行动态分配并新建结点，而是重新提取用户输入的下一个子项的系数和指数，利用continue 进入下一次循环。
数据结构多项式相加实验报告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;}//输出计算结果}三、实验小结通过编写多项加法这个程序，我将自己所学到的创建链表，初始化链表和多项式加法算法都应用了一次，这使我们不仅仅只是理论化的学习书本上的知识，而是将学习到的理论知识应用到实际的操作中来增强我们的实际操作能力，这使我增加了实际操作经验，也使我通过实际操作来认识到自己在程序编写上的不足从而增强了我的实际编写程序的能力。
数据结构一元多项式求和实验报告
xx大学xxx学院算法与数据结构试验报告设计名称：算法与数据结构设计题目：链表的应用学生学号：xx专业班级：xx学生姓名：xx学生成绩：指导教师（职称）：课题工作时间：2012年4月10日说明：实验课程类别：课程内实验实验课程性质：必修适用专业、年级：2010级计算机工程、计算机网络开课院、系：计算机科学与工程学院计算机工程教研室学时：18编写依据：《算法与数据结构》实验教学大纲修订时间：2012年2月《算法与数据结构》课程实验指导书（以下简称：指导书）是针对计算机学院所开设的对应课程的上机实验而编写的教学文件，供学生上机实验时使用。
上机的工作环境要求：Windows 2000或以上操作系统、VC++ 6.0或者其它高级程序设计语言。
学生应按指导教师的要求独立完成实验，并按要求撰写实验报告。
每一个实验，编程上机调试并且提交电子文档实验报告，以学号姓名作为文件名上传。
报告内容至少包含如下内容：1、学生基本情况：专业班级、学号、姓名2、实验题目、实验内容3、设计分析4、源程序代码5、测试用例（尽量覆盖所有分支）6、实验总结一．实验内容与学时分配一、试验课题链表的应用二、试验内容一元多项式求和。
把任意给定的两个一元多项式P(x),Q(x)输入计算机，计算它们的和并输出计算结果。
三、试验分析系数指数一元多项式链表的结点结构四、源程序代码#include<stdio.h> #include<stdlib.h> /*链表数据类型定义*/ typedef struct LNode {int x,z;struct LNode *next; }LinkList;void OutLinkList(LinkList *L); /*输出函数*/void PutLinkList(LinkList *&L,int n); /*输入函数*/LinkList *AddLinkList(LinkList *a,LinkList *b); /*求和函数*/ void OutXLinkList(LinkList *L); void OutZLinkList(LinkList *L); void main() {int n,m;LinkList *a,*b,*c;printf("\t\t\t本程序可以完成两个一元多项式的加法运算。
数据结构实验报告完成多项式的运算
简单介绍：本次作业力在学会链表表示线性表的插入、删除、查找等基本操作设计与实现，学习利用链表提供的接口去求解实际问题，同时熟悉链表的的存储方法。
再基于线性链表的基础设计完成多项式的相加运算程序。
一、实验目的和要求完成多项式的相加、相乘运算。
（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链表各项相乘的新生成节点单独构成一链表，并将第一个链表加入另一新链表，循环此操作将后生成的链表加之先前的链表，即可实现排序问题。
一元多项式相加 数据结构实验报告
南昌航空大学实验报告课程名称：数据结构实验名称：实验二线性表的链式存储结构班级：080611 学生姓名：学号：08指导教师评定：签名:题目：设计并实现以下算法：给出用单链表存储多项式的结构，利用后接法生成多项式的单链表结构，实现两个多项式相加的运算，并就地逆置相加后的多项式链式。
一、需求分析1.用户可以根据自己的需求分别输入两个一元多项式，并且能够实现输入的一元多项式的显示。
2.能够完成两个一元多项式的相加功能，而且还能显示相加后的逆置的一元多项式。
3.程序执行的命令包括：（1）构造链表A （2）构造链表B （3）两个链表的相加（4）求链表的长度（5）打印（显示）已有的链表（6）将已相加的链表进行逆序排列二、概要设计⒈为实现上述算法，需要线性表的抽象数据类型：ADT Polynomial {数据对象：D={a i:|a i∈TermSet,i=1…n,n≥0TermSet 中的每个元素包含一个表示系数的实数和表示指数的整数} 数据关系：R1={<a i-1,a i>|a i-1,a i∈D,且a i-1中的指数值< a i中的指数值i=2,…n≥0}基本操作:initlink(& L)操作结果：构造一个空的链表L。
Creatlink(&L,n)操作结果：输入n项的系数和指数，建立一个非空的一元多项式L。
LinkLength(L)初始条件：链表L已经存在。
操作结果：返回一元多项式L中的项数。
Displaylink（L）初始条件：链表L已经存在。
操作结果：打印输出一元多项式L。
Addpolyn(A,B,&C)初始条件：一元多项式A和B已存在。
操作结果：完成多项式相加运算，即：C=A+B，并且带回C。
subtracypolyn(&La,&Lb,)初始条件：一元多项式La和Lb已存在。
操作结果：完成多项式的相减运算La=La+Lb，并且销毁多项式Lb。
数据结构—多项式求和
实验一多项式求和实验一、程序验证1、源代码：#include<iostream.h>//cout,cin#include"process.h"//exit()#define Max 20typedef struct{float coef;int exp;}PolyArray[Max];struct PolyNode{float coef;int exp;PolyNode *next;};class Poly{private:PolyNode *head;public:Poly();//构造函数，建立空多项式~Poly();//析构函数，释放多项式void Create(PolyArray a,int n);//键盘输入，创建多项式链表void Disp();//多项式显示void Sort();//有序表排序void Add (Poly LB);//多项式加//void Substract(PolyNode * hbQ);//多项式减//void Multiply(PolyNode * hb);//多项式乘};Poly::Poly(){ //创建一空多项式head=new PolyNode;head->next=NULL;}Poly::~Poly(){//释放多项式所占空间PolyNode *p;while(head!=NULL){//从头结点开始，依次释放结点p=head;head=head->next;delete p;}head=NULL;//头结点指向空}void Poly::Disp (){PolyNode *p;p=head->next;while(p!=NULL){cout<<p->coef <<"x^"<<p->exp<<'\t' ;p=p->next ;}cout<<endl;}void Poly::Create (PolyArray a,int n){//由多项式数组创建多项式链表PolyNode *s,*r;int i;r=head;for(i=0;i<n;i++){s=new PolyNode;s->coef =a[i].coef;s->exp =a[i].exp;s->next =NULL;r->next =s;r=s;}}void Poly::Sort(){PolyNode *p,*q,*r;p=head->next ;if(p!=NULL){r=p->next ;//r指向p的后继结点p->next =NULL;//构造只有一个结点的有序表p=r;while(p!=NULL){r=p->next;q=head;while(q->next!=NULL && q->next ->exp < p->exp )q=q->next ;//在有序表中插入*p的前驱结点*q p->next =q->next ;//*p插入到*q之后q->next =p;p=r;}}}void Poly::Add(Poly LB){float sum;PolyNode *pa,*pb,*qa,*qb;pa=head;qa=pa->next;pb=LB.head ;qb=pb->next;while (qa!=NULL && qb!=NULL ){if (qa->exp < qb->exp ){//pa=qa;qa=qa->next; }else if ( qa->exp > qb->exp ){ //pb->next =qb->next;qb->next=qa;pa->next=qb;pa=qb;qb=pb->next;}else{//sum=qa->coef+qb->coef;if (sum==0 ){//pa->next=qa->next;delete qa;qa=pa->next;pb->next=qb->next;delete qb;qb=pb->next;}else{qa->coef=sum;pa=qa; qa=qa->next;pb->next=qb->next;delete qb;qb=pb->next;}}}//whileif(qb!=NULL)qa->next=qb;//}//Addvoid main(){Poly LA,LB;PolyArray a={{7.0,0},{3.0,1},{9.0,8},{5.0,16}};PolyArray b={{8.0,1},{22,7},{-9.0,8}};LA.Create (a,4);LB.Create (b,3);cout<<"原多项式A为：";LA.Disp ();cout<<"原多项式B为：";LB.Disp ();LA.Sort ();LB.Sort ();cout<<"有序多项式A为：";LA.Disp ();cout<<"有序多项式B为：";LB.Disp();LA.Add (LB);cout<<"和多项式为：";LA.Disp ();}2、运行结果：实验二有序表合并一、实验设计1、问题描述把两个有序表归并为一个有序表。
数据结构 多项式 实验报告
数据结构实验报告实验名称：实验一——多项式的实现学生姓名：班级：班内序号：学号：日期：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的值，然后求出每项的值相加即可。
数据结构实验-多项式的相加减
集美大学数据结构课程实验报告课程名称：数据结构班级：网络0911实验成绩：指导教师：姓名：实验项目名称：多项式的相加减学号上机实践日期：实验项目编号：组号：上机实践时间：学时一、目的(本次实验所涉及并要求掌握的知识点)学习和掌握如何运用链表来实现一元稀疏多项式的相加减。
多项式的输入和输出的应注意的要点，规定输出的多项式的顺序。
二、实验内容与设计思想(设计思路、主要数据结构、主要代码结构、)实验内容：一元稀疏多项式的相加减设计思路：建立数据结构存放常数和系数以及指向下一个节点的指数，用链表存放各个节点，通过对常数和系数的的运算，实现多项式的相加减主要数据结构：结构体，链表主要代码结构：struct Polyn;void addPolyn(Polyn * a,Polyn * b,int add);void display( );void tip()’Polyn * CreatPolyn(int m);三、实验使用环境(本次实验所使用的平台和相关软件)Dev-C++、windows XP四、实验步骤和调试过程(实验步骤、测试数据设计、测试结果分析)需说明出，加入必要的截图说明。
#include<iostream>#include<vector>using namespace std;struct Polyn{float coef;int expn;Polyn *next;};//构建结构体vector <Polyn *> ve;void addPolyn(Polyn * a,Polyn * b,int add);void display(Polyn *n);//打印void tip();//屏幕显示Polyn * CreatPolyn(int m); //建立多项式int main(){tip();system("pause");}void tip(){Polyn *first, *second,*s;int m;for( int i=1;i;){cout<<" 多项式运算.\n";cout<<"======================="<<"\n"; cout<<" 1------ 构造多项式.\n";cout<<" 2------ 多项式相加.\n";cout<<" 3------ 多项式相减.\n";cout<<" 0------ 结束.\n";cout<<"======================="<<"\n"; cout<<" 请输入您的选择.\n";cin>>i;switch(i){case 1:cout<<"请输入多项式的项数.\n";cin>>m;s=CreatPolyn(m);display(s);ve.push_back(s);break;case 2:first=ve.back();ve.pop_back();second=ve.back();addPolyn(first,second,0);break;case 3:first=ve.back();ve.pop_back();second=ve.back();addPolyn( first,second,1);break;case 0:cout<<" 再见"<<"\n";break;};}}Polyn* CreatPolyn(int m){Polyn* px=new Polyn[m];cout<<" 输入系数.\n";for(int i=0;i<m;i++)cin>>px[i].coef;cout<<"输入与系数相对应的指数.\n";for(int i=0;i<m;i++){cin>>px[i].expn;if(i!=m-1)px[i].next=&px[i+1];elsepx[i].next=NULL;}return px;}void display(Polyn *n){int q=0;Polyn * r;r=n;for(;r;r=r->next){if(r->coef)q++;if(r==n){if(r->coef!=0)cout<<r->coef<<"X"<<"^"<<r->expn;}else{if( r->coef>0)cout<<"+"<<r->coef<<"X"<<"^"<<r->expn;if(r->coef<0)cout<<r->coef<<"X"<<"^"<<r->expn;}}cout<<"\n";if(q==0)cout<<"0"<<"\n";}void addPolyn(Polyn * a,Polyn * b,int add)//两个多项式的加减{float c;int a1=1,b1=1,s,e;Polyn *ha,*hb,*p,*r;ha=a;hb=b;p=ha;r=hb;for(int i=0;ha[i].next;++i)a1++;for(int i=0;hb[i].next;++i)b1++;ha[a1-1].next=hb;for(int j=0;j<b1;j++){for(int i=0;i<a1;i++){if(a[i].expn-b[j].expn==0){if(add)ha[i].coef=ha[i].coef-hb[j].coef;elseha[i].coef=ha[i].coef+hb[j].coef;if(hb!=&hb[j])hb[j-1].next=hb[j].next;else{hb=hb[j].next;ha[a1-1].next=hb;}i=a1;}}}for(;p;p=p->next){for( Polyn * t=p->next;t;t=t->next)if( p->expn>t->expn){e=p->expn;p->expn=t->expn;t->expn=e;c=p->coef;p->coef=t->coef;t->coef=c;}}display(ha);}五、实验小结(实验中遇到的问题及解决过程、实验体会和收获)至少两点1.刚开始实现多项式的相加减运算时，申请一个新的空间来存放结果，结果指针乱了，后来改成了现在的程序。
数据结构实验-一元多项式的加法运算
一元多项式加法一、实验目的通过实现多项式加法，对链表有更深入的了解二、实验内容问题描述：设计一个一元稀疏多项式简单的加法计算器实现要求：一元稀疏多项式简单计算器的基本功能是：（1）输入并建立多项式：1785937)(x x x x A +++=；879228)(x x x x B -+=（2）输出多项式（3）多项式A 和B 相加，建立多项式C ＝A ＋B ，并输出相加的结果多项式C（4）选作：多项式A 和B 相减，建立多项式C ＝A －B ，并输出相减的结果多项式D 方法说明：（1）多项式的输入与存储用带表头结点的单链表存储多项式，链表中的每个节点分别存储多项式各项的系数和指数，即每从键盘输入多项式的一对数（系数，指数），可对应建立链表的一个结点。
每个节点的结构为：建立两个链表，其中pa 和pb 分别为它们的头指针：pb结果链表Pa(或者是Pc)Pc（2）多项式数据类型的定义struct tagNode{float coef;int exp;struct tagNode *next;typedef struct tagNode Node;typedef struct tagNode* pNode;（3）主要算法①创建两个链表，分别存放多项式1和多项式2，这两个链表中的节点是按指数降序或者升序排列的②多项式相加，下面给出多项式相加的部分实现/*下面的函数实现两个多项式的相加，要相加的链表分别由pa和pb指向（其中，pa，pb都是分配了空间的头结点）。
相加的结果直接由pa指向的链表保存，即是在pa链表中添加或删除（当系数因为相加为0的情况下）一些结点，构成结果。
相加的链表中指数按从小到大的顺序排列好的，是升序链表。
*/void add_poly(Node *pa,Node *pb){Node *p=pa->pNext;//链表1，将来的结果也放在此Node *q=pb->pNext;//链表2Node *pre=pa;Node *u;//临时用float x;while (p!=NULL && q!=NULL)//当两个链表都不为空{if (p->exp<q->exp)//比较链表1跟链表2当前节点的指数大小，链表1也是存放结果的地方{pre=p;p=p->pNext;//p指向要比较的下一个结点。
数据结构多项式相加实验报告
试验一多项式相加一. 实验内容：多项式相加二.实验目的和要求：利用双向链表实现通讯录的建立、删除、检索和列表，并可保存至文件，可重新装入。
用链式存储结构实现一元多项式的相加运算。
三．算法思想描述: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、实验名称:实现一元多项式的加法2、实验日期: 2011-3-73、基本要求：1）编程实现一元多项式的加法；2）设计一个测试主函数。
4、实验目的：通过实验使学生掌握链表的最基本和最主要的操作：插入和删除操作。
5、测试数据：随意输入两个一元多项式的系数和指数：第一个：系数：4 8 6 7；指数：2 3 4 5第二个：系数：5 9 3 8；指数：1 3 5 6两式相加后输出结果。
6、算法思想或算法步骤:1）用尾插入法创建单链表（PLoy *create_Ploy_LinkList(void)）2）输出单链表中所有结点的值，得到一元多项式（void output_Ploy_LinkList(PLoy *L, char ch)）3）进行多项式的相加，采用链式存储表示加法，根据结点类型定义，若指数不同，则进行链表的合并；若指数相同，则进行系数相加；若和为0，则去掉结点；若和不为0，则修改结点的系数域。
（PLoy *add_ploy(PLoy *La, PLoy *Lb)）7、模块划分：1）头文件stdiob.h。
头文件stdiob.h中包括：结点结构体定义、一元多项式的系数和指数的输入、一元多项式的输出以及两式相加输出结果的操作等；2）实现文件yydxsxj.cpp。
包含主函数int main()，其功能是测试所设计的一元多项式加法的正确性。
8、数据结构：链表中的结点的结构体定义如下：typedef struct Node{float coef; /*系数部分*/int expn; /*指数部分*/struct Node *next ;} PloyNode;9、源程序：源程序存放在两个文件中，即头文件stdiob.h和实现文件yydxsxj.cpp。
//头文件stdiob.htypedef struct Node{float coef; /*系数部分*/int expn; /*指数部分*/struct Node *next ;} PloyNode;PloyNode *create_Ploy_LinkList(void){/* 尾插入法创建单链表,链表的头结点head作为返回值 */ float coef ; int expn ;PloyNode *head, *p, *q;head=p=(PloyNode *)malloc(sizeof(PloyNode));p->next=NULL; /* 创建单链表的表头结点head */while (1){printf("\n请输入一元多项式的系数(0表示结束): ") ;scanf("%f",&coef);if (coef==0) break ;else{printf("\n请输入一元多项式的指数: ") ;scanf("%d",&expn);q=(PloyNode *)malloc(sizeof(PloyNode));q->coef=coef ; /* 指数部分赋值 */q->expn=expn ; /* 系数部分赋值 */q->next=p->next; p->next=q; p=q ;/* 钩链，新创建的结点总是作为最后一个结点 */ }}return(head);}void output_Ploy_LinkList(PloyNode *L, char ch)/* 输出以L为头结点的单链表中所有结点的值 */ {PloyNode *p;p=L->next; /* 使p指向第一个结点 */if (p==NULL) printf("\n此多项式为空!!\n\n") ;else{printf("f(x)= \n",ch) ;while (p!=NULL){if (p->coef>0)printf("%+g",p->coef) ;else printf("%g",p->coef) ;if (p->expn!=0){printf("X^") ;printf("%d",p->expn);}p=p->next;}} /* 移动指针p */printf("\n\n") ;}PloyNode *add_Ploy(PloyNode *La, PloyNode *Lb){PloyNode *Lc , *pc , *pa , *pb ,*ptr ; float x ;Lc=pc=La ; pa=La->next ; pb=Lb->next ;if(pa==NULL&&pb==NULL)printf("两个式子之和也为空项");while (pa!=NULL&&pb!=NULL){if (pa->expn< pb->expn){pc->next=pa ; pc=pa ; pa=pa->next ; } else{if (pa->expn>pb->expn){ pc->next=pb ; pc=pb ; pb=pb->next ; }else{x=pa->coef+pb->coef ;if (x==0){ ptr=pa ; pa=pa->next ;ptr=pb ; pb=pb->next ;}else{ pc->next=pa ; pa->coef=x ;pc=pa ; pa=pa->next ;ptr=pb ; pb=pb->next ;}}}}if (pa==NULL) pc->next=pb ;else pc->next=pa ;return (Lc) ;}//实现文件yydxsxj.cpp#include<iostream>#include<malloc.h>#include"stdiob.h"using namespace std;int main(){PloyNode * pa,* pb;char pc,pd;cout<<"请输入第一个多项式(按指数递增顺序输入):"<<endl; pa=create_Ploy_LinkList();output_Ploy_LinkList(pa,pc);cout<<"请输入第二个多项式(按指数递增顺序输入):"<<endl; pb=create_Ploy_LinkList();output_Ploy_LinkList(pb,pd);cout<<"多项式相加结果是:"<<endl;add_Ploy(pa,pb);output_Ploy_LinkList(pa,pc);return 0;}10、测试情况：1）程序运行输出为：第一个多项式为：f(x)=+4x^2+8x^3+6x^4+7x^5第二个多项式为：f(x)=+5x^1+9x^3+3x^5+8x^6两式相加之和为：f(x)=+5x^1+4x^2+17x^3+6x^410x^5+8x^6 2）测试结果分析：程序运行结果和预测的完全相同，说明所设计的一元多项式的加法是正确的。
数据结构-实验2-多项式求和
数据结构-实验2-多项式求和数据结构实验 2 多项式求和在计算机科学和数学领域中，多项式的操作是一个常见且重要的任务。
本次实验 2 的重点是实现多项式的求和。
首先，让我们来理解一下什么是多项式。
简单来说，多项式就是由变量、系数和运算符组成的表达式。
例如，3x^2 ＋ 2x 1 就是一个多项式，其中 3、2 和－1 是系数，x 是变量，＾2 表示幂次。
那么为什么要进行多项式求和呢？在实际的应用中，我们经常会遇到需要对多个多项式进行运算的情况。
比如在数学建模中，通过对不同的多项式进行求和，可以得到更复杂的数学表达式，从而更准确地描述实际问题。
接下来，我们来探讨一下如何实现多项式的求和。
在数据结构中，有多种方式可以表示多项式。
常见的有顺序表和链表两种方式。
使用顺序表来表示多项式时，我们可以将多项式的每一项的系数和指数存储在数组的相应位置。
比如，数组的第一个元素存储第一项的系数和指数，第二个元素存储第二项的系数和指数，以此类推。
这种方式的优点是随机访问速度快，但是在进行多项式的加法运算时，可能需要移动大量的元素，效率较低。
相比之下，链表的方式则更加灵活。
我们可以为每一项创建一个节点，节点中包含系数、指数和指向下一项的指针。
在进行多项式的加法运算时，只需要遍历链表，根据指数的大小进行相应的操作即可。
下面我们通过一个具体的例子来看看如何进行多项式的求和。
假设有两个多项式：P1(x) ＝ 2x^3 ＋ 3x^2 1 和 P2(x) ＝ x^3 ＋ 2x 5 。
首先，我们创建两个链表分别表示这两个多项式。
然后，同时遍历这两个链表。
在遍历的过程中，比较当前节点的指数大小。
如果两个节点的指数相等，那么将它们的系数相加，创建一个新的节点，其系数为相加后的结果，指数不变，并将其插入到结果链表中。
如果一个节点的指数大于另一个节点的指数，那么将指数较小的节点直接插入到结果链表中，并继续遍历。
如果一个链表遍历完了，而另一个链表还有剩余的节点，那么将剩余的节点直接插入到结果链表中。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
【关键字】结构数据结构多项式相加实验报告篇一：数据结构实验多项式加法数据结构实验报告实验名称：多项式加减法学号：1XX10419姓名：林强实验日期：一、实验目的通过实现多项式的加减法，对链表有更深入的了解二、实验具体内容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;}//输出计算结果}三、实验小结通过编写多项加法这个程序，我将自己所学到的创建链表，初始化链表和多项式加法算法都应用了一次，这使我们不仅仅只是理论化的学习书本上的知识，而是将学习到的理论知识应用到实际的操作中来增强我们的实际操作能力，这使我增加了实际操作经验，也使我通过实际操作来认识到自己在程序编写上的不足从而增强了我的实际编写程序的能力。
篇二：数据结构实验报告《一、多项式及其运用》中南大学物理学院数据结构实验报告----一元多项式相加及其运用专业班级时间：XX年10月18日数据结构实验报告----一元多项式相加及其运用【问题描述】设计一个一元稀疏多项式简单计算器【基本要求】一元稀疏多项式简单计算器的功能是：（1）输入并建立多项式；（2）输出多项式，输出形式为整数序列：n，c1,e1,c2,e2,cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列；（3）多项式a和b相加，建立多项式a+b；（4）多项式a和b相减，建立多项式a-b。
【运用拓展】（1）计算多项式在x处的值；（2）多项式a和b相乘，建立乘积多项式ab；（3）计算器的仿真友好界面。
【设计思路分析】（1）解决多项式相加，必须要有多项式，所以必须首先建立两个多项式，在这里采用链表的方式存储链表。
（2）运用尾插法建立两条单链表，以单链表polyn p和polyn h分别表示两个一元多项式a和b，a+b的求和运算等同于单链表的拔出问题（3）设p、q分别指向单链表polya和polyb的当前项，比较p、q结点的指数项，由此得到下列运算规则：① 若p->expnexpn，则结点p所指的结点应是“和多项式”中的一项，令指针p后移。
② 若p->expn=q->expn，则将两个结点中的系数相加，当和不为0时修改结点p的系数。
③ 若p->expn>q->expn，则结点q所指的结点应是“和多项式”中的一项，将结点q拔出在结点p之前，且令指针q在原来的链表上后移。
【测试数据】多项式a：6x+3x^5-7.1x^11多项式b: 2-5x^5+11x^9若计算a+b则有:(6x+3x^5-7.1x^11)+(2-5x^5+11x^9)=(-7.1x^11+11x^9-2x^5+6x+2)等。
【操作界面显示】1：建立多项式的操作：2：输出多项式及计算x的值3：进行运算操作：4：结束程序：【程序代码】#include //调用输入输出函数#includetypedef struct Polynomial //定义一个Polyn结构体{float coef;int exp; //系数指定为浮点型，指数指定为整型struct Polynomial *next;}*Polyn,Polynomial;void Insert(Polyn p,Polyn h){ //查找位置拔出新链节if(p->coef==0) free(p);//p系数为0的话释放结点else{ //否则查找拔出位置Polyn q1,q2;q1=h; q2=h->next;while(q2&& p->exp exp) //指数较大则插前面{q1=q2; q2=q2->next; }if(q2&& p->exp == q2->exp) //将指数相同相合并{ q2->coef += p->coef;free(p);if(!q2->coef) //系数为0的话释放结点{q1->next=q2->next;free(q2);}}else { p->next=q2; q1->next=p;} //指数为新时将结点拔出}//第一个else} //void InsertPolyn CreatePolyn(Polyn head,int m){ //建立一个头指针为head、项数为m的一元多项式int i;Polyn p;p=head=(Polyn)malloc(sizeof(struct Polynomial)); //开辟多项式地址空间head->next=NULL; //指定表尾，然后采用尾插法输入多项式for(i=0;i{p=(Polyn)malloc(sizeof(struct Polynomial)); //建立新结点以接收数据printf("请输入第%d项的系数与指数:",i+1);scanf("%f %d",&p->coef,&p->exp);Insert(p,head); //调用Insert函数拔出结点}return head;}void PrintPolyn(Polyn P)//输出多项式{ Polyn q=P->next;int flag=1;//项数计数器if(!q){//若多项式为空，输出0篇三：一元多项式相加的实验报告《数据结构》实验报告1、实验名称:实现一元多项式的加法2、实验日期: XX-3-73、基本要求：1）编程实现一元多项式的加法；2）设计一个测试主函数。
4、实验目的：通过实验使学生掌握链表的最基本和最主要的操作：拔出和删除操作。
5、测试数据：随意输入两个一元多项式的系数和指数：第一个：系数：4 8 6 7；指数：23 4 5第二个：系数：5 9 3 8；指数：13 5 6两式相加后输出结果。
6、算法思想或算法步骤:1）用尾拔出法创建单链表（PLoy *create_Ploy_LinkList(void)）2）输出单链表中所有结点的值，得到一元多项式（void output_Ploy_LinkList(PLoy *L, char ch)）3）进行多项式的相加，采用链式存储表示加法，根据结点类型定义，若指数不同，则进行链表的合并；若指数相同，则进行系数相加；若和为0，则去掉结点；若和不为0，则修改结点的系数域。