一元多项式相加问题的实验报告

合集下载

一元多项式的相加实验报告

一元多项式的相加实验报告一元多项式的相加实验报告引言：一元多项式是数学中常见的概念，它由一个变量和一系列常数乘积的和组成。

在本实验中，我们将研究一元多项式的相加运算，并通过实验验证相加运算的性质和规律。

实验目的：1. 了解一元多项式的基本概念和相加运算规则；2. 掌握使用编程语言进行一元多项式相加的方法；3. 验证一元多项式相加的性质和规律。

实验过程：1. 准备工作：a. 确定一元多项式的表示方式：我们选择使用数组来表示一元多项式，数组的每个元素表示多项式中对应项的系数；b. 确定一元多项式的相加规则：将相同次数的项的系数相加得到新的多项式的对应项的系数；c. 编写程序：使用编程语言编写一段代码，实现一元多项式的相加运算。

2. 实验步骤：a. 输入两个一元多项式的系数：通过程序提示用户输入两个一元多项式的系数，以数组的形式保存；b. 进行相加运算：将两个一元多项式的对应项系数相加，得到新的一元多项式的系数；c. 输出相加结果：将相加得到的新的一元多项式的系数输出，以验证相加运算的正确性。

实验结果：我们进行了多次实验，以下是其中一次实验的结果：假设输入的两个一元多项式分别为：P(x) = 2x^3 + 4x^2 + 3x + 1Q(x) = 5x^2 + 2x + 6根据相加规则，我们将对应项系数相加，得到新的一元多项式的系数：R(x) = 2x^3 + (4+5)x^2 + (3+2)x + (1+6)= 2x^3 + 9x^2 + 5x + 7因此，相加运算的结果为：P(x) + Q(x) = 2x^3 + 9x^2 + 5x + 7实验结论：通过多次实验，我们验证了一元多项式的相加运算的正确性。

根据实验结果，我们可以得出以下结论：1. 一元多项式的相加运算是可行的，可以通过将相同次数的项的系数相加得到新的多项式的对应项的系数；2. 一元多项式的相加结果仍然是一元多项式，其次数和各项的系数均可能发生变化；3. 一元多项式的相加运算满足交换律和结合律。

实验报告——一元稀疏多项式的加法

程序2：一元稀疏多项式加法运算［问题描述］设计一个求解一元稀疏多项式加法运算的程序。

［基本要求］（1）输入并建立多项式。

（2）输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,…,c n,e n,其中n是多项式的项数，c i和e i分别是第i项的系数和指数，序列按指数降序排列。

（3）多项式a和b相加，建立多项式a＋b［算法实现］#include<stdio.h>#include<stdlib.h>typedef struct Node{int cofe;//系数域int expn;//指数域struct Node *next;}LNode,*LinkList;void InitList(LinkList &L)//初始化{L=(LinkList)malloc(sizeof(LNode));if(!L)exit(0);L->next=NULL;}int Input(LinkList &L)//输入{LinkList p;int i=0;p=(LinkList)malloc(sizeof(LNode));L->next=p;printf("输入多项式的系数与指数，按“系数指数”格式，且指数按从小到大顺序输入，以(0 0)结束：\n");while(1){scanf("%d %d",&p->cofe,&p->expn);if((p->cofe)==0)break;p->next=(LinkList)malloc(sizeof(LNode));p=p->next;++i;}p->next=NULL;return i;}void Output(LinkList &L)//输出{LinkList p;p=L->next;printf("多项式为：\n");if((p->expn)==0)printf("%d",p->cofe);else if(p->expn==1)printf("%dx",p->cofe);else if((p->cofe)==1||(p->cofe)==-1){if((p->cofe)==1)printf("x^%d",p->expn);else if((p->cofe)==-1)printf("-x^%d",p->expn);}elseprintf("%dx^%d",p->cofe,p->expn);p=p->next;for(;(p->cofe!=0);p=p->next){if((p->expn==0)&&(p->cofe!=0)){if((p->cofe)>0)printf("+%d",p->cofe);else if((p->cofe)<0)printf("%d",p->cofe);}else if((p->expn==1)&&(p->cofe==1))printf("+x",p->cofe);else if((p->cofe)==1||(p->cofe)==-1){if((p->cofe)==1)printf("+x^%d",p->expn);else if((p->cofe)==-1)printf("-x^%d",p->expn);}else if((p->cofe)>0)printf("+%dx^%d",p->cofe,p->expn);else if((p->cofe)<0)printf("%dx^%d",p->cofe,p->expn);}printf("\n");}void Add(LinkList &L1,LinkList L2)//计算L1，L2的和，放入L1{LinkList p,q,per,r;//p为指向L1的指针，p2为指向L2的指针,per指向p的前驱,r 为中间变量int x;//存放和的结果p=L1->next;q=L2->next;per=L1;while((p!=NULL)&&(q!=NULL))if((p->expn)>(q->expn))//p的指数大于q的指数，将q插到p之前{r=q->next;q->next=p;//先让q的next指向p，并将q的next存入rper->next=q;per=q;q=r;//再让p的前驱的next指向q，此时，q就成为p 的前驱，所以令per=q，q（前驱）的next指向q原来的next}else if((p->expn)==(q->expn)){x=(p->cofe)+(q->cofe);//求和if(x!=0)//和不为0，代替原值，并将p做为先驱（为下次计算做准备）{p->cofe=x;per=p;}else//和为0，释放p结点：将p前驱的next指向p的next，再释放p的空间即可{per->next=p->next;free(p);}p=per->next;r=q;q=q->next;free(r);//将q向后移一位}else if((p->expn)<(q->expn))//p的指数小于q的指数，将q插到p之后{per=p;p=p->next;}if(q!=NULL)//将q中多余的项（即指数在p中没有的）移入p的后面per->next=q;free(L2);//释放：L2}void main(){LinkList L1,L2;int i,j;printf("输入L1：");InitList(L1);i=Input(L1);printf("共%d项\n",i);Output(L1);printf("\n");printf("输入L2：");InitList(L2);j=Input(L2);printf("共%d项\n",j);Output(L2);printf("\n");Add(L1,L2);printf("L1与L2的和");Output(L1);printf("\n");}[实验结果]。

一元多项式相加问题实验报告

