数据结构课程设计___一元稀疏多项式计算器(报告+代码)__完整版.

合集下载

数据结构实习报告——一元稀疏多项式运算器的设计

数据结构实习报告——一元稀疏多项式运算器的设计

数据结构实习报告——一元稀疏多项式运算器的设计一、引言在计算机科学领域中,数据结构是研究数据组织、存储和管理的关键概念之一。

在本次实习中,我设计并实现了一个一元稀疏多项式运算器,旨在使用适当的数据结构和算法来高效地进行多项式的加法、减法和乘法运算。

本报告将详细介绍该运算器的设计思路、算法实现以及性能评估。

二、设计思路1. 多项式的表示在设计多项式运算器时,首先需要确定多项式的表示方法。

为了高效地处理稀疏多项式,我选择使用链表作为基本数据结构。

每个节点包含多项式的系数和指数,并通过指针连接在一起形成链表。

这种表示方法可以有效地处理稀疏多项式,减少了不必要的空间浪费。

2. 多项式的输入和输出为了方便用户输入和输出多项式,我设计了简单的交互界面。

用户可以通过命令行输入多项式的系数和指数,并选择进行的运算操作。

运算结果将直接在命令行中输出。

三、算法实现1. 多项式的加法多项式的加法是指将两个多项式相加得到一个新的多项式。

为了实现这个功能,我设计了一个算法如下:- 创建两个空的链表,分别表示两个多项式。

- 逐个读取用户输入的系数和指数,并将其插入到相应的链表中。

- 对两个链表进行遍历,根据指数的大小关系进行合并操作。

- 将合并后的结果链表输出。

2. 多项式的减法多项式的减法是指将一个多项式减去另一个多项式得到一个新的多项式。

为了实现这个功能,我设计了一个算法如下:- 创建两个空的链表,分别表示两个多项式。

- 逐个读取用户输入的系数和指数,并将其插入到相应的链表中。

- 对第二个链表中的每个节点的系数取相反数。

- 对两个链表进行遍历,根据指数的大小关系进行合并操作。

- 将合并后的结果链表输出。

3. 多项式的乘法多项式的乘法是指将两个多项式相乘得到一个新的多项式。

为了实现这个功能,我设计了一个算法如下:- 创建一个空的链表,表示乘法结果。

- 逐个读取用户输入的系数和指数,并将其插入到链表中。

- 对第一个链表中的每个节点,与第二个链表中的每个节点进行乘法运算,并将结果插入到结果链表中。

一个一元稀疏多项式简单计算器

一个一元稀疏多项式简单计算器

//设计一个一元稀疏多项式简单计算器#include<stdio.h>#include<stdlib.h>struct tagNode{int coef; //多项式的系数int exp; //多项式的指数struct tagNode *next;};typedef struct tagNode Node; //重新定义结点名称typedef struct tagNode* pNode; //重新定义指针名称void TrailInsertList(pNode,int,int); //在链表表尾部插入结点void AddPolynomial(pNode,pNode); //将两个多项式相加void PrintPolynomial(pNode); //打印多项式int main(void){pNode pa,pb;//定义两个头指针pNode pFree;//定义一个释放指针pa=pb=NULL;Node heada,headb; //定义两个头结点heada.coef=headb.coef=0; //头结点的coef作为结点的个数heada.exp=headb.exp=-1; //头结点的exp无意义故赋给其-1的值heada.next=headb.next=NULL;//让头指针指向头结点pa=&heada;pb=&headb;int coef=0; //系数int exp =0; //指数//第一个多项式的输入printf("请分别输入第一个多项式的系数和指数,并以输入系数为0作为结束标志!\n");do{printf("系数: ");scanf("%d",&coef);printf("指数: ");scanf("%d",&exp);printf("\n");if(coef!=0)TrailInsertList(pa,coef,exp);}while(coef!=0);//第二个多项式的输入printf("请分别输入第二个多项式的系数和指数,并以输入系数为0作为结束标志!\n");do{printf("系数: ");scanf("%d",&coef);printf("指数: ");scanf("%d",&exp);printf("\n");if(coef!=0)TrailInsertList(pb,coef,exp);}while(coef!=0);AddPolynomial(pa,pb); //将两个多项式相加PrintPolynomial(pa); //打印出相加后的多项式pFree=pa->next;free(pFree); //释放动态申请的内存空间return 0;}void TrailInsertList(pNode pHead,int coef,int exp){pNode trail=NULL; //定义一个指向链表尾部的指针pNode newnode=NULL; //定义一个指向新结点的指针//让trail指针指向尾部的结点trail=pHead;while(trail->next!=NULL){trail=trail->next;}newnode=(struct tagNode *)malloc(sizeof(Node)); //申请一块大小为Node的内存空间if(!newnode) //如果申请失败{printf("Allocte memory failure!\n");exit(1); //退出}//初始化申请的新结点newnode->coef=coef;newnode->exp=exp;newnode->next=NULL;trail->next=newnode; //插入新结点pHead->coef++; //头结点的计算器加一}void AddPolynomial(pNode p1,pNode p2){pNode cur1=p1->next; //链表1,结果存放的地方pNode cur2=p2->next; //链表2pNode pre1=p1;pNode temp=NULL; //临时指针while(cur1!=NULL && cur2!=NULL)//当前两个链表都不为空{if(cur1->exp<cur2->exp)//比较链表1与链表2当前指数大小{pre1=cur1;cur1=cur1->next; //cur1指向下一个结点}else if(cur1->exp==cur2->exp) //链表1与链表2指数相等时{cur1->coef+=cur2->coef;if(cur1->coef!=0){pre1=cur1;}else{pre1->next=cur1->next; //保持链表1的连续性free(cur1);}cur1=pre1->next; //cur1指向要比较的下一个结点//下面是删除指针cur2指向的结点,因为结果已经存放在链表1的结点中temp=cur2;cur2=cur2->next;free(temp);}else //链表1当前结点的指数比链表2的大时{p2->next=cur2->next;cur2->next=cur1;pre1->next=cur2;pre1=cur2;cur2=p2->next;}}if(cur2) //如果链表2比链表1长{pre1->next=cur2;}p2->next=NULL;}void PrintPolynomial(pNode pHead){pNode p; //定义头指针p=pHead;p=p->next;while(p){printf("%dX(%d)",p->coef,p->exp);if(p->next){printf(" + ");}p=p->next;}printf("\n");}。

数据结构课程设计___一元稀疏多项式计算器(报告 代码)__完整版

数据结构课程设计___一元稀疏多项式计算器(报告 代码)__完整版

数据结构课程设计一、课程题目一元稀疏多项式计算器二、需求分析1、一元稀疏多项式简单计算器的功能是:1.1 输入并建立多项式;1.2 输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,………cn,en,其中n是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序排列;1.3 求多项式a、b的导函数;1.4 计算多项式在x处的值;1.5多项式a和b相加,建立多项式a+b;1.6 多项式a和b相减,建立多项式a-b。

2、设计思路:2.1 定义线性表的动态分配顺序存储结构;2.2 建立多项式存储结构,定义指针*next2.3利用链表实现队列的构造。

每次输入一项的系数和指数,可以输出构造的一元多项式2.4演示程序以用户和计算机的对话方式执行,即在计算机终站上显示“提示信息”之后,由用户在键盘上输入演示程序中规定的运行命令;最后根据相应的输入数据(滤去输入中的非法字符)建立的多项式以及多项式相加的运行结果在屏幕上显示。

多项式显示的格式为:c1x^e1+c2x^e2+…+cnx^en3、设计思路分析要解决多项式相加,必须要有多项式,所以必须首先建立两个多项式,在这里采用链表的方式存储链表,所以我将结点结构体定义为运用尾插法建立两条单链表,以单链表polyn p和polyn h分别表示两个一元多项式a和b,a+b的求和运算等同于单链表的插入问题(将单链表polyn p中的结点插入到单链表polyn h中),因此“和多项式”中的结点无须另生成。

为了实现处理,设p、q分别指向单链表polya和polyb的当前项,比较p、q结点的指数项,由此得到下列运算规则:① 若p->expn<q->expn,则结点p所指的结点应是“和多项式”中的一项,令指针p后移。

② 若p->expn=q->expn,则将两个结点中的系数相加,当和不为0时修改结点p的系数。

③ 若p->expn>q->expn,则结点q所指的结点应是“和多项式”中的一项,将结点q插入在结点p之前,且令指针q在原来的链表上后移。

数据结构课程设计_一元稀疏多项式计算器

数据结构课程设计_一元稀疏多项式计算器

