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、本演示程序中,多项式的系数限定为整数,多项式的长度由用户预先输入,利用链表实现队列的构造。

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

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、在建立链表和多项式相加时,新生成链表的头指针做为参数传递时,曾忽略了参数的标识“&”,致使建立链表失败。

一元稀疏多项式计算器实验报告(c++编写,附源代码)

一元稀疏多项式计算器实验报告(c++编写,附源代码)

一元稀疏多项式计算器实验报告级班年月日学号_1.实验题目设计一个一元稀疏多项式简单计算器。

2.需求分析本程序用VC编写,实现一元浮点系数,整数指数稀疏多项式的创建、两个一元多项式相加、两个一元多项式相减、输出一元多项式。

①输入的形式和输入值的围:A.输入指定的数字,以此选择两个多项式的运算方式,运算方式有两个一元多项式相加、两个一元多项式相减。

B.创建多项式时,需要输入此多项式,每一项的系数和指数。

②输出的形式:每次输入一个完整的多项式后、每次得出多项式运算结果时,会以指定的方式输出多项式。

③程序所能达到的功能:实现一元稀疏多项式的创建、两个一元多项式相加、两个一元多项式相减、输出一元多项式。

④测试数据:输入数据:A.出现选择两个多项式的运算方式菜单时,输入1(即使两个多项式相加);B.首先输入多项式p的每一项系数和指数,当输入的指数为-5000时,表示该多项式输入完毕,输入的数据依次为:3,3,0,-5000;C.其次输入多项式q的每一项系数和指数,输入数据依次为:2,2,0,-5000。