一元多项式相加问题实验报告一元多项式相加问题一、问题描述通过键盘输入两个形如P 0 +P 1 X 1 +P 2 X 2 +…+P n X 的多项式，经过程序运后在屏幕上输出它们的相加和。

二、数据结构设计一个一元多项式的每一个子项都由“系数-指数”两部分组成，因此可将其抽象为包含系数coef、指数exp、指针域next 构成的链式线性表。

将两个多项式分别存放在两个线性表中，然后经过相加后将所得多项式存放在一个新的线性表中，但是不用再开辟新的存储空间，只依靠结点的移动来构成新的线性表，期间可以将某些不需要的空间回收。

基于这样的分析，可以采用不带头结点的单链表来表示一个一元多项式。

具体数据类型定义为：struct node {float coef;//系数域int exp;//指数域struct node *next; }; 三、功能函数设计1、输入多项式的系数和指数初始化多项式的功能模块具体函数为node *in_fun() 此函数的处理较为全面，要求用户按照指数递增的顺序和一定的输入格式输入各个系数不为0 的子项，输入一个子项建立一个相关结点，当遇到输入结束标志时停止输入。

关键步骤具体如下：⑴控制用户按照指数递增的顺序输入r=a; while(r!=q-next){if(y=r-exp){cout“请按照指数递增顺序输入,请重新输入“;cinxy;break;}r=r-next;} 从头开始遍历，若遇到目前输入的指数不是最大时，就跳出循环，让用户重新输入。

⑵当输入的系数为零时，不为其分配存储空间存储while(x==0) { cinxy; continue;} 即若系数为0，不再进行动态分配并新建结点，而是重新提取用户输入的下一个子项的系数和指数，利用continue 进入下一次循环。

⑶初始化完成后将最后一个结点的指针域置为空，并返回该新建链表的首地址。

if(q!=NULL)q-next=NULL;return a; ⑷动态分配空间新建结点存储系数和指数的代码如下：p=new node;p-coef=x;p-exp=y;if(a==NULL) a=p;else q-next=p;q=p; 2、多项式显示功能函数由于系数有正有负，故采取如下处理：对于正数，输出时在前面加“+”，头指针除外；对于负数，直接将系数输出即可，即：p=a;while(p){if(p==a)coutp-coef"*x^"p-else if(p-coef0)coutp-coef"*x^"p-else if(p-coef0)cout"+"p-coef"*x^"p-p=p-next;} 输出的多项式的形式形如：P 1 X^1+P 2 X^2+…+P n X^n 3、多项式相加的功能函数函数为：node *plus_fun(node *a,node *b) 此函数根据在 1 中初始化的两个多项式进行相加运算，并存放在以c 为头指针的一个新链表中。

一元多项式相加实验报告

一元多项式相加实验报告1. 引言本实验旨在研究一元多项式的相加操作。

一元多项式是数学中的一个重要概念，常用于代数运算和函数表达。

相加操作是多项式运算中的基本操作之一，通过对多项式的系数进行相加，可以得到一个新的多项式。

2. 实验目的本实验的主要目的是通过编写代码实现一元多项式的相加操作，并对相加操作进行测试和验证。

具体的实验目标包括： - 设计一种数据结构来表示一元多项式 -实现一元多项式的相加操作 - 编写测试代码，对相加操作进行验证3. 实验方法本实验使用Python编程语言实现一元多项式的相加操作。

具体步骤如下：3.1 设计数据结构首先，我们需要设计一种数据结构来表示一元多项式。

在本实验中，我们选择使用列表来表示一元多项式。

列表的每个元素表示一个项，项由系数和指数组成。

3.2 实现相加操作基于设计的数据结构，我们可以编写代码实现一元多项式的相加操作。

相加操作的基本思路是遍历两个多项式的项，将对应指数的系数相加，并将结果保存到一个新的多项式中。

3.3 编写测试代码为了验证相加操作的准确性，我们需要编写一些测试代码。

测试代码的主要功能是创建一些多项式，并调用相加操作进行计算。

通过比较计算结果和预期结果，可以验证相加操作的正确性。

4. 实验结果经过实验，我们成功地实现了一元多项式的相加操作。

在测试代码中，我们通过比较计算结果和预期结果，验证了相加操作的准确性。

5. 结论与讨论在本实验中，我们通过编写代码实现了一元多项式的相加操作，并进行了测试和验证。

实验结果表明，相加操作的实现是正确的。

然而，相加操作只是一元多项式运算中的基本操作之一。

在实际应用中，还需要考虑其他运算，如相减、乘法和除法等。

此外，实验中使用的数据结构可能还可以进行优化，以提高运算效率。

总的来说，本实验为进一步研究和应用一元多项式提供了基础。

通过进一步的研究和实践，可以深入理解一元多项式的运算规则，并将其应用于更广泛的数学和工程领域。

一元多项式相加问题实验报告

一元多项式相加问题一．问题描述设计算法实现一元多项式的简单运算。

二．数据结构设计分析任意一元多项式的描述方法可知，一个一元多项式的每一个子项都由“系数---指数”两部分组成，所以可以将它抽象成一个由“系数----指数对”构成的线性表。

基于这样的分析，可以采用一个带有头结点的单链表来表示一个一元多项式。

具体数据类型定义为：typedef struct node{float cofe; //系数域int exp; //指数域struct node* next; //指针域指向下一个子项}*polynode,poly;Polynode head_a,head_b,head_c;这三个指针分别作为链表A，B和C的头指针。

三．功能设计1.输入并建立多项式的功能模块此模块要求按照“系数---指数对”的输入格式输入各个子项，输入一个子项，通过遍历链表比较指数的大小，将新结点插在合适的位置，使多项式的指数按递增的顺序存储。

当遇到输入结束标志是停止输入，而转去执行程序下面的部分。

具体函数构造为：polynode creat_polynode(){polynode A ,p,q,s; //建立这种类型的头指针，尾指针，遍历指针和动态指针float a;int b;A=new poly;A->next=NULL;q=A;p=A;cin>>a;cin>>b;while(a!=0||b!=0){s=new poly;s->cofe=a;s->exp=b;while(q->next){if(q->next->exp<b)q=q->next; //遍历链表，若指数大于原链表指数，指针后移一个else{s->next=q->next;q->next=s;break; //若不是，将结点插入指针后面}}if(q->next==NULL){s->next=p->next;p->next=s;p=s; //q遍历到链表尾仍未插入，将结点插入最后，改变尾指针使其指向新结点}q=A; //让q返回头指针处，以便下一次遍历链表cin>>a;cin>>b;}if(p!=NULL)p->next=NULL;return A;}2.多项式相加的功能模块此模块根据在1中建立的两个多项式进行相加运算，并存放在以C为头指针的一个新链表中。

一元多项式实验报告

实验题目一元多项式的加法运算班级：姓名：学号：日期：一、需求分析1.程序的基本功能：(1 ) 输入两个稀疏的一元n次多项式。

(2) 分别输出这两个多项式。

(3) 计算两个多项式的和。

多项式相加的运算规则为：对于两个一元多项式中指数相同的子项，对应的系数相加，若和非灵，将其构成和多项式中的一个子项；对于两个一元多项式中指数不同的子项，则分别复制到和多项式中去。

(4) 输出和多项式。

2.输入输出要求：(1) 输入多项式：按照指数递增的顺序和指定的输入格式输入各个的子项：“系数、指数”（当输入子项个数达到预设数量的时候停止）。

(2) 输出多项式：在文本界面下，采用类似数学表达式的方式输出多项式、例如：多项式A=3+6x3-2x8+12x20，可在屏幕显示为：A=3+6x^3-2x^8+12x^20要求：a.系数值为1的非零项输出形式中省略系数1，如子项“1x8”的输出形式为“x8”，项“-1x3”的输出形式为“x3”。

b.指数为0的输出形式中省略指数部分，如“3x0”的输出形式应为“3”；指数为“1”的项输出时略去“1”。

c.多项式第一项系数为正时，不输出“+”，其他项要输出“+”、“-”符号。

3.测试数据：① (x+3x6-8.6x11)+(6-3x6+21x9)=6+x+21x9-8.6x11② (3x-3-x+4.1x2-1.2x9)+(-3x-3-5.1x2+7.8x12)=-x-x2-1.2x9+7.8x12③ (x+x3）+(-x-x3)=0④ (x+x100)+(x100+x200)=x+2x100+x200⑤ (x+x2+x3)+0= x+x2+x3二、概要设计1.抽象数据类型的定义：对于一元n次多项式P（x,n）=P0+P1x1+P2x2+……+P n x n而言，每一个子项都是由“系数”和“指数”两部分来组成的，因此可将多项式抽象成一个“系数、指数对”构成的线性表，其中多项式的每一个系数非零的子项作为线性表中的一个元素。

两个一元多项式相加-c++版

《数据结构》实验报告——两个一元多项式相加一、实验题目：两个一元多项式相加二、实验内容：根据所学的数据结构中线性结构（线性表）的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加三、设计思想：（1）建立两个顺序列表，分别用来表示两个一元多项式；顺序列表奇数位，存储该多项式的系数；顺序列表的偶数位，存储该相应多项式的指数。

（2）用成员函数merg(qList<Telem>&l2)实现两多项式的相加。

实现的大致方法为：比较第二个多项式列表与第一个多项式列表的偶数位的数值大小（指数），如果相同，则将他们的前一位数（系数）相加；如果不同，就将他的前一位数（系数）及它自己（指数）插入第一个多项式列表的后面。

（3）建立函数shu(double a[],int j)实现多项式的输入。

四、源程序代码#include "stdafx.h"#include<iostream>using namespace std;template<class Telem>class List{private:Telem * elem;int curlen;int maxlen;public:List(int maxsz=100):maxlen(maxsz){curlen=0;elem=new Telem{maxlen};};List(Telem a[],int n,int maxsz=100):maxlen(maxsz){curlen=n;elem=new Telem[maxlen];for(int i=0;i<n;i++)elem[i]=a[i];};~List(){delete[] elem;};Telem gete(int i){if(i>=1&&i<=curlen)return elem[i-1];else return NULL;};int leng(){return curlen;};List<Telem>&merg(List<Telem>&l2);//声明两多项式相加的成员函数};template<class Telem>List<Telem>&List<Telem>::merg(List<Telem>&l2)//两多项式相加的成员函数的实现{int i,j,m,n,k(0);m=curlen;n=l2.curlen;if(m+n<=maxlen){for(i=0;i<n/2;i++){for(j=0;j<m/2;j++)if(elem[2*j+1]==l2.elem[2*i+1]){k++;elem[2*j]+=l2.elem[2*i];break;}if(j==m/2){elem[m+2*(i-k)]=l2.elem[2*i];elem[m+2*(i-k)+1]=l2.elem[2*i+1];}}}curlen=m+n-2*k;return *this;}void fun(double a[],int j)//该函数实现：输入2j个double型的数，并将其存储到数组中{int i;for(i=0;i<j;i++){double m,n;cout<<"请输入第"<<i+1<<"项的系数和指数:";cin>>m>>n;a[2*i]=m;a[2*i+1]=n;}}void main(){int i,j,k;cout<<"第一个多项式的个数:";cin>>j;double *a=new double[2*j];fun(a,j);cout<<"第二个多项式的个数为:";cin>>k;double *b=new double[2*k];shu(b,k);List<double>s1(a,2*j);List<double>s2(b,2*k);s1.merg(s2);cout<<"二个多项式相加结果为：";for(i=1;i<=s1.leng()/2;i++)//用for循环将这二个多项式结果输出{cout<<s1.gete(2*i-1)<<"X^"<<s1.gete(2*i);if(i!=s1.leng()/2)cout<<"+";}cout<<endl;}五、程序运行结果截图。

[计算机]一元多项式相加完整实验报告

[计算机]一元多项式相加完整实验报告一元多项式的相加一实验内容根据所学的数据结构中线性结构(线性表)的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加二需求分析1掌握线性结构的逻辑特性和物理特性。

2建立一元多项式。

3将一元多项式输入，并存储在内存中，并按照指数降序排列输出多项式。

4能够完成两个多项式的加减运算，并输出结果。

三概要设计1 本程序所用到的抽象数据类型:typedef OrderedLinkList polynomial;// 用带表头结点的有序链表表示多项式结点的数据元素类型定义为:typedef struct { // 项的表示oat flcoef; // 系数int expn; // 指数 term, ElemType;Void AddPolyn(polynomail&Pa,polynomail&Pb)Position GetHead()Position NextPos(LinkList L,Link p)Elem GetCurElem(Link p)int cmp(term a term b)Status SetCurElem(Link&p, ElemType e)Status DelFirst(Link h, Link &q)Status ListEmpty(LinkList L)Status Append(LinkList&L, Link S)FreeNode()2 存储结构一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。

它包含三个域，分别存放多项式的系数，指数，以及指向下一个项的指针。

序数coef 指数exp 指针域next创建一元多项式链表，对运算中可能出现的各种情况进行分析，实现一元多项式的相加相减操作。

3 模块划分a) 主程序;2)初始化单链表;3)建立单链表; 4)相加多项式 4 主程序流程图开始申请结点空间输入多项式各项的系数X，指数Y输出已输出的多项式否是否输入正确合并同类项结束四详细设计根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项，对于两个一元多项式中所有指数不相同的项，则分别复抄到“和多项式”中去。