数据结构实验报告——一元稀疏多项式计算器安子烨PB12203079实验目的实现一元多项式的简单运算功能,掌握线性表的知识,提高编程能力。

功能清单1.一元多项式创建2.显示一元多项式3.复制一元多项式4.多项式加法5.多项式减法6.修改一元多项式7.删除一元多项式8.销毁记录实验设计该多项式计算器以菜单驱动的形式实现上述各运算功能。

最多可支持十条记录,分别用指针数组引导存储于十个不同的位置。

以下为程序的部分源代码。

#include<stdio.h>#include<math.h>#include<stdlib.h>typedef struct LinkList{double coef;int expn;LinkList *next;}LNode;void CreatPolyn(LinkList **h)//创建多项式{LinkList *q=NULL, *w=NULL, *p=NULL;double m=0; int n=0;(*h)=(LinkList *)malloc(sizeof(LinkList));(*h)->coef=0; (*h)->expn=0; (*h)->next=NULL;printf("请输入X的系数和指数,当系数为零时结束创建\n");scanf("%lf%d",&m,&n);while(m!=0){q=(LinkList *)malloc(sizeof(LinkList));q->coef=m; q->expn=n; q->next=NULL;if((*h)->next==NULL){if(q->expn==(*h)->expn) (*h)->coef+=q->coef;else if((*h)->expn>q->expn) {q->next=(*h); *h=q; } else (*h)->next=q;}else{for(w=(*h);w->next!=NULL;w=w->next){if(q->expn==w->expn){w->coef+=q->coef;break;}else if((w->expn>q->expn)&&(w==*h)){q->next=(*h);(*h)=q;break;}else if((w->expn<q->expn)&&(w->next->expn>q->expn)){q->next=w->next;w->next=q;break;}}if(w->next==NULL){if(w->expn==q->expn) w->coef+=q->coef;else if(w->expn<q->expn) w->next=q;}}printf("请输入X的系数和指数,当系数为零时结束创建\n");scanf("%lf%d",&m,&n);}}void PrintPolyn(LinkList *p, int i)//打印多项式{printf("第%d个多项式是:",i);while(p!=NULL){if((p->coef)>0) printf("+%lf*X^%d",p->coef,p->expn);else if((p->coef)<0) printf("%lf*X^%d",p->coef,p->expn); p=p->next;}printf("\n");}void CopyPolyn(LinkList **M, LinkList **N)//多项式复制{LinkList *p=NULL, *q=NULL, *w=NULL;(*N)=(LinkList *)malloc(sizeof(LinkList));(*N)->coef=(*M)->coef; (*N)->expn=(*M)->expn; (*N)->next=NULL;for(w=(*N),p=(*M)->next;p!=NULL;p=p->next){q=(LinkList *)malloc(sizeof(LinkList));q->coef=p->coef; q->expn=p->expn; q->next=p->next;w->next=q; w=w->next;}}void AddPolyn(LinkList *M, LinkList *N, LinkList **X)//多项式加法{LinkList *p=NULL, *q=NULL, *w=NULL, *z=NULL;(*X)=(LinkList *)malloc(sizeof(LinkList));(*X)->coef=0; (*X)->expn=0; (*X)->next=NULL;for(p=M,q=N,w=(*X);(p!=NULL)&&(q!=NULL);){z=(LinkList *)malloc(sizeof(LinkList));if(p->expn<q->expn){z->coef=p->coef; z->expn=p->expn; z->next=NULL;p=p->next; w->next=z; w=w->next;}else if(p->expn>q->expn){z->coef=q->coef; z->expn=q->expn; z->next=NULL;q=q->next; w->next=z; w=w->next;}else if(p->expn==q->expn){z->coef=p->coef+q->coef; z->expn=p->expn; z->next=NULL;p=p->next; q=q->next; w->next=z; w=w->next;}}if(p==NULL){for(;q!=NULL;){z=(LinkList *)malloc(sizeof(LinkList));z->coef=q->coef; z->expn=q->expn; z->next=NULL;q=q->next; w->next=z; w=w->next;}}else if(q==NULL){for(;p!=NULL;){z=(LinkList *)malloc(sizeof(LinkList));z->coef=p->coef; z->expn=p->expn; z->next=NULL;p=p->next; w->next=z; w=w->next;}}for(w=(*X);w!=NULL;w=w->next){printf("%lf %d\n",w->coef,w->expn);}}void SubtractPolyn(LinkList *M, LinkList *N, LinkList **X)//多项式减法{LinkList *p=NULL, *q=NULL, *w=NULL, *z=NULL;(*X)=(LinkList *)malloc(sizeof(LinkList));(*X)->coef=0; (*X)->expn=0; (*X)->next=NULL;for(p=M,q=N,w=(*X);(p!=NULL)&&(q!=NULL);){z=(LinkList *)malloc(sizeof(LinkList));if(p->expn<q->expn){z->coef=p->coef; z->expn=p->expn; z->next=NULL;p=p->next; w->next=z; w=w->next;}else if(p->expn>q->expn){z->coef=-q->coef; z->expn=q->expn; z->next=NULL;q=q->next; w->next=z; w=w->next;}else if(p->expn==q->expn){z->coef=p->coef-q->coef; z->expn=p->expn; z->next=NULL;p=p->next; q=q->next; w->next=z; w=w->next;}}if(p==NULL){for(;q!=NULL;){z=(LinkList *)malloc(sizeof(LinkList));z->coef=-q->coef; z->expn=q->expn; z->next=NULL;q=q->next; w->next=z; w=w->next;}}else if(q==NULL){for(;p!=NULL;){z=(LinkList *)malloc(sizeof(LinkList));z->coef=p->coef; z->expn=p->expn; z->next=NULL;p=p->next; w->next=z; w=w->next;}}/*for(w=(*X);w!=NULL;w=w->next){printf("%lf %d\n",w->coef,w->expn);}*/}void ValuePolyn(LinkList *h, double x)//多项式求值{double sum=0, a=0;while(h!=NULL){a=pow(x,h->expn);sum=sum+(h->coef)*a;h=h->next;}printf("所求多项式的值为%lf\n",sum);}void DeletePolyn(LinkList **h){LinkList *p=(*h)->next; (*h)=NULL;while(p!=NULL){free(*h);(*h)=p;p=p->next;}}void RevisePolyn(LinkList **h, int i){int n=0;int choose=0;double m=0;LinkList *q=NULL, *w=NULL;PrintPolyn((*h),i);printf("请输入你想执行的操作代号(添加:1;修改:2;删除:3)\n");scanf("%d",&choose);switch(choose){case 1:{printf("输入你想要添加项的系数和次数\n");scanf("%lf%d",&m,&n);q=(LinkList *)malloc(sizeof(LinkList));q->coef=m; q->expn=n; q->next=NULL;for(w=(*h);w->next!=NULL;w=w->next){if((w->expn>q->expn)&&(w==*h)){q->next=(*h);(*h)=q;break;}else if((w->expn<q->expn)&&(w->next->expn>q->expn)) {q->next=w->next;w->next=q;break;}}if(w->expn<n) w->next=q;break;}case 2:{printf("输入你想要修改项的系数和次数\n");scanf("%lf%d",&m,&n);for(w=(*h);w!=NULL;w=w->next){if(w->expn==n) w->coef=m;}printf("未找到该项。

c一元稀疏多项式计算器-课程设计实验报告

c一元稀疏多项式计算器-课程设计实验报告

2016-2017学年第二学期学号1608220203 《网络工程》课程设计报告题目:一元稀疏多项式计算器专业:网络工程班级:网络工程(3)班姓名:代应豪指导教师:代美丽成绩:[键入文字] [键入文字] [键入文字]一、问题描述 (3)二、需求分析 (3)三、概要设计 (4)四、详细设计 (5)五、源代码 (6)六、程序测试 (19)七、使用说明 (25)八、课设总结 (26)一、问题描述1.1基本要求(1)输入并建立多项式;(2)输出多项式,输出形式为整数序列:n,c1,e1, c2,e2,,,,,,, cn,en,其中n 是多项式的项数,ci,ei,分别是第i项的系数和指数,序列按指数降序排序;(3)多项式a和b相加,建立多项式a+b;(4)多项式a和b相减,建立多项式a-b;(5)计算多项式在x处的值。

(6)计算器的仿真界面。

1.2设计目的数据结构是实践性很强的课程。

课程设计是加强学生实践能力的一个强有力手段。

课程设计要求学生在完成程序设计的同时能够写出比较规范的设计报告。