输出结果:多项式q+p的结果为:多项式为:3x3+2x23.概要设计1)为了实现上述程序功能,需要定义多项式结点的抽象数据类型:class Term{数据对象:float coef; 该数据对象为多项式一项中的系数。

int exp; 该数据对象为多项式一项中的指数。

Term* link; 该数据对象为指向下一个多项式结点的指针。

基本操作:A. Term (float c, int e)初始条件:无操作结果:初始化多项式结点对象,将c赋值给该结点的数据成员coef(表示系数),将e赋值给该结点的数据成员exp(表示指数),将该结点的数据成员link赋值为0。

B.Term (float c, int e, Term* next)初始条件:无操作结果:初始化多项式结点对象,将c赋值给该结点的数据成员coef(表示系数),将e赋值给该结点的数据成员exp(表示指数),将next赋值给该结点的数据成员link(link表示指向下一个多项式结点的指针)。

一元多项式相加实验报告

一元多项式相加实验报告

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

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

实验步骤: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。

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

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

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

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

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

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

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

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

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

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

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

C++课程设计实验报告(一元多项式加减法)

C++课程设计实验报告(一元多项式加减法)

C++课程设计实验报告(一元多项式加减法)C++程序设计课程设计报告课题: 一元多项式加减法专业班级:学号:姓名:同组者姓名:指导教师:目录一、课程设计的目的意义.................................2二、程序报告要求.............................. 3三、程序流程图 (4)四、运行和调试.......................................5五、错误分析 (8)六、课程设计的心得...................................8七、参考书目.........................................9八、附录:源代码....................................101、设计系统的目的意义《数据结构》主要介绍一些最常用的数据结构,阐明各种数据结构内在的逻辑关系,讨论其在计算机中的存储表示,以及在其上进行各种运算时的实现算法,并对算法的效率进行简单的分析和讨论。

数据结构是介于数学、计算机软件和计算机硬件之间的一门计算机专业的核心课程,它是计算机程序设计、数据库、操作系统、编译原理及人工智能等的重要基础,广泛的应用于信息学、系统工程等各种领域。

学习数据结构是为了将实际问题中所涉及的对象在计算机中表示出来并对它们进行处理。

通过课程设计可以提高学生的思维能力,促进学生的综合应用能力和专业素质的提高。

通过此次课程设计主要达到以下目的:了解并掌握数据结构与算法的设计方法,具备初步的独立分析和设计能力;初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能;提高综合运用所学的理论知识和方法独立分析和解决问题的能力;训练用系统的观点和软件开发一般规范进行软件开发,培养软件工作者所应具备的科学的工作方法和作风。

2、程序及报告要求1、能够按照指数降序排列建立并输出多项式;2、能够完成两个多项式的相加、相减,并将结果输入;3、在上交资料中请写明:存储结构、多项式相加的基本过程的算法(可以使用程序流程图)、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法;3、程序流程图程序流程图如下:是4、运行和测试1、系统需求、功能分析:由用户输入两个一元多项式,计算得到它们的和、差并输出。

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

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

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

一、问题描述一元多项式相加是通过键盘输入两个形如P0+P1X1+P2X2+···+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=1ex=2ce=0ex=0 //输入结束标志input ce & ex and end with 0:ce=2ex=2ce=0ex=0 //输入结束标志输入后程序将分别建立两个链表来描述两个一元多项式:A=X^2B=2X^2这两个多项式的相加的结果应该为:C=3X^22、多项式相加的功能模块此模块根据在1中建立的两个多项式进行相加运算,并存放在以C为头指针的一个新建表中。

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

一元多项式课程设计报告

一元多项式课程设计报告

课程设计报告一元多项式系别:专业年级:学生姓名:学号 :任课教师:二○一一年三月一题目内容:一元多项式用C语言编写一段程序,该程序的功能相当于一个一元多项式计算器。

它能够实现按照指数降序排列建立并输出多项式,并且能够完成两个多项式的相加,相减的运算和将其结果输入的功能。

二解题分析2.1数据结构设计此程序的数据结构是选择用带头接待你的单链表存储多项式。

虽然一元多项式可以用顺序和链式两种存储结构表示,但是顺序结构的最大长度很难确定。

比如当多项式的系数比较大时,此时就会浪费了巨大的存储空间,所以应该选择用链式存储结构来存储一元多项式。

单链表的结构体可以用来存储多项式的系数和指数,下一个指针3个元素,这样便于实现任意多项式的加法,减法运算。

2.2 功能模块思路及设计(1)一元多项式的建立输入多项式采用采用头插法的方法,输入多项式汇总一个项的系数和指数,就产生一个新的节点,建立起来它的右指针并用头结点只想它;为了判断一个多项式是否舒服结束,定义一个结束标志,当输入为0时就结束一个多项式的输入。

(2)显示一元多项式如果系数是大于0的话就输出+系数x指数的形式;如果系数是小于0的话就输出系数X指数的形式;如果指数是0的话直接输出系数;如果系数是1的话就直接输出+X;如果系数是-1的话就直接输出-X。

(3)一元多项式的加法运算它从的两个多项式的头部开始,两个多项式的某一项都不为空时如果指数相等的话系数就应该相加;相加的和不为0的话,用头插法建立一个新的节点。

P的指数小于Q的指数的话,就应该复制Q节点到多项式。

P的指数大于Q的指数的话,就应该复制P节点到多项式,当第二个多项式为空,第一个多项式不为空时,将第二个多项式用新节点产生。

(4)一元多项式的减法它从的两个多项式的头部开始,两个多项式的某一项都不为空时如果指数相等的话系数就应该相减;相加的和不为0的话,用头插法建立一个新的节点。

P的指数小于Q的指数的话,就应该复制Q节点到多项式。

算法与数据结构实验一元多项式求和

算法与数据结构实验一元多项式求和

《算法与数据结构》实验报告姓名:***班级:计科01学号:**********实验题目:链表的应用实验内容:一元多项式求和把任意给定的两个一元多项式P(x),Q(x)输入计算机,计算它们的和并输出计算结果。

设计分析:一元多项式可以用单链表表示,结点结构图示如下:Array一元多项式链表的结点结构一元多项式算法伪代码如下:源程序代码:#include"StdAfx.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本À?程¨¬序¨°可¨¦以°?完ª¨º成¨¦两¢?个?一°?元a多¨¤项?式º?的Ì?加¨®法¤¡§运?算?。

¡ê\n");printf("请?输º?入¨?一°?元a多¨¤项?式º?a的Ì?项?数ºym:êo");scanf("%d",&m);printf("请?按ã¡ä照?从䨮低̨ª次ä?到Ì?高?次ä?的Ì?顺3序¨°依°¨¤此ä?输º?入¨?一°?元a多¨¤项?式º?a的Ì?系¦Ì数ºy和¨ª指?数ºy:êo\n");PutLinkList(a,m);printf("a=");OutLinkList(a);printf("请?输º?入¨?一°?元a多¨¤项?式º?b的Ì?项?数ºyn:êo");scanf("%d",&n);printf("请?按ã¡ä照?从䨮低̨ª次ä?到Ì?高?次ä?的Ì?顺3序¨°依°¨¤此ä?输º?入¨?一°?元a多¨¤项?式º?b的Ì?系¦Ì数ºy和¨ª指?数ºy:êo\n");PutLinkList(b,n);printf("b=");OutLinkList(b);c=AddLinkList(a,b);printf("两¢?个?多¨¤项?式º?的Ì?和¨ª为a:êo\na+b=");OutLinkList(c);}void PutLinkList(LinkList *&L,int n){LinkList *s,*r;L=(LinkList *)malloc(sizeof(LinkList));r=L;for(int i=0;i<n;i++){s=(LinkList *)malloc(sizeof(LinkList));printf("请?输º?入¨?第̨²%d项?的Ì?系¦Ì数ºy:êo",i+1);scanf("%d",&s->x);printf("请?输º?入¨?第̨²%d项?的Ì?指?数ºy:êo",i+1);scanf("%d",&s->z);r->next=s;r=s;}r->next=NULL;}void OutLinkList(LinkList *L) {char FuHao;LinkList *p=L->next;FuHao=p->x>0? '+':'-';if(FuHao=='-'){printf("%c",FuHao);if(p->x==-1)printf("1");}OutXLinkList(p);OutZLinkList(p);p=p->next;while(p!=NULL){FuHao=p->x>0? '+':'-';printf("%c",FuHao);OutXLinkList(p);OutZLinkList(p);p=p->next;}printf("\n");}void OutXLinkList(LinkList *L) {int xi=L->x>0? L->x:-L->x;if(L->x==1||L->x==-1);elseprintf("%d",xi);}void OutZLinkList(LinkList *L) {if(L->z==0);else if(L->z==1||L->z==-1){if(L->z<0){if(L->x==1||L->x==-1)printf("1");printf("/");}printf("X");}else{if(L->z<0)printf("/");int zhi=L->z>0? L->z:-L->z;printf("X^%d",zhi);}}LinkList *AddLinkList(LinkList *a,LinkList *b){a=a->next;b=b->next;LinkList *c,*d,*s;c=(LinkList *)malloc(sizeof(LinkList));d=c;while(a!=NULL&&b!=NULL){if(a->z<b->z){s=(LinkList *)malloc(sizeof(LinkList));s->x=b->x;s->z=b->z;d->next=s;d=s;b=b->next;}else if(a->z>b->z){s=(LinkList *)malloc(sizeof(LinkList));s->x=a->x;s->z=a->z;d->next=s;d=s;a=a->next;}else{s=(LinkList *)malloc(sizeof(LinkList));s->x=a->x+b->x;s->z=a->z;if(s->x==0);else{d->next=s;d=s;}a=a->next;b=b->next;}}if(a!=NULL)d->next=a;else if(b!=NULL)d->next=b;elsed->next=NULL;return c;}测试用例:当a=3x^8-x^5+2x^3+7x^2+5x,b=5x^5+3x^4-7x^2-3x^(-3)时,运行结果如下:试验总结:通过本次试验,学会了链表的应用,加深了对链表的理解,知道了链表是把线性表中的元素按照链式储存方式到计算机中的一片连续的储存空间中。

一元多项式实验报告

一元多项式实验报告

一元多项式实验报告一元多项式实验报告引言:一元多项式是高中数学中的重要概念之一,它在代数学、几何学以及其他数学领域中都有广泛的应用。

通过实验,我们可以深入了解一元多项式的性质和运算规则,并且探索其在实际问题中的应用。

实验一:多项式的表示和运算1. 实验目的通过实验,了解多项式的表示方法和基本运算规则。

2. 实验步骤a) 多项式的表示方法选择一个简单的多项式,如3x^2 + 2x - 1,通过观察和分析,了解多项式的系数、次数和项的概念。