数据结构-实验一-一元多项式相加

数据结构实验报告实验一：一元多项式相加姓名：周成学号： 13083511专业：软件工程任课教师：马慧珠2013年12 月01 日1.实验名称：一元多项式相加2.实验目的:如何使用C语言实现链表的说明、创建以及结点的插入和删除等操作。

3.实验要求：对一元多项式能实现输入、输出，以及两个一元多项式相加及结果显示。

4.实验内容：一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。

它包含三个域，分别存放多项式的系数，指数，以及指向下一个项的指针。

根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项，对于两个一元多项式中所有指数不相同的项，则分别复抄到“和多项式”中去。

核心算法PolyAdd是把分别由pa和pb所指的两个多项式相加，结果为pa所指的多项式。

运算规则如下：相加时，首先设两个指针变量qa和qb分别从多项式的首项开始扫描，比较qa和qb所指结点指数域的值，可能出现下列三种情况之一：（1）qa->exp大于qb->exp,则qa继续向后扫描。

（2）qa->exp等于qb->exp,则将其系数相加。

若相加结果不为零，将结果放入qa->coef中，并删除qb所指结点，否则同时删除qa和qb所指结点。

然后qa、qb继续向后扫描。

（3）qa->exp小于qb->exp,则将qb所指结点插入qa所指结点之前，然后qa、qb继续向后扫描。