严格实施课程设计这一环节,对于学生基本程序设计素养的培养和软件工作者工作作风的训练,将起到显著的促进作用二、需求分析2.1设计开发环境:软件方面:系统windows 7编程软件:VC++ 6.02.2思路分析:①一般情况下的一元n次多项式可写成pn(x)=p1xe1+p2xe2+……+pmxem其中,p1是指数为ei的项的非零系数,且满足0≦e1<e2<……<em=n ,若用一个长度为m且每个元素有两个数据项(系数项和指数项)的线性表((p1,e1),(p2,e2),……,(pm,em))便可惟一确定多项式pn(x)。

②用两个带表头结点的单链表分别存储两个多项式③根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相同的项,对应系数相加,若其和不为零,则构成“和多项式”中的一项;④只需要将第二个多项式的系数改为其相反数,然后根据一元多项式相加的运算规则便可以得到其相应的“差多项式”三、概要设计图3-1功能模块图为实现上述程序功能,用带表头结点的单链表存储多项式。

数据结构实习报告——一元稀疏多项式运算器的设计

数据结构实习报告——一元稀疏多项式运算器的设计

数据结构实习报告班级 XXXXXX学生姓名 XXXXXX学号 *******XXXX指导教师 XXXXXX日期 2012年11月10日报告简介:整篇实习报告主要分为三部分:实习一,实习二以及实习困惑。

其中每个实习报告涉及6个部分:需求分析,设计,调试分析,用户手册,测试结果,源程序清单。

具体报告内容如下:实习一:一元稀疏多项式运算器的设计1、需求分析【问题描述】设计一个一元稀疏多项式简单计算器。

【基本要求】(1)输入并建立两个多项式;(2)多项式a与b相加,建立和多项式c;(3)多项式a与b相减,建立和多项式d;(4)输出多项式a,b,c,d。

输出格式:比如多项式a为:A(x)=c1xe1+ c2xe2+…+ cmxem,其中,ci和ei分别为第i项的系数和指数,且各项按指数的升幂排列,即0≤e1<e2<…<em。

2、设计(1)设计思想存储结构:以带头结点的单链表存储多项式。

算法主要思想:●首先定义单链表中每个结点的结构体类型,设计能够生成多项式链表的函数,这个函数的功能是可以根据给定的多项式来创建存储它的单链表。

●然后需要设计两个多项式相加的函数与两个多项式相减的函数。

●要检验多项式的运算结果以及初始的多项式链表正确与否,需要将其打印输出,故还需要设计打印输出函数。

●主函数的设计:依次调用多项式链表生成的函数、多项式相加减的函数,最后将结果打印输出。

(2)概要设计整个算法需要设计五个函数,分别是:多项式链表生成的函数、两个多项式相加的函数、两个多项式相减的函数、打印输出的函数以及主函数。

在设计各个函数之前,要定义单链表结点的结构体类型。

每个结点应该包括指数code、系数exp和指向下一个结点的指针next。

多项式链表生成的函数:函数的返回值应该为定义的结构体类型,不需要设置参数。

函数内部,需要有多项式指数和系数的输入,直至输入的系数为零时结束,将每一对输入的指数和系数保存到新结点中,并将结点插入到链表中。

(完整word版)一元稀疏多项式计算器实现(完整实现版,详细源码)

(完整word版)一元稀疏多项式计算器实现(完整实现版,详细源码)

1。

5一元稀疏多项式计算器实习报告一、需求分析1.输入并建立多项式;2.输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,……,c n,e n,其中n是多项式的项数,c i 和e i分别是第i项的系数和指数,序列按指数降序排列;3.多项式a和b相加,建立多项式a+b;4.多项式a和b相减,建立多项式a-b;5.多项式a和b相乘,建立多项式a×b;6.计算多项式在x处的值;7.求多项式P的导函数P’;8。

多项式的输出形式为类数学表达式;9.做出计算器的仿真界面;10。

测试数据:(1)(2x+5x^8—3.1x^11)+(7—5x^8+11x^9)=(—3。

1x^11+11x^9+2x+7)(2)(6x^—3-x+4。

4x^2—1。

2x^9+1.2x^9)-(-6x^—3+5.4x^2—x^2+7。

8x^15 )=(-7。

8x^15—1.2x^9+12x^-3—x);(3)(1+x+x^2+x^3+x^4+x^5)+(-x^3—x^4)=(1+x+x^2+x^5);(4)(x+x^3)+(-x—x^3)=0(5)(x+x^100)+(x^100+x^200)=(x+2x^100+x^200)(6)(x+x^2+x^3)+0=x+x^2+x^3(7)互换上述测试数据中的前后两个多项式二、概要设计1.链表的抽象数据类型定义为:ADT LinkList{数据对象:D={ ai | ai∈ElemSet, i=1,2,...,n,n≥0 }数据关系:R1={〈ai-1,ai〉|ai—1,ai∈D, i=2,.。

,n }基本操作:InitList(&L)操作结果:构造一个空的线性表L.DestroyList(&L)初始条件:线性表L已存在.操作结果:销毁线性表L。

ClearList(*L)初始条件:线性表L已存在。

操作结果:将线性表L重置为空表。

LocateElem(L,e, cmp())初始条件:线性表L已存在,compare()是元素判定函数。

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

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

元稀疏多项式计算器实验报告c编写,附源代码(1)实验报告:元稀疏多项式计算器引言:本次实验是运用C语言编写一个元稀疏多项式计算器,该计算器可以实现多项式的加法、减法、乘法、求导、积分、求值等操作。

本次实验旨在通过编写实践,加深对多项式计算的理解和程序设计能力。

一、设计思路及实现方法1.1 多项式的表示方式多项式可以用数组来表示,数组的下标表示多项式的幂次,数组的内容表示该幂次项的系数。

例如多项式:2x^4 + 3x^2 + 5可以表示为数组:{0,0,3,0,2,5}。

1.2 多项式的操作函数及实现方法本次实验实现了以下多项式操作函数:1)add(多项式加法):将两个多项式相加并返回结果多项式。

2)subtract(多项式减法):将两个多项式相减并返回结果多项式。

3)multiply(多项式乘法):将两个多项式相乘并返回结果多项式。

4)differential(求导):求一个多项式的导数并返回结果多项式。

5)integral(积分):对一个多项式进行积分并返回结果多项式。

6)evaluate(求值):给定一个值,计算多项式在该值处的值并返回结果。

以上操作函数的实现方法都是通过循环遍历数组,并运用相应的多项式计算公式来计算。