b) 多项式的加法和减法选择两个多项式,如2x^3 + 3x^2 - 4x + 1和x^2 + 2x - 3,进行多项式的加法和减法运算,并观察运算结果。

c) 多项式的乘法选择两个多项式,如(x + 1)(x - 2)和(2x - 1)(3x + 2),进行多项式的乘法运算,并观察运算结果。

3. 实验结果与分析通过实验,我们可以发现多项式的表示方法是以字母和指数的形式来表示,其中字母代表未知数,指数代表该项的次数。

多项式的加法和减法运算与常规的数学运算类似,只需按照相同次数的项进行系数的加减运算。

多项式的乘法运算需要将每个项进行相乘,并按照指数的规则进行合并。

实验二:多项式的因式分解和求根1. 实验目的通过实验,了解多项式的因式分解和求根的方法。

2. 实验步骤a) 多项式的因式分解选择一个多项式,如x^2 + 3x + 2,通过观察和分析,尝试将其进行因式分解。

b) 多项式的求根选择一个多项式,如x^2 - 4,通过观察和分析,尝试求解其根的值。

3. 实验结果与分析通过实验,我们可以发现多项式的因式分解是将多项式拆解为若干个乘积的形式,每个乘积中的因子是多项式的一个因式。

多项式的求根是找到使得多项式等于零的未知数值,即方程的解。