扫描过程一直进行到qa或qb有一个为空为止，然后将有剩余结点的链表接在结果表上。

所得pa指向的链表即为两个多项式之和。

5.实验程序代码及运行结果：#include"stdafx.h"#include<stdio.h>#include<stdlib.h>#include<malloc.h>#include<stdio.h>#define NULL 0typedef struct NODE{float coef; //系¦Ì数ºyint expn; //指?数ºystruct NODE *next;}NODE;NODE *Creat(int n);void print(NODE *head);NODE *AddPolyn(NODE *head1, NODE *head2);NODE *Delfirst(NODE *head, NODE *q);void InsertBefore(NODE *p1, NODE *p2);int compare(int a, int b);/*创ä¡ä建¡§链¢¡ä表À¨ª*/NODE *Creat(int n){NODE *current, *previous, *head;int i;head = (NODE *)malloc(sizeof(NODE)); /*创ä¡ä建¡§头ª¡¤结¨¢点Ì?*/previous = head;for(i = 0; i < n; i++){current = (NODE *)malloc(sizeof(NODE));printf("请?输º?入¨?系¦Ì数ºy和¨ª指?数ºy : ");scanf("%f%d", &current->coef, &current->expn);previous->next = current;previous = current;}previous->next = NULL;return head;}/*一°?元a多¨¤项?式º?的Ì?想?加¨®，ê?总Á¨¹体¬?考?虑?，ê?可¨¦分¤?qa的Ì?指?数ºy比À¨¨qb小?，ê?或¨°等Ì¨¨于®¨²pb(如¨?果?系¦Ì数ºy相¨¤加¨®等Ì¨¨于®¨²0和¨ª不?等Ì¨¨于®¨²0),或¨°大ä¨®于®¨²pb里¤?面?由®¨¦InsertBefore和¨ªDelfirst两¢?个?小?模¡ê块¨¦组Á¨¦成¨¦一°?部?分¤?*/ NODE *AddPolyn(NODE *head1, NODE *head2){NODE *ha, *hb, *qa, *qb;int a, b;float sum;ha = head1; /*ha和¨ªhb指?向¨°头ª¡¤结¨¢点Ì?*/hb = head2;qa = ha->next; /*qa和¨ªqb指?向¨°头ª¡¤结¨¢点Ì?的Ì?下?一°?个?结¨¢点Ì?*/qb = hb->next;while(qa && qb) /*qa和¨ªqb均¨´非¤?空?*/{a = qa->expn;b = qb->expn;switch(compare(a, b)) {case -1 : /*qa->expn < qb->expn*/ha = qa;qa = qa->next;break;case 0 :sum = qa->coef + qb->coef; /*系¦Ì数ºy的Ì?和¨ª*/if(sum != 0.0) { /*如¨?果?不?是º?0.0*/qa->coef = sum; /*改?变À?系¦Ì数ºy*/ha = qa;}else{free(Delfirst(ha, qa));}free(Delfirst(hb, qb));qa = ha->next;qb = hb->next; /*qb释º¨ª放¤?后¨®要°a重?新?赋3值¦Ì*/ break;case 1 : /*如¨?果?qa-> expn > qb -> expn*/Delfirst(hb, qb);InsertBefore(ha, qb); /*把ã?qb插?入¨?到Ì?ha下?一°?个?结¨¢点Ì?之?前¡ã*/qb = hb->next;ha = ha->next;break;}}if(qb)ha->next = qb; /*插?入¨?剩º¡ê余®¨¤的Ì?pb*/free(head2);return head1;}/*比À¨¨较?*/int compare(int a, int b){if(a < b)return -1;else if(a > b)return 1;elsereturn 0;}/*删¦?除y结¨¢点Ì?q*/NODE *Delfirst(NODE *p1, NODE *q){p1 -> next = q -> next;return (q);}/*插?入¨?结¨¢点Ì?,引°y入¨?结¨¢点Ì?p,可¨¦以°?让¨?p插?入¨?到Ì?p2和¨ªp1之?间?*/ void InsertBefore(NODE *p1, NODE *p2){NODE *p;p = p1->next;p1->next = p2;p2->next = p;}/*打ä¨°印®?,为a了¢?美¨¤观?程¨¬序¨°分¤?开a打ä¨°印®?*/void print(NODE *head){NODE *current;current = head->next;while(current->next != NULL){printf("%0.f * x^%d + ", current->coef, current->expn);current = current -> next;}printf("%0.f * x^%d", current->coef, current->expn);//system（ê¡§"pause");}int main(){NODE *head1, *head2, *head3;int n1, n2;printf("请?输º?入¨?你?需¨¨要°a的Ì?多¨¤项?式º?的Ì?项?数ºy n1 : "); scanf("%d", &n1);head1 = Creat(n1);printf("第Ì¨²一°?个?多¨¤项?式º?的Ì?显?示º? : \n");print(head1);printf("\n请?输º?入¨?你?需¨¨要°a的Ì?多¨¤项?式º?的Ì?项?数ºy n2 : "); scanf("%d", &n2);head2 = Creat(n2);printf("\n第Ì¨²二t个?多¨¤项?式º?的Ì?显?示º? : \n");print(head2);head3 = AddPolyn(head1, head2);printf("\n合?并¡é后¨®的Ì?多¨¤项?式º?的Ì?显?示º? : \n");print(head3);printf("\n");}运行结果：实验数据1如图：输入一个四次二项式X^3+2X^4，一个五次二项式X^4+2X^5，输出如图：实验数据2如图：输入一个五次四项式X^2+X^3+X^4+X^5，还有一个五次五项式1+X+X^3+2X^4+2X^5输出如图所示实验数据3如图：输入一个七次三项式1+2x^5+3X^7，还有一个五次四项式1+2X^2+3X^4+4X^5,输出如图：6.实验总结本来我对编程很没有信心，做这样一个课程设计感觉有点吃力，虽然有些人觉得很简单，但是我还是坚持做下来了，我不断的看书，翻阅资料，询问同学，上网搜索，总算有模有样地把这个程序编的能运行了。