二、程序设计及实验结果2.1 程序设计本次实验采用C语言编写完成,主函数的框架如下:int main(int argc, char const *argv[]) {// 输入多项式各项系数和幂次// 调用各个多项式计算函数// 输出计算结果return 0;}2.2 实验结果本次实验的实验结果如下:1)将多项式2x^3 + 3x^2 + 5x + 2与多项式3x^3 - 2x^2 + 4相加:输入:2 3 5 2 3 -2 0 4输出:5x^3 + x^2 + 5x + 62)将多项式2x^3 + 3x^2 + 5x + 2与多项式3x^3 - 2x^2 + 4相减:输入:2 3 5 2 3 -2 0 4输出:-1x^3 + 5x^2 + 5x - 23)将多项式2x^3 + 3x^2 + 5x + 2与多项式3x^3 - 2x^2 + 4相乘:输入:2 3 5 2 3 -2 0 4输出:6x^6 + 5x^5 + 4x^4 + 4x^3 + 26x^2 + 14x + 84)求多项式2x^3 + 3x^2 + 5x + 2的导数:输入:2 3 5 2输出:6x^2 + 6x + 55)对多项式2x^3 + 3x^2 + 5x + 2进行积分:输入:2 3 5 2输出:0.5x^4 + 1x^3 + 2.5x^2 + 2x + 06)计算多项式2x^3 + 3x^2 + 5x + 2在x=3处的值:输入:2 3 5 2 3输出:59以上实验结果均能正确输出。

一元稀疏多项式计算器实验报告(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表示指向下一个多项式结点的指针)。

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

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

(2023)一元稀疏多项式计算器实验报告c编写,附源代码(一)实验报告:(2023)一元稀疏多项式计算器实验目的本实验旨在编写一款一元稀疏多项式计算器,实现对两个多项式的加、减、乘、求导、求值等操作。

实验环境•操作系统:Windows 10•开发工具:Visual Studio Code•编程语言:C实验过程1. 首先定义多项式的结构体typedef struct PolyTerm {int coef;// 系数unsigned int power;// 指数struct PolyTerm* next;// 下一项}PolyTerm;typedef struct Poly {int degree;// 多项式最高次项PolyTerm* head;// 首项指针}Poly;2. 实现多项式的输入与输出void inputPoly(Poly* poly);// 输入多项式void outputPoly(Poly* poly);// 输出多项式3. 实现多项式的加、减、乘操作Poly* addPoly(Poly* p1, Poly* p2);// 多项式加法Poly* subPoly(Poly* p1, Poly* p2);// 多项式减法Poly* multPoly(Poly* p1, Poly* p2);// 多项式乘法4. 实现多项式求导void derivative(Poly* poly);// 多项式求导5. 实现多项式求值int evaluate(Poly* poly,int x);// 多项式求值6. 主函数的实现主函数通过简单的菜单方式,实现用户输入选项,选择需要进行的操作。

实验结果通过对多项式加、减、乘、求导、求值等操作的实现,成功完成了一元稀疏多项式计算器的编写,实现了对多项式运算的基本掌握。

实验总结在本次实验中,我们通过C语言实现了一元稀疏多项式计算器,并体验了多项式运算的具体操作。

一元稀疏多项式简单计算器

一元稀疏多项式简单计算器

一、课程设计概述:本次数据结构课程设计共完成五个题:一元稀疏多项式计算器、迷宫问题、成绩分析问题、图的基本操作与实现以及背包问题的求解使用语言:C编译环境:TC3.0二、课程设计题目一[实验内容]一元稀疏多项式计算器[问题描述]设计一个一元稀疏多项式简单计算器。

[基本要求]一元稀疏多项式简单计算器的基本功能是:(1)输入并建立多项式;(2)输出多项式,输出形式为整数序列:n,c1,e1, c2,e2,,,,,,, c n,e n,其中n是多项式的项数,c i,e i,分别是第i项的系数和指数,序列按指数降序排序;(3)多项式a和b相加,建立多项式a+b;(4)多项式a和b相减,建立多项式a-b;(5)计算多项式在x处的值。

(6)计算器的仿真界面。

(选做)[概要设计]-=ADT=-Test1:主类,程序的启动Item :项,表示多项式中的某一项Ploynomial:多项式类[存储结构]Item属性:private double c;//系数private int e;//指数Item方法:public void setC(double c){//设置系数}public void setE(int e){ //设置指数}public double getC(){//获取系数}public int getE(){//获取指数}public double resultItem(double x){//在x处Item的值}private double fac(double x,int e){//求x的e次方,当e为整数时}Polynomial属性:private LinList list;//单链表Polynomial方法:public Polynomial(){}public Polynomial(Item [] item)throws Exception{ //构造函数}private void initItem(Item [] item){//初始化Item数组,使其是按降序排序}public int getItemNum(){//获取项数}public void print()throws Exception{//打印多项式不空行}public void println()throws Exception{//打印多项式空行}public LinList getLinList(){//获取单链表}public void printPolynomial()throws Exception{//只打印项数、系数和指数}public Polynomial add(Polynomial other)throws Exception{//多项式相加}}public Polynomial subtraction(Polynomial other)throws Exception{//多项式相减}public double result(double x)throws Exception{}[详细设计]Item类:public class Item {private double c;//系数private int e;//指数public Item(){}public Item(double c,int e){this.c=c;this.e=e;}public void setC(double c){this.c=c;}public void setE(int e){this.e=e;}public double getC(){return c;}public int getE(){return e;}public double resultItem(double x){return getC()*fac(x,getE());}private double fac(double x,int e){//求x的e次方,当e为整数时if(e==0) return 1;return x*fac(x,e-1);}}Polynomial类:import java.util.*;public class Polynomial{//多项式类private LinList list;//单链表public Polynomial(){list=new LinList(0,null);}public Polynomial(Item [] item)throws Exception{ //构造函数int n=item.length;list=new LinList(n,null);if(n==0){return;}initItem(item);try{for(int i=0;i<n;i++)list.insert(i,item[i]);}catch(Exception e){}}private void initItem(Item [] item){//初始化Item数组,使其是按降序排序int n=item.length;int max;for(int i=0;i<n;i++){max=i;for(int j=i+1;j<n;j++)if(item[j].getE()>item[max].getE()) max=j;if(max!=i){Item temp=item[i];item[i]=item[max];item[max]=temp;}}}public int getItemNum(){//获取项数Object temp=list.head.getElement();int n=-1;if(temp instanceof Integer){Integer i=(Integer)temp;n=i.intValue();}return n;}public void print()throws Exception{//打印多项式不空行int n=getItemNum();// System.out.println(n);if(n==-1) return ;if(n==0){System.out.print("0");return;}boolean flag=true;//是不是输出第一项的标志for(int i=0;i<n;i++){Item temp=(Item)list.getData(i);double c=temp.getC();if(c==0) continue;//系数为0时不输出if(flag && temp.getE()!=0 ){System.out.print(c+"x^"+temp.getE());}else if(flag && temp.getE()==0)System.out.print(temp.getC());else {if(c>0)System.out.print("+"+c+"x^"+temp.getE());else if(c<0)System.out.print(c+"x^"+temp.getE());}flag=false;}}public void println()throws Exception{//打印多项式空行print();System.out.println();}public LinList getLinList(){//获取单链表return list;}public void printPolynomial()throws Exception{//只打印项数、系数和指数int n=getItemNum();if(n==0) return ;System.out.print(n+",");for(int i=0;i<n;i++){Item item=(Item)this.getLinList().getData(i);if(i!=n-1){System.out.print("c"+i+"="+item.getC()+", "+"e"+i+"="+item.getE()+", ");}else{System.out.print("c"+i+"="+item.getC()+", "+"e"+i+"="+item.getE());}}System.out.println();}public Polynomial add(Polynomial other)throws Exception{//多项式相加LinList otherList=other.getLinList();int n1=getItemNum();//该多项式的项数int n2=other.getItemNum();//另一个多项式的项数if(n2==0) return this;if(n1==0) return other;Polynomial temp=new Polynomial();int i=0,j=0;while (+i<n1 && j<n2){Item item=new Item();Item item1=(Item)list.getData(i);Item item2=(Item)otherList.getData(j);double c1=item1.getC();//获得系数double c2=item2.getC();int e1=item1.getE();//获得指数int e2=item2.getE();if(e1==e2){//相等时double c=c1+c2;item.setC(c);item.setE(e1);i++;j++;}else if(e1<e2){//不相等时指数的大的增加item=item2;j++;}else {item=item1;i++;}try{if(item.getC()==0)//当得到项的系数为0时就没有必要加入continue;temp.getLinList().insert(temp.getLinList().size(),item);}catch(Exception e){}}//将没有参加比较的项加进去,注意比较之后有且只有一个有多余的项while(i<n1){Item item1=(Item)list.getData(i);try{temp.getLinList().insert(temp.getLinList().size(),item1);}catch(Exception e){}i++;}while(j<n2){Item item1=(Item)otherList.getData(j);try{temp.getLinList().insert(temp.getLinList().size(),item1);}catch(Exception e){}j++;}temp.getLinList().head.setElement(temp.getLinList().size());//设置项数return temp;}public Polynomial subtraction(Polynomial other)throws Exception{//多项式相减int n=other.getItemNum();if(n==0) return this;Polynomial temp=new Polynomial();LinList l=temp.getLinList();for(int i=0;i<n;i++){Item item =(Item)other.getLinList().getData(i);double c=-1*item.getC();//取反l.insert(i,new Item(c,item.getE()));}l.head.setElement(n);//设置项数return add(temp);}public double result(double x)throws Exception{double sum=0;int n=getItemNum();//该多项式的项数if(n==0) return 0;for(int i=0;i<n;i++){Item item=(Item)list.getData(i);sum+=item.resultItem(x);}return sum;}}T est1类:import java.io.*;import java.util.Scanner;public class T est1 {Scanner scanner =new Scanner(System.in);public static void main(String[] args)throws Exception{ T est1 test1=new T est1();Scanner scanner1 =new Scanner(System.in);while(true){System.out.println("请输入你要操作的系号:\n"+"1)输出多项式\n"+"2)多项式相加\n"+"3)多项式相减\n"+"4)计算多项式在x处的值\n"+"5)退出");String s=scanner1.next();int t=-1;try{t=Integer.parseInt(s);}catch(Exception e){}switch(t){case 1:test1.printPolynomial();break;case 2:test1.add();break;case 3:test1.subtraction();break;case 4:test1.resultOfPolynomia();break;case 5:System.exit(0);break;default:System.out.println("你输入的操作有误,请重试\n");continue;}}}private void printPolynomial()throws Exception{//选择1时System.out.println("请输入要输出的多项式的信息:");Item[] item=creatItemShuZu();Polynomial p=new Polynomial(item);p.printPolynomial();}private void add()throws Exception{//选择2时System.out.println("请输入第一个多项式的信息:");Item[] item1=creatItemShuZu();Polynomial p1=new Polynomial(item1);System.out.println("请输入第二个多项式的信息:");Item[] item2=creatItemShuZu();Polynomial p2=new Polynomial(item2);Polynomial p=p1.add(p2);System.out.print("(");p1.print();System.out.print(")+(");p2.print();System.out.print(")=");p.print();System.out.println();}private void subtraction()throws Exception{//选择3时System.out.println("请输入第一个多项式的信息:");Item[] item1=creatItemShuZu();Polynomial p1=new Polynomial(item1);System.out.println("请输入第二个多项式的信息:");Item[] item2=creatItemShuZu();Polynomial p2=new Polynomial(item2);Polynomial p=p1.subtraction(p2);System.out.print("(");p1.print();System.out.print(")-(");p2.print();System.out.print(")=");p.print();System.out.println();}private void resultOfPolynomia()throws Exception{//选择4时System.out.println("请输入要输出的多项式的信息:");Item[] item=creatItemShuZu();Polynomial p=new Polynomial(item);System.out.println("请输入x=");double x=scanner.nextDouble();System.out.println(p.result(x));}private Item[] creatItemShuZu()throws Exception{//构造多项式数组System.out.print("项数n=");int n=scanner.nextInt();double []c=new double[n];int [] e=new int[n];Item[] item=new Item[n];System.out.print("请输入各项的系数:");for(int i=0;i<n;i++)c[i]=scanner.nextDouble();System.out.print("请输入各项的指数:");for(int i=0;i<n;i++)e[i]=scanner.nextInt();for(int i=0;i<n;i++){item[i]=new Item(c[i],e[i]);}return item;}}[调试分析]本程序主要的操作对象是记录数组,使用的存储结构是结构体数组。

一元稀疏多项式计算器源代码

一元稀疏多项式计算器源代码

一元稀疏多项式计算器源代码#include #include typedef struct node {float coef; int exp;struct node *next; }Lnode, *polynmial;void create(polynmial &L); //输入并建立多项式L void display(polynmial L); //显示,输出多项式L void sort(polynmial &L); //多项式L按指数排序 voidreverse(polynmial &L); //逆置 void select(); //用户选择加减操作void add(polynmial La, polynmial Lb, polynmial &Lc); //多项式voidsubtract(polynmial La, polynmial Lb, polynmial &Ld); //多项式void create(polynmial &L) //输入并建立多项式L {int i, n;static struct node *p; scanf(\L = (struct node *)malloc (sizeof(struct node)); L->next = NULL; for(i = 0;i < n; i++) {p = (struct node *)malloc(sizeof(struct node)); scanf(\ p->next = L->next; L->next = p; } }void display(polynmial L)//显示,输出多项式L {struct node *p, *q; int flag = 0; int k = 0; q = L->next; while(q) {if(q->coef != 0) k++;q = q->next;La,Lb相加La减去LbLd ,结果给}printf(\p = L->next; if(p->coef != 0) {printf(\ flag++; }for(p = p->next; p; p = p->next) {if(p->coef != 0) {printf(\ flag++; } }if(flag == 0)printf(\elseprintf(\}void sort(polynmial &L)//多项式L按指数排序 {polynmial p, q, r, u; p = L->next;L->next = NULL; while(p != NULL) {r = L;q = L->next;while((q != NULL) && (q->exp <= p->exp)) {r = q;q = q->next; }u = p->next; r->next = p; p->next = q; p = u; } }void reverse(polynmial &L)//逆置{polynmial H;static struct node *p, *q, *s;H = (struct node*)malloc(sizeof(struct node)); H->next = NULL;p = (struct node*)malloc(sizeof(struct node)); s = L->next;p->coef = s->coef; p->exp = s->exp; p->next = s->next; while(s) {p->coef = s->coef; p->exp = s->exp; p->next = s->next; q = H->next; H->next = p; p->next = q;p = (struct node*)malloc(sizeof(struct node)); s = s->next; }p = H->next; q = L->next; while(p) {q->coef = p->coef; q->exp = p->exp; q = q->next; p = p->next; } }void select() //用户选择加减操作 {printf(\请选择加减操作\\n\printf(\两个一元多项式相加\\n\printf(\两个一元多项式相减\\n\}void add(polynmial La, polynmial Lb, polynmial &Lc)//{struct node *pa, *pb; static struct node *pc;Lc = (struct node*)malloc(sizeof(struct node));La,Lb多项式相加pa = La->next; pb = Lb->next; Lc->next = NULL; while(pa && pb) {pc = (struct node*)malloc(sizeof(struct node)); if(pa->exp < pb->exp) {pc->next = Lc->next; Lc->next = pc;pc->coef = pa->coef; pc->exp = pa->exp; pa = pa->next; }elseif(pa->exp == pb->exp) {pc->next = Lc->next; Lc->next = pc; pc->exp = pa->exp;pc->coef = pa->coef + pb->coef; pa = pa->next; pb = pb->next; } else {pc->next = Lc->next; Lc->next = pc;pc->coef = pb->coef; pc->exp = pb->exp; pb = pb->next; } }while(pa) {pc = (struct node*)malloc(sizeof(struct node)); pc->next = Lc->next; Lc->next = pc;pc->coef = pa->coef; pc->exp = pa->exp; pa = pa->next; }while(pb) {pc = (struct node*)malloc(sizeof(struct node)); pc->next = Lc->next; Lc->next = pc;pc->coef = pb->coef; pc->exp = pb->exp; pb = pb->next; } }void subtract(polynmial La, polynmial Lb, polynmial &Ld)//多项式{struct node *pa, *pb; static struct node *pd;Ld = (struct node*)malloc(sizeof(struct node)); pa = La->next; pb = Lb->next; Ld->next = NULL; while(pa && pb) {pd = (struct node*)malloc(sizeof(struct node)); if(pa->exp < pb->exp) {pd->next = Ld->next; Ld->next = pd;pd->coef = pa->coef; pd->exp = pa->exp; pa = pa->next; }elseif(pa->exp == pb->exp) {pd->next = Ld->next; Ld->next = pd; pd->exp = pa->exp;pd->coef = pa->coef - pb->coef; pa = pa->next; pb = pb->next; } else {pd->next = Ld->next; Ld->next = pd;pd->coef = pb->coef; pd->exp = pb->exp;La减去Lb,结果给Ld感谢您的阅读,祝您生活愉快。

(完整word版)一元稀疏多项式计算器(数据结构)

(完整word版)一元稀疏多项式计算器(数据结构)

【问题描述】设计一个一元稀疏多项式简单计算器【基本要求】一元多项式简单计算器的基本功能是:1,输入并建立多项式;2,输出多项式,输出形式为整数序列:n,c1,e1,c2,c2,...,cn,en,其中n是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序排列;3,多项式a和b相加,建立多项式a+b;4,多项式a和b相减,建立多项式a-b.【测试数据】1,(2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=(-3.1x^11+11x^9+2x+7)【实现提示】用带表头结点的单链表存储多项式。

#include <stdio.h>#include <malloc.h>typedef struct node{float coef;int expn;struct node *next;}Lnode, *polynmial;void create(polynmial &L); //输入并建立多项式Lvoid display(polynmial L); //显示,输出多项式Lvoid sort(polynmial &L); //多项式L按指数排序void reverse(polynmial &L); //逆置void select(); //用户选择加减操作void add(polynmial La, polynmial Lb, polynmial &Lc); //多项式La,Lb相加void subtract(polynmial La, polynmial Lb, polynmial &Ld); //多项式La减去Lb,结果给Ldvoid create(polynmial &L) //输入并建立多项式L{int i, n;static struct node *p;scanf("%d", &n);L = (struct node *)malloc (sizeof(struct node));L->next = NULL;for(i = 0; i < n; i++){p = (struct node *)malloc(sizeof(struct node));scanf("%f %d", &p->coef, &p->expn);p->next = L->next;L->next = p;}}void display(polynmial L)//显示,输出多项式L {struct node *p, *q;int flag = 0;int k = 0;q = L->next;while(q){if(q->coef != 0)k++;q = q->next;}printf("%d, ", k);p = L->next;if(p->coef != 0){printf("%.1f,%d, ", p->coef, p->expn);flag++;}for(p = p->next; p; p = p->next){if(p->coef != 0){printf("%.1f,%d, ", p->coef, p->expn);flag++;}}if(flag == 0)printf("%d\n", flag);elseprintf("\n");}void sort(polynmial &L)//多项式L按指数排序{polynmial p, q, r, u;p = L->next;L->next = NULL;while(p != NULL){r = L;q = L->next;while((q != NULL) && (q->expn <= p->expn)) {r = q;q = q->next;}u = p->next;r->next = p;p->next = q;p = u;}}void reverse(polynmial &L)//逆置{polynmial H;static struct node *p, *q, *s;H = (struct node*)malloc(sizeof(struct node)); H->next = NULL;p = (struct node*)malloc(sizeof(struct node)); s = L->next;p->coef = s->coef;p->expn = s->expn;p->next = s->next;while(s){p->coef = s->coef;p->expn = s->expn;p->next = s->next;q = H->next;H->next = p;p->next = q;p = (struct node*)malloc(sizeof(struct node)); s = s->next;}p = H->next;q = L->next;while(p){q->coef = p->coef;q->expn = p->expn;q = q->next;p = p->next;}}void select() //用户选择加减操作{printf("请选择加减操作\n");printf("1.两个一元多项式相加\n");printf("2.两个一元多项式相减\n");}void add(polynmial La, polynmial Lb, polynmial &Lc)//多项式La,Lb相加{struct node *pa, *pb;static struct node *pc;Lc = (struct node*)malloc(sizeof(struct node));pa = La->next;pb = Lb->next;Lc->next = NULL;while(pa && pb){pc = (struct node*)malloc(sizeof(struct node));if(pa->expn < pb->expn){pc->next = Lc->next;Lc->next = pc;pc->coef = pa->coef;pc->expn = pa->expn;pa = pa->next;}elseif(pa->expn == pb->expn){pc->next = Lc->next;Lc->next = pc;pc->expn = pa->expn;pc->coef = pa->coef + pb->coef;pa = pa->next;pb = pb->next;}else{pc->next = Lc->next;Lc->next = pc;pc->coef = pb->coef;pc->expn = pb->expn;pb = pb->next;}}while(pa){pc = (struct node*)malloc(sizeof(struct node));pc->next = Lc->next;Lc->next = pc;pc->coef = pa->coef;pc->expn = pa->expn;pa = pa->next;}while(pb){pc = (struct node*)malloc(sizeof(struct node));pc->next = Lc->next;Lc->next = pc;pc->coef = pb->coef;pc->expn = pb->expn;pb = pb->next;}}void subtract(polynmial La, polynmial Lb, polynmial &Ld)//多项式La减去Lb,结果给Ld{struct node *pa, *pb;static struct node *pd;Ld = (struct node*)malloc(sizeof(struct node));pa = La->next;pb = Lb->next;Ld->next = NULL;while(pa && pb){pd = (struct node*)malloc(sizeof(struct node));if(pa->expn < pb->expn){pd->next = Ld->next;Ld->next = pd;pd->coef = pa->coef;pd->expn = pa->expn;pa = pa->next;}elseif(pa->expn == pb->expn){pd->next = Ld->next;Ld->next = pd;pd->expn = pa->expn;pd->coef = pa->coef - pb->coef;pa = pa->next;pb = pb->next;}else{pd->next = Ld->next;Ld->next = pd;pd->coef = pb->coef;pd->expn = pb->expn;pb = pb->next;}}while(pa){pd = (struct node*)malloc(sizeof(struct node)); pd->next = Ld->next;Ld->next = pd;pd->coef = pa->coef;pd->expn = pa->expn;pa = pa->next;}while(pb){pd = (struct node*)malloc(sizeof(struct node)); pd->next = Ld->next;Ld->next = pd;pd->coef = -pb->coef;pd->expn = pb->expn;pb = pb->next;}}int main(){int sign;polynmial La, Lb, Lc, Ld;printf("请输入第一个多项式:\n");create(La);sort(La);printf("请输入第二个多项式:\n");create(Lb);sort(Lb);select();scanf("%d", &sign);switch(sign){case 1:printf("多项式之和为:\n"); add(La, Lb, Lc);sort(Lc);reverse(Lc);display(Lc);break;default:printf("多项式之差为:\n"); subtract(La, Lb, Ld); sort(Ld);reverse(Ld);display(Ld);break;}return 0;}。

一元稀疏多项式计算器

一元稀疏多项式计算器

数据结构课程设计报告课程名称______数据结构_____ 题目名称一元稀疏多项式计算器学生学院_ 计算机学院2012年 07月 01 日一元稀疏多项式计算器1.用了VC6.0,MFC对话框界面编程,下面的LJQList.h和LJQList.cpp是我自己编写的数据结构以及功能操作函数2.源代码LJQList.h的头文件代码:#ifndef LJQLIST#define LJQLIST#include <stdio.h>#include <malloc.h>#include <CString>//多项式链表的结构,第一个链表头的exp值表示为该多项式的项数typedef struct LJQLink{float data;int exp;struct LJQLink *next;}LJQLink,*LJQList;//初始化LJQLinkvoid create(LJQList &L);//插入新的节点次幂为e 系数为dvoid insert(LJQList L,int e,float d);//根据幂数,若存在输出该节点指针,显示该项系数LJQList search(LJQList L,int e);//打印多项式L,以幂数下降为序显示CString changeCString(LJQList L);//A 多项式和B多项式相加,输出到L A+B = Lvoid Add(LJQList &A,LJQList &B,LJQList &L);//A 多项式和B多项式相减,输出到L A-B = Lvoid Cut(LJQList &A,LJQList &B,LJQList &L);//A 多项式和B多项式相乘,输出到L A*B = Lvoid Multiply(LJQList &A,LJQList &B,LJQList &L);//A 多项式的求导函数,并输出到L (A)' = Lvoid Derivation(LJQList A,LJQList &L);//删除以e为次幂的节点void DeleteOne(LJQList &L,int e);//清空该单链表bool clear(LJQList &L);#endif //LJQLIST这里是LJQList.cpp的代码:#include"stdafx.h"#include "LJQList.h"//链表的初始化void create(LJQList &L){L = (LJQList)malloc(sizeof(struct LJQLink));L->next = NULL;L->exp = 0;L->data = 0;}//插入一个新的节点赋值幂数e,系数dvoid insert(LJQList L,int e,float d){LJQList n;n = (LJQList)malloc(sizeof(struct LJQLink));n->exp = e;n->data = d;n->next =NULL;if(n->data==0) free(n); //系数为0的话释放结点else{LJQList q1,q2;q1=L;q2=L->next;while(q2&&n->exp<q2->exp){ //查找插入位置q1=q2;q2=q2->next; }if(q2&&n->exp==q2->exp){//将指数相同相合并q2->data+=n->data;free(n);if(!q2->data){//系数为0的话释放结点L->exp--;q1->next=q2->next;free(q2);}} else{ //指数为新时将结点插入并使项数加1L->exp++;n->next=q2;q1->next=n;}}}//根据幂数,若存在输出该节点指针,显示该项系数LJQList search(LJQList L,int e){LJQList l = L->next;for(;l;l = l->next)if(l->exp ==e) {return l;}return NULL;}//打印多项式L,以幂数下降为序显示CString changeCString(LJQList L){LJQList l;CString s,cs;s = "";if(L->exp){l = L->next;if(l->data ==1) cs.Format(_T("X^%d"),l->exp),s+=cs;else if(l->data ==-1) cs.Format(_T("-X^%d"),l->exp),s+=cs;else cs.Format(_T("%0.1fX^%d"),l->data,l->exp),s+=cs;l = l->next;for(;l;l = l->next){if(l->data ==1) cs.Format(_T("+X^%d"),l->exp),s+=cs;else {if(l->data>=0)cs.Format(_T("+%0.1fX^%d"),l->data,l->exp),s+=cs;else if(l->data != -1) cs.Format(_T("%0.1fX^%d"),l->data,l->exp),s+=cs;else cs.Format(_T("-X^%d"),l->exp),s+=cs;}}}return s;}//A 多项式和B多项式相加,输出到L A+B = Lvoid Add(LJQList &A,LJQList &B,LJQList &L){LJQList la,lb;float d ;int e;la = A->next;lb = B->next;for(la = A->next;la;la = la->next){e = la->exp;d = la->data;insert(L,e,d);}for(lb = B->next;lb;lb = lb->next){e = lb->exp;insert(L,e,d);}}//A 多项式和B多项式相减,输出到L A-B = L void Cut(LJQList &A,LJQList &B,LJQList &L){ LJQList la,lb;float d ;int e;la = A->next;lb = B->next;for(la = A->next;la;la = la->next){e = la->exp;d = la->data ;insert(L,e,d);}for(lb = B->next;lb;lb = lb->next){e = lb->exp ;d = -lb->data ;insert(L,e,d);}}//A 多项式和B多项式相乘,输出到L A*B = L void Multiply(LJQList &A,LJQList &B,LJQList &L){ LJQList la,lb;float d ;int e;la = A->next;lb = B->next;while(la) {for(lb = B->next;lb;lb = lb->next){e = la->exp + lb->exp;d = la->data * lb->data;insert(L,e,d);}la = la->next;}}//A 多项式的求导函数,并输出到L (A)' = L void Derivation(LJQList A,LJQList &L){LJQList l = A->next;float d ;int e;for(;l;l = l->next){e = l->exp-1;insert(L,e,d);}}//删除以e为次幂的节点void DeleteOne(LJQList &L,int e){LJQList l,q;q = L;if( l = search(L,e))if(l->next) {for(;q->next;q = q->next)if(q->next->exp ==l->exp ) {if(!l->next) q->next = NULL;elseq->next = l->next;free(l);L->exp--;}}else {for(;q;q = q->next){if(q->next->exp ==l->exp ) {if(!l->next) q->next = NULL;elseq->next = l->next;free(l);L->exp--;}}}}//清空该单链表用一个递归函数清空bool clear(LJQList &L){if(L->next){LJQList q;q = L->next;if(q) DeleteOne(L,q->exp);clear(L);}else return true;return false;}这里是MFC自动生成的LJQDlg界面类的头文件,里面申明了各种参数,函数// CLJQDlg dialogclass CLJQDlg : public CDialog{// Constructionpublic:CLJQDlg(CWnd* pParent = NULL); // standard constructor// Dialog Data//{{AFX_DATA(CLJQDlg)enum { IDD = IDD_LJQ_DIALOG };int m_edit_exp;CString m_A;CString m_B;float m_edit_data;CString m_Show;int m_Radio_Kind;CString m_Message;int m_RadioAB;//}}AFX_DATA// ClassWizard generated virtual function overrides//{{AFX_VIRTUAL(CLJQDlg)protected:virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support //}}AFX_VIRTUAL// Implementationprotected:LJQList L;LJQList B;LJQList A;HICON m_hIcon;// Generated message map functions//{{AFX_MSG(CLJQDlg)virtual BOOL OnInitDialog();afx_msg void OnPaint();afx_msg HCURSOR OnQueryDragIcon();afx_msg void OnButtonJisuan();afx_msg void OnButtonTianjia();afx_msg void OnButtonClear();afx_msg void OnButtonDel();//}}AFX_MSGDECLARE_MESSAGE_MAP()};这里是LJQDlg.cpp文件的按钮上的各个事件响应函数://对应的是“”按钮void CLJQDlg::OnButtonJisuan() {// TODO: Add your control notification handler code hereUpdateData(true);if(B->exp ==0|| A->exp ==0 ) MessageBox("A 或B各至少需要添加一次才可以参加计算!");else {clear(L);// TODO: Add your control notification handler code hereswitch(m_Radio_Kind){case 0:Add(A,B,L);m_Show = "A + B =";m_Show += changeCString(L);break;case 1:Cut(A,B,L);m_Show = "A - B =";m_Show += changeCString(L);break;case 2:Multiply(A,B,L);m_Show = "A × B =";m_Show += changeCString(L);break;case 3:Derivation(A,L);m_Show = "对A求导=";m_Show += changeCString(L);break;}}UpdateData(false);}//对应的是“”按钮void CLJQDlg::OnButtonTianjia(){// TODO: Add your control notification handler code hereUpdateData(true);CString s="";m_Message = "";if(m_edit_exp*10%10 == 0)switch(m_RadioAB){case 0:insert(A,m_edit_exp,m_edit_data);m_A = changeCString(A);m_Message= "当前A多项式共有";s.Format(_T("%d项!"),A->exp);m_Message += s;break;case 1:insert(B,m_edit_exp,m_edit_data);m_B = changeCString(B);m_Message= "当前B多项式共有";s.Format(_T("%d项!"),B->exp);m_Message += s;break;}UpdateData(false);}//对应的是“”按钮void CLJQDlg::OnButtonClear(){UpdateData(true);// TODO: Add your control notification handler code hereswitch(m_RadioAB){case 0:m_A = "";clear(A);m_Message = "清空A成功!";break;case 1:m_B = "";clear(B);m_Message = "清空B成功!";break;}UpdateData(false);}//对应的是“”按钮void CLJQDlg::OnButtonDel(){// TODO: Add your control notification handler code hereUpdateData(true);CString s ="";LJQList l;switch(m_RadioAB){case 0:if(!A->exp) {MessageBox("当前A多项式为空,删除失败!");break;}if( l = search(A,m_edit_exp)){m_Message = "删除A中";s.Format(_T("%d"),l->exp);m_Message +=s;m_Message+="次幂项成功!";m_Message+= "该项系数为";s.Format(_T("%0.1f"),l->data);m_Message +=s;DeleteOne(A,m_edit_exp);break;}else m_Message ="删除失败!A中不存在该次幂项。

数据结构课程设计(一元稀疏多项式计算器)

数据结构课程设计(一元稀疏多项式计算器)

实习报告:1.5题一元稀疏多项式计算器题目:设计一个一元稀疏多项式简单计算器班级:计科一班姓名:康宇学号:10061014 完成日期:2013.4.15一、需求分析1、一元稀疏多项式简单计算器的功能是:1)输入并建立多项式;2)输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,………cn,en,其中n是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序排列;3)多项式a和b相加,建立多项式a+b;4)多项式a和b相减,建立多项式a-b。