通过因式分解和求根,我们可以进一步了解多项式的性质和特点。

实验三:多项式在实际问题中的应用1. 实验目的通过实际问题,探索多项式在实际应用中的作用。

一元多项式程序实验报告

一元多项式程序实验报告

一元多项式程序实验报告一、需求分析实现实系数一元多项式的创建,打印以及两个一元多项式的加、减、乘运算。

(1)程序所能达到的功能:a.实现一元多项式的输入;b. 实现一元多项式的输出;c. 计算两个一元多项式的和并输出结果;d. 计算两个一元多项式的差并输出结果;e. 计算两个一元多项式的积并输出结果。

(2)输入的形式和输入值的范围:输入要求:分行输入,每行输入一项,先输入多项式的指数,再输入多项式的系数,以0 0为结束标志,结束一个多项式的输入。

输入形式:2 3-1 23 01 20 0输入值的范围:系数为int型,指数为float型。

(3)输出的形式:要求:第一行输出多项式1;第二行输出多项式2;第三行输出多项式1与多项式2相加的结果多项式;第四行输出多项式1与多项式2相减的结果多项式;第五行输出多项式1与多项式2相乘的结果多项式注:多项式的每一项形如:2.0x^3,注意指数应保留一位小数;多项式按照升幂次序排列;系数为1的非零次项应略去系数,系数为0的项不能出现在结果中;指数为0的项应只输出系数;多项式的第一项系数符号为正时,不要输出“+”,其他项要输出“+”,“-”符号。

-3.0x^-1-6.0x-2.0x^2-9.0x^3-4.0x^4-6.0x^6二、概要设计(1):程序实现a. 功能:将要进行运算的二项式输入输出;b. 数据流入:要输入的二项式的系数与指数;c. 数据流出:合并同类项后的二项式;d. 程序流程图:二项式输入流程图;e. 测试要点:输入的二项式是否正确,若输入错误则重新输入。

(2):数据类型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}基本操作:sort(Polyn & h); //对多项式进行排序print(Polyn h); //输出多项式delZeroCoef(Polyn & h); //判断系数为零的情况merge(Polyn & h); //合并指数相同的项createList(); //创建多项式addPoly(Polyn h1,Polyn h2); //多项式相加subPoly(Polyn h1,Polyn h2); //多项式相减multPoly(Polyn h1,Polyn h2); //多项式相乘} ADT Polynomial三、详细设计(1):存储结构一元多项式的表示在计算机内可以用链表来表示,为了节省存储空间,只存储多项式中系数非零的项。

实验1-一元多项式实验报告

实验1-一元多项式实验报告

实验1-一元多项式实验报告数据结构实验报告实验名称:实验1——一元多项式Polynomial学生姓名:孙广东班级:2011211109班内序号:08学号:2011210251日期:2012年11月1日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即可,将每项得到的结果更新到结果多项式的链表中。

  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;
}。

相关文档
最新文档