实验报告示例(实验一_一元多项式相加)

实验一一元多项式相加（实验报告示例）一、需求分析1、本演示程序中，多项式的系数限定为整数，多项式的长度由用户预先输入，利用链表实现队列的构造。

每次输入一项的系数和指数，可以输出构造的一元多项式。

2、演示程序以用户和计算机的对话方式执行，即在计算机终站上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运行命令；最后根据相应的输入数据（滤去输入中的非法字符）建立的多项式以及多项式相加的运行结果在屏幕上显示。

多项式显示的格式为：c1x^e1+c2x^e2+…+cnx^en3、程序执行的步骤包括：1）输入多项式的项数及系数，建立多项式；2）实现多项式的相加；3）输出相加结果4、测试数据：(1)(2x+5x^8-3x^11)+(7-5x^8+11x^9)(2)(3-x+4^x2-2x^9)+(-6^x+5x^2+7x^15)(3)(x+x2+x3)+0(4)(x+x^3)+(3-x)二、概要设计为了实现上述程序功能，根据一元多项式的特点，可以构造链式存储的线性表存放一元多项式各式的信息。

1、主要思想：根据多项式的结构特点，利用线性链表来实现多项式相加，结点中存放各项的系数和指数，在默认用户按升幂次序输入多项式的各项后，构造相应的多项式。

从头扫描两个多项式，用两个指针分别指示两个多项式的当前项，根据多项式相加的规则，对于指数相同的项，将其对应系数相加，若和不为零，则构成“和多项式”中的一项；对于两个多项式中指数不同的项，可直接复制到和多项式中，并按从小到大的升幂排列2、本程序包含四个模块1）主函数void main(){初始化；建立两个链表A和B；输出建立的链表；A与B的相加，并输出}2）建立多项式函数createpoly()——根据用户输入的项数，提示用户输入系数和指数，建立链式存储的一元多项式3）输出多项式函数outpoly()——根据日常的阅读习惯将多项式按格式输出4）多项式相加函数addpoly()——按照多项式相加的法则实现两个多项式的相加各模块之间的调用关系及接口如下：三、详细设计1、元素类型、结点类型和指针类型：typedef int ElemType;typedef struct mulpoly{ElemType coef;ElemType exp;struct mulpoly * next;};2、主函数和其他函数清单struct mulpoly * createpoly(int n) //根据用户输入的项数n，提示用户输入n组系数和指数，并构建链式线性表存储多项式信息{}void outpoly(struct mulpoly * head)// 将以head为头指针的链表按多项式的格式输出{}struct mulpoly * addpoly(struct mulpoly * ha,struct mulpoly *hb)// 将以ha,hb为头指针的两个链式按多项式相加的法则进行合并，放在hc中，并将hc返回void main(){}四、调试分析1、在建立链表和多项式相加时，新生成链表的头指针做为参数传递时，曾忽略了参数的标识“&”，致使建立链表失败。

一元多项式相加实验报告

一元多项式相加实验报告一元多项式相加实验报告引言：一元多项式是高中数学中的重要概念，它在代数运算中具有广泛的应用。

本次实验旨在通过实际操作，探究一元多项式的相加规律，并验证其正确性。

实验步骤：1. 准备工作：将实验所需材料准备齐全，包括纸张、铅笔、计算器等。

2. 设定实验目标：选择两个一元多项式进行相加操作，并记录相加过程。

3. 编写一元多项式：根据实验要求，编写两个一元多项式，如P(x)和Q(x)。

4. 相加操作：按照一元多项式相加的规则，对P(x)和Q(x)进行相加操作。

5. 记录结果：将相加的结果记录下来，并进行必要的化简。

6. 分析结果：分析相加结果的特点和规律，并与理论知识进行对比。

7. 总结实验：总结实验过程中的收获和体会，并提出相加操作的注意事项。

实验结果：通过实验操作，我们得到了两个一元多项式相加的结果。

例如，设定P(x) =2x^3 + 5x^2 - 3x + 1，Q(x) = -x^3 + 4x^2 + 2x - 2，经过相加操作后，得到R(x) = x^3 + 9x^2 - x - 1。

可以看出，相加结果的次数和系数分别是两个一元多项式次数和系数的相加。

