C++一元多项式合并实验报告

合集下载

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

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

南昌航空大学实验报告课程名称:数据结构实验名称:实验二线性表的链式存储结构班级: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.使用C语言编写一元多项式运算的程序
2.理解和掌握链表的基本概念和操作
3.熟悉链表在实际问题中的应用
实验内容
1.设计一元多项式数据结构,支持多项式的输入、输出、加、减、乘、求导等计算。

2.使用链表来实现多项式数据结构。

3.编写测试程序,测试多项式数据结构的正确性和效率。

实验步骤
1.设计一元多项式数据结构,包括多项式中的每一项所包含的系数和指数,以及链表节点结构体定义。

typedef struct node
{
float coef; // 系数
int expn; // 指数
struct node *next; // 指向下一个节点的指针
} Node, *pNode;
2.按照上述定义的结构体,实现多项式的输入函数。

3.利用链表实现多项式的加法函数。

6.编写测试程序,测试多项式数据结构的正确性和效率。

实验结果
1.输入第一个多项式为 3x^3+2x^2+3 第二个多项式为 2x^3+x^2+4x+1
2.经过程序的处理,两个多项式的加法结果为 5.00x^3+
3.00x^2+
4.00x+4.00
两个多项式的乘法结果为
6.00x^6+10.00x^5+5.00x^4+10.00x^3+14.00x^2+19.00x+3.00
第一个多项式求导结果为 9.00x^2+4.00x
1.链表可以有效地实现多项式数据结构的存储和操作,具有较好的效率和灵活性。

2.通过本次实验,能够更加深入地理解数据结构中链表的应用,有助于提高编程能力和实际问题解决能力。

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

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

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

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

实验目的: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. 一元多项式的相加运算满足交换律和结合律。

一元多项式相加实验报告

一元多项式相加实验报告

一元多项式相加实验报告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掌握线性结构的逻辑特性和物理特性。

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输出已输出的多项式否是否输入正确合并同类项结束四详细设计根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相同的项,对应系数相加,若其和不为零,则构成“和多项式”中的一项,对于两个一元多项式中所有指数不相同的项,则分别复抄到“和多项式”中去。

一元多项式求和

一元多项式求和

实验二一.学生基本情况:专业班级:学号:姓名:二.实验题目、实验内容1、实验目的:(1)熟练掌握链表结构及有关算法的设计;(3)掌握用链表表示特定形式的数据的方法,并能编写出有关运算的算法。

2、实验内容:一元多项式求和。

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

三.设计分析先构造两个项链表,分别存储两个多项式的系数和指数,然后将每个链表按指数的大小从小到大排列,以便于后来的合并。

合并的伪代码如下:当然,多项式的输出也不简单,要考虑系数是否为1,为1时x前的系数不显示,指数是否为1,为1时也不显示。

还有最前面的项如果系数为正,则不显示+号。

四.源程序代码#include<stdio.h>#include<stdlib.h>#define M 50typedef struct node//项节点{float coef;//系数float exp;//指数node * next;//下一节点}Linode;void Initlinode(Linode * &L)//初始化{L=(Linode * )malloc(sizeof(Linode));L->coef=L->exp=0;L->next=NULL;}void Createlinode(Linode * &L,int n)//建立项链表{Linode * p,* s=L;int i;for(i=0;i<n;i++){printf("输入第%d个数的系数和指数:\n",i+1);p=(Linode * )malloc(sizeof(Linode));scanf("%f%f",&(p->coef),&(p->exp));s->next=p;p->next=NULL;s=p;}}void Destroylinode(Linode * &L)//销毁链表{Linode * p=L,* s=L->next;while(s!=NULL){free(p);p=s;s=s->next;}free(p);}bool Sort(Linode * &L)//排序{Linode * p, * pre,* q;if(L->next==NULL)return 0;p=L->next->next;L->next->next=NULL;while(p!=NULL){q=p->next;pre=L;while(pre->next!=NULL&&pre->next->exp<p->exp) pre=pre->next;p->next=pre->next;pre->next=p;p=q;}return 1;}bool Plus(Linode * &A,Linode * &B)//合并多项式{Linode * p=A->next, * q=B->next,* r=A,* s;if(q==NULL)return 0;while(p!=NULL&&q!=NULL){s=q->next;if(p->exp<q->exp){while(p!=NULL&&p->exp<q->exp){p=p->next;r=r->next;}}if(p!=NULL&&p->exp>q->exp){r->next=q;q->next=p;r=q;q=s;if(s!=NULL)s=s->next;}if(p!=NULL&&q!=NULL&&p->exp==q->exp){p->coef=p->coef+q->coef;if(p->coef==0){r->next=p->next;free(p);p=r->next;}else{p=p->next;r=r->next;}free(q);q=s;}}if(q!=NULL)r->next=q;return 1;}void Displinode(Linode * &L){Linode * p=L->next;while(p!=NULL){if(p->exp==0)printf("%.4f",p->coef);else if(p==L->next&&p->coef>=0){if(p->coef==1){if(p->exp==1)printf("x");elseprintf("x^%.2f",p->exp);}else{if(p->exp==1)printf("%.4fx",p->coef);elseprintf("%.4fx^%.2f",p->coef,p->exp);}}else{if(p->coef>=0){if(p->coef==1){if(p->exp==1)printf("+x");elseprintf("+x^%.2f",p->exp);}else{if(p->exp==1)printf("+%.4fx",p->coef);elseprintf("+%.4fx^%.2f",p->coef,p->exp);}}else{if(p->coef==-1){if(p->exp==1)printf("-x");elseprintf("-x^%.2f",p->exp);}else{if(p->exp==-1)printf("%.4fx",p->coef);elseprintf("%.4fx^%.2f",p->coef,p->exp);}}}p=p->next;}printf("\n");}void main(){int m,n;Linode* A;Linode* B;Initlinode(A);Initlinode(B);printf("输入P(x)的项数:");scanf("%d",&m);Createlinode(A,m);if(Sort(A)==1)printf("排序成功\n");printf("P(x)=");Displinode(A);printf("输入Q(x)的项数:");scanf("%d",&n);Createlinode(B,n);if(Sort(B)==1)printf("排序成功\n");printf("Q(x)=");Displinode(B);if(Plus(A,B)==1)printf("表达式为F(x)=");Displinode(A);Destroylinode(A);}五.测试用例(尽量覆盖所有分支)六.实验总结对于这个实验,我最开始的想法是输入字符串,然后将字符串拆分成几个项存入链表中,然后再排序,合并。