5)计算多项式在x处的值;6)求多项式a、b的导函数;2、测试数据:1、(2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=(-3.1x^11+11x^9+2x+7);2、(6x^-3-x+4.4x^2-1.2x^9+1.2x^9)-(-6x^-3+5.4x^2-x^2+7.8x^15)=(-7.8x^15-1.2x^9+12x^-3-x);3、(1+x+x^2+x^3+x^4+x^5)+(-x^3-x^4)=(1+x+x^2+x^5);4、(x+x^3)+(-x-x^3)=0;5、(x+x^100)+(x^100+x^200)=(x+2x^100+x^200);6、(x+x^2+x^3)+0=x+x^2+x^3.二、概要设计为实现上述程序功能,应以有序链表来表示多项式的系数和指数。

定义线性表的动态分配顺序存储结构;建立多项式存储结构,定义指针*next利用链表实现队列的构造。

每次输入一项的系数和指数,可以输出构造的一元多项式演示程序以用户和计算机的对话方式执行,即在计算机终站上显示“提示信息”之后,由用户在键盘上输入演示程序中规定的运行命令;最后根据相应的输入数据(滤去输入中的非法字符)建立的多项式以及多项式相加的运行结果在屏幕上显示。

1、元素类型、结点类型和指针类型:typedef struct LNode{float xishu; //系数int zhishu; //指数struct LNode *next;} LNode,*Linklist;2、建立两个全局链表指针,Linklist List1=NULL;Linklist List2=NULL;用来存放两个多项式,然后在main()函数里调用输入函数。

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

数据结构课程设计系别电子信息系专业计算机科学与技术班级学号4090113姓名王健指导教师党群成绩2011年7 月14 日目录一、课程题目 (1)二、需求分析 (1)三、测试数据 (2)四、概要设计 (2)五、调用关系图 (3)六、程序代码 (3)七、心得体会及总结 (12)数据结构课程设计一、课程题目一元稀疏多项式计算器二、需求分析1、一元稀疏多项式简单计算器的功能是:1.1 输入并建立多项式;1.2 输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,………cn,en,其中n是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序排列;1.3 求多项式a、b的导函数;1.4 计算多项式在x处的值;1.5多项式a和b相加,建立多项式a+b;1.6 多项式a和b相减,建立多项式a-b。

2、设计思路:2.1 定义线性表的动态分配顺序存储结构;2.2 建立多项式存储结构,定义指针*next2.3利用链表实现队列的构造。

每次输入一项的系数和指数,可以输出构造的一元多项式2.4演示程序以用户和计算机的对话方式执行,即在计算机终站上显示“提示信息”之后,由用户在键盘上输入演示程序中规定的运行命令;最后根据相应的输入数据(滤去输入中的非法字符)建立的多项式以及多项式相加的运行结果在屏幕上显示。

多项式显示的格式为:c1x^e1+c2x^e2+…+cnx^en3、设计思路分析要解决多项式相加,必须要有多项式,所以必须首先建立两个多项式,在这里采用链表的方式存储链表,所以我将结点结构体定义为运用尾插法建立两条单链表,以单链表polyn p和polyn h分别表示两个一元多项式a和b,a+b的求和运算等同于单链表的插入问题(将单链表polyn p中的结点插入到单链表polyn h中),因此“和多项式”中的结点无须另生成。

为了实现处理,设p、q分别指向单链表polya和polyb的当前项,比较p、q结点的指数项,由此得到下列运算规则:① 若p->expn<q->expn,则结点p所指的结点应是“和多项式”中的一项,令指针p后移。

② 若p->expn=q->expn,则将两个结点中的系数相加,当和不为0时修改结点p的系数。

③ 若p->expn>q->expn,则结点q所指的结点应是“和多项式”中的一项,将结点q插入在结点p之前,且令指针q在原来的链表上后移。

三、测试数据:1、(2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=(-3.1x^11+11x^9+2x+7);2、(6x^-3-x+4.4x^2-1.2x^9+1.2x^9)-(-6x^-3+5.4x^2-x^2+7.8x^15)=(-7.8x^15-1.2x^9+12x^-3-x);3、(1+x+x^2+x^3+x^4+x^5)+(-x^3-x^4)=(1+x+x^2+x^5);4、(x+x^3)+(-x-x^3)=0;5、(x+x^100)+(x^100+x^200)=(x+2x^100+x^200);6、(x+x^2+x^3)+0=x+x^2+x^3.四、概要设计1、元素类型、结点类型和指针类型:typedef struct Polynomial{float coef; //系数int expn; //指数struct Polynomial *next;}*Polyn,Polynomial;2、建立一个头指针为head、项数为m的一元多项式, 建立新结点以接收数据, 调用Insert函数插入结点:Polyn CreatePolyn(Polyn head,int 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("请输入第%d项的系数与指数:",i+1);scanf("%f %d",&p->coef,&p->expn);Insert(p,head);}return head;}3、主函数和其他函数:void main(){int m,n,a,x;char flag;Polyn pa=0,pb=0,pc;}float ValuePolyn(Polyn head,int x) //输入x值,计算并返回多项式的值五、调用关系图(图1)六、程序代码:#include<stdio.h>#include<stdlib.h> //定义多项式的项typedef struct Polynomial{float coef; //系数int expn; //指数struct Polynomial *next;}*Polyn,Polynomial;void Insert(Polyn p,Polyn h){if(p->coef==0) free(p); //系数为0的话释放结点 else{Polyn q1,q2;q1=h;q2=h->next;while(q2&& p->expn < q2->expn){ //查找插入位置q1=q2;q2=q2->next;}if(q2&& p->expn == q2->expn){ //将指数相同相合并q2->coef += p->coef;free(p);if(!q2->coef){ //系数为0的话释放结点q1->next=q2->next;free(q2);}}else{ //指数为新时将结点插入p->next=q2;q1->next=p;}}}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("请输入第%d项的系数与指数:",i+1);scanf("%f %d",&p->coef,&p->expn);Insert(p,head); //调用Insert函数插入结点}return head;}void 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){ //若多项式为空,输出0putchar('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->expn==1) putchar('X');else if(q->expn) printf("X^%d",q->expn);}else{if(q->coef==1){if(!q->expn) putchar('1');else if(q->expn==1) putchar('X');else printf("X^%d",q->expn);}if(q->coef==-1){if(!q->expn) printf("-1");else if(q->expn==1) printf("-X");else printf("-X^%d",q->expn);}}q=q->next;flag++;}printf("\n");}int compare(Polyn a,Polyn b){if(a&&b){if(!b||a->expn>b->expn) return 1;else if(!a||a->expn<b->expn) return -1;else return 0;}else if(!a&&b) return -1; //a多项式已空,但b 多项式非空else return 1; //b多项式已空,但a 多项式非空}Polyn 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->expn=qa->expn;qa=qa->next;break;}case 0:{qc->coef=qa->coef+qb->coef;qc->expn=qa->expn;qa=qa->next;qb=qb->next;break;}case -1:{qc->coef=qb->coef;qc->expn=qb->expn;qb=qb->next;break;}}if(qc->coef!=0){qc->next=hc->next;hc->next=qc;hc=qc;}else free(qc); //当相加系数为0时,释放该结点}return headc;}Polyn 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;}float ValuePolyn(Polyn head,int x){ //输入x值,计算并返回多项式的值Polyn p;int i,t;float sum=0;for(p=head->next;p;p=p->next){t=1;for(i=p->expn;i!=0;){if(i<0){t/=x;i++;} //指数小于0,进行除法else{t*=x;i--;} //指数大于0,进行乘法}sum+=p->coef*t;}return sum;}Polyn Derivative(Polyn head){ //求解并建立导函数多项式,并返回其头指针Polyn q=head->next,p1,p2,hd;hd=p1=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点hd->next=NULL;while(q){if(q->expn!=0){ //该项不是常数项时p2=(Polyn)malloc(sizeof(struct Polynomial));p2->coef=q->coef*q->expn;p2->expn=q->expn-1;p2->next=p1->next; //连接结点p1->next=p2;p1=p2;}q=q->next;}return hd;}Polyn 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->expn=qa->expn+qb->expn;Insert(pf,hf); //调用Insert函数以合并指数相同的项}}return hf;}void main(){int m,n,a,x;char flag;Polyn pa=0,pb=0,pc;printf("--------------------------------------------------\n");printf(" | ***班 *** ******** |\n");printf("--------------------------------------------------\n");printf(" 欢迎使用多项式操作程序\n");printf("请输入a的项数:");scanf("%d",&m);pa=CreatePolyn(pa,m); //建立多项式aprintf("请输入b的项数:");scanf("%d",&n);pb=CreatePolyn(pb,n); //建立多项式b//输出菜单printf(" **************************************************\n");printf(" * 多项式操作程序 *\n");printf(" * *\n");printf(" * A:输出多项式a B:输出多项式b *\n");printf(" * *\n");printf(" * C:输出a的导数 D:输出b的导数 *\n");printf(" * *\n");printf(" * E:代入x的值计算a F:代入x的值计算b *\n");printf(" * *\n");printf(" * G:输出a+b H:输出a-b *\n");printf(" * *\n");printf(" * I:输出a*b J:退出程序*\n");printf(" * *\n");printf(" *************************************************\n");while(a){printf("\n请选择操作:");scanf(" %c",&flag);switch(flag){case'A':case'a':{printf("\n 多项式a=");PrintPolyn(pa);break;}case'B':case'b':{printf("\n 多项式b=");PrintPolyn(pb);break;}case'C':case'c':{pc=Derivative(pa);printf("\n 多项式a的导函数为:a'=");PrintPolyn(pc);break;}case'D':case'd':{pc=Derivative(pb);printf("\n 多项式b的导函数为:b'=");PrintPolyn(pc);break;}case'E':case'e':{printf("输入x的值:x=");scanf("%d",&x);printf("\n x=%d时,a=%.3f\n",x,ValuePolyn(pa,x));break;}case'F':case'f':{printf("输入x的值:x=");scanf("%d",&x);printf("\n x=%d时,b=%.3f\n",x,ValuePolyn(pb,x));break;}case'G':case'g':{pc=AddPolyn(pa,pb);printf("\n a+b=");PrintPolyn(pc);break;}case'H':case'h':{pc=SubtractPolyn(pa,pb);printf("\n a-b=");PrintPolyn(pc);break;}case'I':case'i':{pc=MultiplyPolyn(pa,pb);printf("\n a*b=");PrintPolyn(pc);break;}case'J':case'j':{printf("\n 感谢使用此程序!\n");DestroyPolyn(pa);DestroyPolyn(pb);a=0;break;}default:printf("\n 您的选择错误,请重新选择!\n");}}}七、心得体会及总结通过这次课程设计,我感觉到要真正做出一个程序并不很容易,但只要用心去做,总会有收获,特别是当我遇到问题,与同学互相探讨,想尽办法去解决,最后终于找到方法时,心里的那份喜悦之情真是难以形容.编写程序中遇到问题再所难免,应耐心探究其中的原因,从出现问题的地方起,并联系前后程序,仔细推敲,逐个排查.直到最终搞清为止。

相关文档
最新文档