结果分析：从实验结果中可以发现，一元多项式相加的规律是将相同次数的项的系数相加，并保留该次数的项。

这与我们在学习一元多项式时所掌握的知识是一致的。

通过实验操作，我们验证了一元多项式相加的正确性。

实验总结：本次实验通过实际操作验证了一元多项式相加的规律，加深了对一元多项式的理解。

在实验过程中，我们还发现了一些注意事项。

首先，要注意相加过程中的计算准确性，尤其是在涉及到多项式次数较高时。

其次，要注意对相加结果进行化简，以便更好地观察和分析。

最后，实验过程中要保持仔细和认真，确保实验结果的可靠性。

结论：通过本次实验，我们验证了一元多项式相加的规律，并得出了相加结果的特点和规律。

一元多项式相加是代数运算中的重要内容，掌握相加规律对于深入理解和应用一元多项式具有重要意义。

一元多项式的表示及相加实验报告

显示多项式中用swichcase语句表示当系数为01或者更多的情况剩下的是主函数的实现调用linklist构建l1l2两个多项式实现相加相加时分系数相等l1系数大于l2l1系数小于l2三种情况l2入到l1中则要考虑l1l2的长度当l1或l2为空时则直接插入另一链表
测试过程：（实验中出现的问题、错误、解决方法）刚开始逻辑出现问题，运行时，总是显示不出来，然后问同学才知道在 showList 这个成员函数中 Node *curr = this->head->next; 没有具体说明 curr 该怎样用和 public 中没声明 Node* getHead(){return head;} int deleteNode(Node *cur);是后面的 main 函数 wufayunxing
一元多项式的表示及相加验证性实验时间 2011.09.29
实验环境 C++给认真掌握签名任亚平 2011-10-13 月日年
WindowsXP 系统 DEV C+&了解线性表的各种存储结构。 2.熟练掌握在各种存储结构上进行插入、删除等操作的算法。
3.通过线性表结构解决现实中的一些问题。
实验内容：
一元多项式的表示及相加。
while(p1!=0&&p2!=0){ if(p1->zhishu=p2->zhishu){ p1->xishu=p1->xishu+p2->xishu; if(p1->xishu=p2->xishu){ Node *c1=p1; Node *c2=p2; p1 = p1->next; p2 = p2->next; l1.DeleteList(pre1,c1); l2.DeleteList(pre2,c2); } else{ Node *c2=p2; pre1=pre1->next; p1 = p1->next; p2 = p2->next; l2.DeleteList(pre2,p2); } } if(p1->xishu < p2->xishu){ pre1=pre1->next; p1=p1->next; } if(p1->xishu > p2->xishu){ Node *temp = p2->next; l1.InsertList(pre1,p2); pre1 = pre1->next; p2 = temp; } } if(p1 == NULL && p2!=NULL){ pre1->next = p2; }

一元多项式的相加减

实验一一元多项式的表示和相减、相乘一、实验目的1.掌握链表的存储方式2.掌握一元多项式的存储及运算。

二、实验内容已知一元多项式P(x)和Q(x)已存在，求P(x)-Q(x)和P(x)* Q(x)并输出。

要求：1.通过键盘随机输入两多项式P(x)和Q(x)的内容。

2.输出结果要有P(x)和Q(x)的以及它们的差P(x)-Q(x)和乘积P(x)* Q(x)。

三、实验步骤：1.创建一元多项P(x)和Q(x)。

2.求P(x)-Q(x)，P(x)* Q(x)。

3.输出P(x)、Q(x)、P(x)-Q(x)，P(x)* Q(x)。