(完整word版)一元多项式计算器报告(C语言编程)

(完整word版)一元多项式计算器报告(C语言编程)

题目:编制一个一元多项式基本运算的程序姓名: 学号:PB110130一、需求分析1.在通常的应用中,多项式的次数可能很高且变化很大,使得顺序存储结构的最大长度很难确定。

由稀疏多项式的特点,故采用链式存储结构,可以不会带来浪费存储空间。

2.程序中单链表存储,根据链表的指数域,对链表进行升序排序,可给运算带来方便。

3.程序设计是在VC6.0环境下设计的的。

4.程序执行的命令为(程序主界面):二、概要设计抽象数据类型一元多项式的定义如下:1.LNode *MakeNode(double coef, int exp) 通过传入指数和系数创建一个节点,返回该节点的地址。

2.void InitList(LinkList &L)初始化,带头节点3.void PrintPolyn (LinkList L) 传入链表的指针,打印该链表4.LinkList CreatPolyn(void)//输入m项的系数和指数,建立表示一元多项式的有序链表L5.double SumPolyn(LinkList L,double x) 传入链表的指针及x值,求多项式的值。

6.void DestroyPolyn (LinkList &L) 销毁多项式,去掉头节点7.void ClearPolyn (LinkList &L) 清空多项式,保留节点实验报告8.void CopyPolyn (LinkList La,LinkList &Lb) 将La位置的多项式复制到Lb位置9.void AddPolyn(LinkList L,LinkList J ,LinkList &K) 将a和b多项式相加存到c10.void MultiplyPolyn(LinkList L,LinkList J,LinkList &K)将a和b相减存到c11. void MultiplyPolyn(LinkList L,LinkList J,LinkList &K)将a和b多项式相乘存到c12。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

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

一、问题描述
一元多项式相加是通过键盘输入两个形如P
0+P
1
X1+P
2
X2+···+PnX n的多项式,经过程序运算后在屏幕上输出它
们的相加和。

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

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

具体数据结构定义为:
typedef struct node
{
float ce; //系数域
float ex; //指数域
struct node *next; //指针域
}lnode,*linklist;
三功能(函数)设计
1、输入并建立多项式的功能模块
此模块要求按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项的“系数—指数对”,输入一个子项建立一个相关的节点,当遇到输入结束标志时结束输入,而转去执行程序下面的部分。

屏幕提示:
input ce & ex and end with 0:
ce=1
ex=2
ce=0
ex=0 //输入结束标志
input ce & ex and end with 0:
ce=2
ex=2
ce=0
ex=0 //输入结束标志
输入后程序将分别建立两个链表来描述两个一元多项式:
A=X^2
B=2X^2
这两个多项式的相加的结果应该为:
C=3X^2
2、多项式相加的功能模块
此模块根据在1中建立的两个多项式进行相加运算,并存放在以C为头指针的一个新建表中。