四、算法说明首先，定义一元多项式的存储方式，然后从键盘输入P(x)和Q(x)对应多项式的各对系数和指数，建立相应的一元多项式五、测试结果参考下图多项式相减多项式相乘六、源代码1.多项式的相减# include<stdio.h># include<malloc.h>typedef struct{float coef; //系数int expn; //指数}ElemType;typedef struct LNode{ //结点类型ElemType data;struct LNode *next;}*LinkList;void MakeNode(LinkList &s,ElemType e){//生成结点s=(LinkList)malloc(sizeof(LNode));s->data=e;}void InsAfter(LinkList p,LinkList s){//插入结点s->next=p->next;p->next=s;}int compare(ElemType e1,ElemType e2){//比较if(e1.expn>e2.expn)return 1;else if(e1.expn<e2.expn)return -1;return 0;}void OrderInsert(LinkList &L,ElemType e,int(*compare)(ElemType,ElemType)){//有序插入LinkList p=L,q=p->next,s;while(q){int n=compare(e,q->data);if(n<0){MakeNode(s,e);InsAfter(p,s);break;}else if(n==0){q->data.coef=q->data.coef+e.coef;if(q->data.coef==0){p->next=q->next;free(q);}break;}p=p->next;q=p->next;}if(q==NULL){MakeNode(s,e);InsAfter(p,s); //最大，放在最后一个位置}}void InitList(LinkList &L){//初始化L=(LinkList)malloc(sizeof(LNode));L->next=NULL;}void SetCurElem(LinkList &p,ElemType e){ //设置结点p->data.coef=e.coef;p->data.expn=e.expn;}void CreatePolyn(LinkList &L,int m){InitList(L);ElemType e;e.coef=0.0;e.expn=-1;SetCurElem(L,e);//设置头结点的数据元素printf("请输入%d对多项式的值：\n",m);for(int i=1;i<=m;i++){scanf("%f%d",&e.coef,&e.expn); //输入值OrderInsert(L,e,compare);}}void show(LinkList L){//输出方法LinkList p=L->next;if(p){ //第一个输出printf("%.2fX^%d",p->data.coef,p->data.expn);p=p->next;}while(p){if(p->data.coef>0)printf("+");printf("%.2fX^%d",p->data.coef,p->data.expn);p=p->next;}printf("\n");}void ListDestroy(LinkList &L){//销毁LinkList p=L,q;while(p){q=p;p=p->next;free(q);}}void subtract(LinkList L1,LinkList L2,LinkList &L3){//多项式相减ElemType e;InitList(L3);e.coef=0.0;e.expn=-1;SetCurElem(L3,e);//设置头结点的数据元素LinkList p1=L1->next,p2=L2->next,q;//r1始终指向新建链表的尾部,p1和p2表示当前结点while(p2){p2->data.coef=-p2->data.coef;p2=p2->next;}p2=L2->next;while(p1&&p2){int n=compare(p1->data,p2->data);switch(n){case -1:{OrderInsert(L3,p1->data,compare);p1=p1->next;break;} //L1中的值小，插入之case 1:{OrderInsert(L3,p2->data,compare);p2=p2->next;break;} //L2中的值小，插入之case 0:{ //相同e.coef=p1->data.coef+p2->data.coef;e.expn=p1->data.expn;if(e.coef!=0){OrderInsert(L3,e,compare);}p1=p1->next;p2=p2->next;break;}}}if(p1){OrderInsert(L3,p1->data,compare);p1=p1->next;} //添加L1else if(p2){OrderInsert(L3,p2->data,compare);p2=p2->next;} //添加L2}LinkList FindThan( LinkList X, LinkList L ){LinkList Tmp;Tmp = L;while( Tmp->next != NULL && Tmp->next->data.expn >= X->data.expn ) {Tmp = Tmp->next;}return Tmp;}int main(){LinkList L1,L2,L3,L4;int m,n;printf("请输入多项式P(X)的项数：");scanf("%d",&m);CreatePolyn(L1,m);printf("多项式P(X)为：\n");show(L1);printf("请输入多项式Q(X)的项数：");scanf("%d",&n);CreatePolyn(L2,n);printf("多项式Q(X)为：\n");show(L2);subtract(L1,L2,L3);printf("多项式P(X)-Q(X)为：\n");show(L3);return 0;}2.多项式的相乘# include<stdio.h># include<malloc.h>typedef struct{float coef; //系数int expn; //指数}ElemType;typedef struct LNode{ //结点类型ElemType data;struct LNode *next;}*LinkList;void MakeNode(LinkList &s,ElemType e){//生成结点s=(LinkList)malloc(sizeof(LNode));s->data=e;}void InsAfter(LinkList p,LinkList s){//插入结点s->next=p->next;p->next=s;}int compare(ElemType e1,ElemType e2){//比较if(e1.expn>e2.expn)return 1;else if(e1.expn<e2.expn)return -1;return 0;}void OrderInsert(LinkList &L,ElemType e,int(*compare)(ElemType,ElemType)){//有序插入LinkList p=L,q=p->next,s;while(q){int n=compare(e,q->data);if(n<0){MakeNode(s,e);InsAfter(p,s);break;}else if(n==0){q->data.coef=q->data.coef+e.coef;if(q->data.coef==0){p->next=q->next;free(q);}break;}p=p->next;q=p->next;}if(q==NULL){MakeNode(s,e);InsAfter(p,s); //最大，放在最后一个位置}}void InitList(LinkList &L){//初始化L=(LinkList)malloc(sizeof(LNode));L->next=NULL;}void SetCurElem(LinkList &p,ElemType e){ //设置结点p->data.coef=e.coef;p->data.expn=e.expn;}void CreatePolyn(LinkList &L,int m){InitList(L);ElemType e;e.coef=0.0;e.expn=-1;SetCurElem(L,e);//设置头结点的数据元素printf("请输入%d对多项式的值：\n",m);for(int i=1;i<=m;i++){scanf("%f%d",&e.coef,&e.expn); //输入值OrderInsert(L,e,compare);}}void show(LinkList L){//输出方法LinkList p=L->next;if(p){ //第一个输出printf("%.2fX^%d",p->data.coef,p->data.expn);p=p->next;}while(p){if(p->data.coef>0)printf("+");printf("%.2fX^%d",p->data.coef,p->data.expn);p=p->next;}printf("\n");}void ListDestroy(LinkList &L){//销毁LinkList p=L,q;while(p){q=p;p=p->next;free(q);}}void Multiply(LinkList L1,LinkList L2,LinkList &L3){//多项式相乘ElemType e;InitList(L3);e.coef=0.0;e.expn=-1;SetCurElem(L3,e);//设置头结点的数据元素LinkList p1=L1->next,p2=L2->next,q;//r1始终指向新建链表的尾部,p1和p2表示当前结点while(p1){p2=L2->next;while(p2){e.coef=p1->data.coef*p2->data.coef;e.expn=p1->data.expn+p2->data.expn;OrderInsert(L3,e,compare);p2=p2->next;}p1=p1->next;} }int main(){LinkList L1,L2,L3;int m,n;printf("请输入多项式P(X)的项数：");scanf("%d",&m);CreatePolyn(L1,m);printf("多项式P(X)为：\n");show(L1);printf("请输入多项式Q(X)的项数：");scanf("%d",&n);CreatePolyn(L2,n);printf("多项式Q(X)为：\n");show(L2);Multiply(L1,L2,L3);printf("多项式P(X)*Q(X)为：\n");show(L3);return 0;}七、分析总结本程序从源代码开始经过多次调试，一开始创建多项式并没有遇到什么问题，但是减法开始遇到问题，好在经过调试和反复检验后问题都得以解决，在多项式相加的基础上修改，相减和相乘就容易得多。

一元多项式实验报告

实验二一元多项式相加问题本实验的目的是进一步熟练掌握应用链表处理实际问题的能力。

一、【问题描述】一元多项式相加是通过键盘输入两个形如P0+P1X1+P2X2+…+P n X n 的多项式，经过程序运算后在屏幕上输出他们的相加和。

二、【数据结构设计】分析任意一元多项式的描述方法可知，一个一元多项式的每一个子项都是有“系数－指数”两部分来组成的，所以将它可以抽象成一个由“系数－指数对”构成的线性表，由于对多项式中系数为0的子项可以不记录它的指数值，对于这样的情况就不再付出存储空间来存放它了。

基于这样的分析，我们可以采用一个带有头结点的单链表来表示一个一元多项式。

具体数据类型定义为：typedef struct Polynomial{Float coe; //系数int exp; //指数struct Polynomial *next;}*Polyn,Polynomial; 这三个指针分别作为链表A、B、C的头指针。

三、【功能（函数）设计】1、输入并建立多项式的功能模块：此模块要求按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项的“系数－指数对”，输入一个子项建立一个相关结点，当遇到输入结束标志的时候就停止输入，而转去执行程序下面的部分。

2、多项式相加的功能模块此模块根据在1中建立的两个多项式进行相加的运算，并存放在以C为头指针的一个新链表中。

可以采用如下的方法进行设计：设指针p、q、r分别指向描述多项式的链表A、B、C头部，p指针按照A中结点顺序一个一个的移动，每移动一个结点，就通过q指针的移动来寻找B中是否有与p→exp相同的，（1）如果有，在C中合适的位置（注意多项式存储是按照指数递增有序的）建立新结点，并做如下赋值操作：r→coef=p→coef＋q→coef;r→exp=p→exp;p→flag=1;q→flag=1; /*标志子项已参与过运算*/p=p→next;q=head_b;（2）如果没有，在C中合适的位置（注意多项式存储是按照指数递增有序的）建立新结点，并做如下赋值操作：r→coef=p→coef;r→exp=p→exp;p=p→next;q=head_b;注意：当A、B中可以相加的两项的系数和为0的时候，在C中就不用分配新的空间来进行存储了。

数据结构实验-一元多项式的加法运算

一元多项式加法一、实验目的通过实现多项式加法，对链表有更深入的了解二、实验内容问题描述：设计一个一元稀疏多项式简单的加法计算器实现要求：一元稀疏多项式简单计算器的基本功能是：（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）测试结果分析：程序运行结果和预测的完全相同，说明所设计的一元多项式的加法是正确的。

完整word版一元多项式求和实验报告范文_

完整word版一元多项式求和实验报告范文_实验一、线性结构综合应用一、实验题目：顺序表的应用二、实验内容：一元多项式求和。

把任意给定的两个一元多项式P(某),Q(某)输入计算机，计算它们的和并输出计算结果。

三、设计分析：实现要定义的一元多项式应采用链式存储结构。

根据一元多项式相加的运算法则，对于两个多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成新多项式的一项；对于两个多项式中所有指数不同的项，分别复制到新多项式中。

新多项式不必另外生成，而是在原来的两个多项式中摘取结点即可。

采用顺序存储结构存储多项式系数A，使多项式的某些运算变得更简洁。

但在实际使用时，多项式的阶数可能很高，不同的多项式阶数可能相差很大，这使顺序存储结构的最大长度难以确定。

而且，最高次幂与最低次幂项之间缺项很多时，采用顺序存储结构显然十分浪费存储空间，因此，一般情况下多采用链式存储结构来存储高阶多项式。

在用线性链表来存储一个多项式时，多项式中的每个非零项系数对应一个结点，结点由数据元素项和指针组成。

数据元素项中包含系数和指数值，设计中先定义定义数据元素中的数据，其中有指数、系数级指针ne某t等。

并要先构造一元多项式。

在定义输出、删除、合并等模块。

假设指针qa和qb分别指向多项式A和B中当前进行操作的某个结点，比较这个结点的指数项，可能有三种情况：①指针qa->e某p<qb->e某p,则摘取qa指针所指结点插入到和多项式中；②指针qa->e某p<qb->e某p,则摘取qb指针所指结点插入到和多项式中；③指针qa->e某p=qb->e某p,则将系数相加，若和数不为零，则修改qa->coef的值，同时释放qb所指结点，反之，从多项式A的链表中删除相应的结点，并释放指针Pa和Pb所指结点；还有就是在输入是采取的降序输入，也好使两个多项式进行合并。

并输出。

在主函数中将前面也的这些功能都运用起来就可以了四、程序代码：#include<iotream>#defineNULL0uingnamepacetd;typedeftructPolynomial{floatcoef;//系数inte某p;//指数tructPolynomial某ne某t;}Polynomial;Polynomial某CreatPolyn(){//输入m项的系数和指数，建立一元多项式floatmod;intind;Polynomial某H,某p,某;H=newPolynomial;=H;潣瑵请输入多项式的系数和指数：(按0结束输入)<<endl; cin>>mod>>ind;while(mod){p=(Polynomial某)newPolynomial;p->coef=mod;p->e某p=ind;->ne某t=p;=p;cin>>mod>>ind;}->ne某t=NULL;returnH;}voidPrint(Polynomial某pa){//打印输出一元多项式pwhile(pa->ne某t!=NULL){pa=pa->ne某t;cout<<pa->coef<<某某^<<pa->e某p;if(pa->ne某t!=NULL&&pa->ne某t->coef>0) cout<<+;}}voidDelete(Polynomial某pa){//删除一元多项式Polynomial某p,某q;p=pa->ne某t;while(p){q=p;p=p->ne某t;deleteq;}pa->ne某t=NULL;}voidAddPolyn(Polynomial某pa,Polynomial某pb) {//用于链表的合并使用完成多项式的相加运算floatum;Polynomial某p,某q,某pre,某temp;p=pa->ne某t;q=pb->ne某t;pre=pa;while(p!=NULL&&q!=NULL){if(p->e某p>q->e某p){pre->ne某t=p;pre=pre->ne某t;p=p->ne某t;}eleif(p->e某p==q->e某p) {um=p->coef+q->coef;if(um!=0){p->coef=um;pre->ne某t=p;pre=pre->ne某t;p=p->ne某t;temp=q;q=q->ne某t; deletetemp;}ele{temp=p->ne某t;deletep;p=temp;temp=q->ne某t;deleteq;}}ele{pre->ne某t=q;pre=pre->ne某t;q=q->ne某t;}}if(p!=NULL)//将多项式A中剩余的结点加入到和多项式中pre->ne某t=p;elepre->ne某t=q;}intmain(){intc;intt=1;cout<<某某某某某某某某某某某某某某某某某某菜单某某某某某某某某某某某某某某某某某<<endl<<endl;cout<<.创建并显示一元多项式A和B，计算一元多项式A加B并显示和<<endl<<endl;cout<<.退出程序.<<endl;cin>>c;witch(c){cae1:Polynomial某p1,某p2;p1=CreatPolyn();潣瑵一元多项式A是:;Print(p1);cout<<endl;p2=CreatPolyn();潣瑵一元多项式B是:;Print(p2);cout<<endl;AddPolyn(p1,p2);潣瑵一元多项式A加B的和是:;Print(p1);cout<<endl;Delete(p1);break;cae2:t=0;break;}}ytem(paue);return0;}五、测试用例：六、实验总结通过这次实验，对于链表的应用知识有了更加深刻的认识，虽然中间出了很多问题，但是经过调试以后都得以解决。