可以采用以下方法进行设计:
开始时a,b分别指向A,B的开头,如果ab不为空,进行判断:如果a所指的结点的指数和b所指的结点的指数相同,将它们的系数相加做成C式中的一项,如果不一样则将小的一项加到C中。

if(a->ex==b->ex) //判断指数是否相等
{s->ce=a->ce+b->ce;
if(s->ce!=0)
s->ex=a->ex;
else delete s;
a=a->next;
b=b->next;
}
直到将所有的结点都处理一遍,得到合并之后的C式。

3、多项式显示的功能模块
此模块用于多项式的显示,程序可以使用文本界面,用“系数—指数对”的形式表达表达式,如:A=X^2+2X^3+3X^4+5X^6
B=2X^2+3X^3+5X^5+7X^9
C=3X^2+5X^3+3X^4+5X^5+5X^6+7X^9
四、界面设计
提示用户每一步输入操作的格式和限制。

指导用户按照正确的格式输入数据。

五、编码实现
见源程序。

六、运行与测试
1、测试以下数据,比较结果:
(1)(2x+5x8-3.1x11)+(7-5x8+11x9)=-3.1x11+11x9+2x+7
(2)(x+x3)+(-x-x3)=0
(3)(x+x2+x3)+0= x+x2+x3
2、指数递增的顺序输入多项式,验证程序的健壮性和容错性。

七、试验完成后的思考
1、通过本程序熟练掌握了应用链表处理问题的能力,增加了处理细节问题的经验,达到了实验目的。

2、通过在设计过程中的讨论和思考,对使用现有知识系统利用计算机来解决数学问题确立了信心,对链表的意义
有了更深刻的理解,为今后的程序设计奠定了一定的心理基础和技术上的准备。

3、由于个人能力实在有限,程序中还有一些需要完善的地方,例如,程序不能做出对数据类型的判断;没有一个
美观的图形界面;输入方式复杂,极易出错,等等等等。

在今后的试验中要多多联系这方面的能力。

附:程序源代码
#include<iostream>
using namespace std;
typedef struct node{
float ce;
int ex;
struct node *next;
}lnode,*linklist;
linklist creat()
{
linklist L;
lnode *s,*r;
float m;
int n;
L=r=NULL;
cout<<"input ce & ex end and with 0:"<<endl;
cout<<"ce=";
cin>>m;
cout<<"ex=";
cin>>n;
while(m&&n) //结束
{
s=new lnode;
s->ce=m;
s->ex=n;
if(L==NULL)
L=s;
else r->next=s;
r=s;
cout<<"ce=" ;
cin>>m;
cout<<"ex=" ;
cin>>n;
}
if(r!=NULL)
r->next=NULL;
return L;
} //初始化并赋值
linklist add(linklist A,linklist B)
{
linklist C;
lnode *s,*r,*a,*b;
a=A;
b=B;
C=r=NULL;
while(a&&b)
{
s=new lnode;
if(a->ex==b->ex) //判断指数是否相等
{
s->ce=a->ce+b->ce;
if(s->ce!=0)
s->ex=a->ex;
else delete s;
a=a->next;
b=b->next;
}
else{if(a->ex>b->ex) //a<b
{s->ce=b->ce;
s->ex=b->ex;
b=b->next;
}
else{s->ce=a->ce; //a>b
s->ex=a->ex;
a=a->next;
}
}
if(C==NULL)
C=s;
else r->next=s;
r=s;
}
while(a) //B结束
{ s=new lnode;
s->ce=a->ce;
s->ex=a->ex;
a=a->next;
if(C==NULL)
C=s;
else r->next=s;
r=s;
}
while(b)
{s=new lnode;
s->ce=b->ce;
s->ex=b->ex;
b=b->next;
if(C==NULL)
C=s;
else r->next=s;
r=s;
}
s=new lnode;
s->ce=0;
s->ex=0;
s->next=NULL;
if(r!=NULL)
r->next=NULL;
return C;
cout<<"ok"<<endl;
}
void print(linklist L)
{
lnode *p;
p=L;
if(p->ce==0&&p->ex==0)
cout<<0;
else
while(p!=NULL)
{
if(p->ce!=1&&p->ce!=-1) //ce?=1
cout<<p->ce<<"x";
else if(p->ce!=1)
cout<<"-x";
else
cout<<"x";
if(p->ex!=1)
cout<<"^"<<p->ex;
if(p->next&&p->next->ce>0)
cout<<"+";
p=p->next;
}
cout<<"ok"<<endl;
}
int main()
{
linklist A,B,C;
A=creat();
print(A);
B=creat();
print(B);
C=add(A,B);
cout<<"ok"<<endl;
print(C);
return 0;
}。

相关文档
最新文档