《数据结构课设》一元稀疏多项式的运算程序

合集下载

数据结构课程设计-一元多项式的加法、减法、乘法的实现

数据结构课程设计-一元多项式的加法、减法、乘法的实现

一、设计题目一元多项式的加法、减法、乘法的实现。

二、主要内容设有一元多项式A m(x)和B n(x).A m(x)=A0+A1x1+A2x2+A3x3+… +A m x mB n(x)=B0+B1x1+B2x2+B3x3+… +B n x n请实现求M(x)= A m(x)+B n(x)、M(x)= A m(x)-B n(x)和M(x)= A m(x)×B n(x)。

要求:1) 首先判定多项式是否稀疏2) 采用动态存储结构实现;3) 结果M(x)中无重复阶项和无零系数项;4) 要求输出结果的升幂和降幂两种排列情况三、具体要求及应提交的材料1.每个同学以自己的学号和姓名建一个文件夹,如:“312009*********张三”。

里面应包括:学生按照课程设计的具体要求所开发的所有源程序(应该放到一个文件夹中)、任务书和课程设计说明书的电子文档。

2.打印的课程设计说明书(注意:在封面后夹入打印的“任务书”以后再装订)。

四、主要技术路线提示为把多个小功能结合成一个完整的小软件,需使用“菜单设计”技术(可以是控制台方式下的命令行形式,若能做成图形方式则更好)。

五、进度安排共计两周时间,建议进度安排如下:选题,应该在上机实验之前完成需求分析、概要设计可分配4学时完成详细设计可分配4学时调试和分析可分配10学时。

2学时的机动,可用于答辩及按教师要求修改课程设计说明书。

注:只用课内上机时间一般不能完成设计任务,所以需要学生自行安排时间做补充。

六、推荐参考资料(不少于3篇)[1]苏仕华等编著,数据结构课程设计,机械工业出版社,2007[2]严蔚敏等编著,数据结构(C语言版),清华大学出版社,2003[3]严蔚敏等编著,数据结构题集(C语言版),清华大学出版社,2003指导教师签名日期年月日系主任审核日期年月日摘要分析了matlab,mathmatic,maple等数学软件对一元多项式的计算过程,步骤后。

由于这些软件比较大功能齐全,但是实用性不强。

一元稀疏多项式的加法运算数据结构实习

一元稀疏多项式的加法运算数据结构实习

实习一线性表、栈和队列及其应用——一元稀疏多项式的加法运算【问题描述】设计一个实现一元稀疏多项式相加运算的演示程序。

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

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

多项式b,c类似输出。

【测试数据】(1)(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5)(2)(x+x100)+(x100+x200)=(x+2x100+x200)(3)(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11)一.需求分析1.输入的形式和输入值的围:输入是从键盘输入的,输入的容为多项式的系数和指数,其中多项式的每一项分别以一个系数和指数的形式输入,不带未知数X,系数为任意的实数,指数为任意的整数。

要结束该多项式的输入时,输入的指数和系数都为0.2. 输出的形式从屏幕输出,显示用户输入的多项式,并显示多项式加减以后的多项式的值,并且多项式中将未知数X表示了出来. 形式为:+c1X^e1+c2X^e2+…+ciX^ei+…(ci和ei分别是第i 项的系数和指数,序列按指数升序排列。

)当多项式的某一项的系数为+1或者-1时侧该项多项式的输出形式为X^ei或-X^ei;当该项的系数为正时输出+ciX^ei,当为负数时则输出ciX^ei3. 程序所能达到的功能输入并建立多项式,实现一元稀疏多项式的相加并输出。

4. 注意:所有多项式都必须以指数升密形式输入。

5. 测试数据为(1)(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5)(2)(x+x100)+(x100+x200)=(x+2x100+x200)(3)(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11)二.设计1.设计思路(1).储存结构:链式存储(2). 主要算法基本思路首先定义一个多项式的结构体,存放多项式每一项的系数和指数以及next指针;然后定义两个指针,第一个指针指向第一个多项式,第二个指针指向第二个多项式。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

一元多项式计算(数据结构课程设计)一、系统设计1、算法思想根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相同的项,对应指数相加(减),若其和(差)不为零,则构成“和(差)多项式”中的一项;对于两个一元多项式中所有指数不相同的项,则分别写到“和(差)多项式”中去。

因为多项式指数最高项以及项数是不确定的,因此采用线性链表的存储结构便于实现一元多项式的运算。

为了节省空间,我采用两个链表分别存放多项式a 和多项式b,对于最后计算所得的多项式则利用多项式a进行存储。

主要用到了单链表的插入和删除操作。

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

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

P的指数大于q的指数的话,就应该复制p节点到多项式中。

当第二个多项式空,第一个多项式不为空时,将第一个多项式用新节点产生。

当第一个多项式空,第二个多项式不为空时,将第二个多项式用新节点产生。

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

p的指数小于q的指数的话,就应该复制q的节点到多项式中。

P的指数大于q的指数的话就应该复制p的节点到多项式中,并且建立的节点的系数为原来的相反数;当第二个多项式空,第一个多项式不为空时,将第一个多项式用新节点产生。

当第一个多项式空,第二个多项式不为空时,将第二个多项式用新节点产生,并且建立的节点的系数为原来的相反数。

2、概要设计(1)主函数流程图:(注:a代表第一个一元二次方程,b代表第二个一元二次方程)(2)一元多项式计算算法用类C语言表示:Typedef struct00{ //项的表示,多项式的项作为LinkList的数据元素Float coef;//细数Int expn;//指数}term,ElemType;//两个类型名:term用于本ADT,ElemType为LinkList的数据对象名Typedef LinkList polynomial://用带表头的节点的有序链表表示多项式//基本操作的函数原型说明Void CreatePolyn(polynomail&P);//输入n的系数和指数,建立表示一元多项式的有序链表P 销毁一元多项式P Void DestroyPolyn(polynomailP);销毁一元多项式PvoidPrintPoly(polynomail P);//打印输入一元多项式PIntPolynLength(polynnomail P);//返回一元多项式P中的项数void CreatPolyn(polynomail&Pa.polunomail&Pb);//完成多项式相加运算,即:Pa=Pa+Pb,并贤惠一元多项式Pb voidSubtractPolyn(polunomail&Papolunomail&Pb);//完成多项式相减运算,即:Pa=Pa-Pb,并销毁一元多项式Pb//基本操作的算法描述Int cmp(tem a,temp b);//依a的指数值<(或=)(或>b的住数值,分别返回-1、0和+1Void CreatePolyn(polynomail&P,int m){//输入m项的系数和指数,建立表示一元多项式的有序链表PInitList(P);h=GetHead(P);E.coef=0.0; e.expn=-1;S erCurElem(h,e);//设置头结点的数据元素For (i=1;i<=m;++i){ //依次输入m个非零项Scanf(e.coef,e.epn);If(!LocateElem(P,e,q,(*cmp)())){//当前链表中不存在该指数项If(MakeNode(s,e))InsFirst(q,s);//生成节点并插入链表}}}//CreatPolun二、详细设计1、算法实现(1)输入一元多项式函数:void shuchu(pnode *head){pnode *p;int one_time=1;p=head;while(p!=NULL) /*如果不为空*/{if(one_time==1){if(p->zhishu==0) /*如果指数为0的话,直接输出系数*/printf("%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/else if(p->xishu==1||p->xishu==-1)printf("X^%d",p->zhishu); /*如果系数是1的话就直接输出+x*//*如果系数是-1的话就直接输出-x号*/else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);one_time=0;}else{if(p->zhishu==0) /*如果指数为0的话,直接输出系数*/{if(p->xishu>0)printf("+%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/}else if(p->xishu==1) /*如果系数是1的话就直接输出+x号*/printf("+X^%d",p->zhishu);else if(p->xishu==-1) /*如果系数是-1的话就直接输出-x号*/printf("X^%d",p->zhishu);else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("+%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/printf("%5.2fX^%d",p->xishu,p->zhishu);}p=p->next; /*指向下一个指针*/}printf("\n");}(2)加法函数/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针,r,s为临时指针,p指向第1个多项式并向右移动,q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话,就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话,就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空,第1个数不为空时,将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空,第1个数不为空时,将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}(3)减法函数/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针,r,s为临时指针,p指向第1个多项式并向右移动,q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话,就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话,就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空,第1个数不为空时,将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空,第1个数不为空时,将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}2、程序代码/*一元多项式计算*//*程序功能:能够按照指数降序排列建立并输出多项式;能够完成两个多项式的相加、相减,并将结果输出;*//*提示:输入完一元多项式之后,输入“0 0”结束本一元多项式的输入*//*注意:系数只精确到百分位,最大系数只能为999.99,指数为整数.如果需要输入更大的系数,可以对程序中5.2%f进行相应的修改*/#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<conio.h>/*建立结构体*/typedef struct pnode{float xishu; /*系数*/int zhishu; /*指数*/struct pnode *next; /*下一个指针*/}pnode;/*用头插法生成一个多项式,系数和指数输入0时退出输入*/pnode * creat()int m;float n;pnode *head,*rear,*s; /*head为头指针,rear和s为临时指针*/ head=(pnode *)malloc(sizeof(pnode));rear=head; /*指向头*/scanf("%f",&n); /*系数*/scanf("%d",&m); /*输入指数*/while(n!=0) /*输入0退出*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=n;s->zhishu=m;s->next=NULL;rear->next=s; /*头插法*/rear=s;scanf("%f",&n); /*输入系数*/scanf("%d",&m); /*输入指数*/}head=head->next; /*第一个头没有用到*/return head;}/*调整多项式*/void tiaozhen(pnode *head){pnode *p,*q,*t;float temp;p=head;while(p!=NULL){q=p;t=q->next;while(t!=NULL){if(t->zhishu>q->zhishu)q=t;t=t->next;}temp=p->xishu;p->xishu=q->xishu;q->xishu=temp;temp=p->zhishu;p->zhishu=q->zhishu;q->zhishu=temp;p=p->next;}/*显示一个多项式*/void shuchu(pnode *head){pnode *p;int one_time=1;p=head;while(p!=NULL) /*如果不为空*/{if(one_time==1){if(p->zhishu==0) /*如果指数为0的话,直接输出系数*/printf("%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/else if(p->xishu==1||p->xishu==-1)printf("X^%d",p->zhishu); /*如果系数是1的话就直接输出+x*//*如果系数是-1的话就直接输出-x号*/else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);one_time=0;}else{if(p->zhishu==0) /*如果指数为0的话,直接输出系数*/{if(p->xishu>0)printf("+%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/}else if(p->xishu==1) /*如果系数是1的话就直接输出+x号*/printf("+X^%d",p->zhishu);else if(p->xishu==-1) /*如果系数是-1的话就直接输出-x号*/printf("X^%d",p->zhishu);else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("+%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);}p=p->next; /*指向下一个指针*/}printf("\n");/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针,r,s为临时指针,p指向第1个多项式并向右移动,q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话,就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话,就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空,第1个数不为空时,将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空,第1个数不为空时,将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}/*两个多项式的减法运算*/pnode * sub(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r;float x; /*x为系数相减*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*两个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu-q->xishu; /*系数相减*/if(x!=0) /*相减的差不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=-q->xishu; /*建立的节点的系数为原来的相反数*/s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}else{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}while(p!=NULL) /*当第2个多项式空,第1个数不为空时,将第一个数剩下的全用新节点产生*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}while(q!=NULL) /*当第1个多项式空,第1个数不为空时,将第2个数剩下的全用新节点产生*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=-q->xishu; /*建立的节点的系数为原来的相反数*/ s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}void add_main(){pnode * a,*b,*c;printf("\n输入第一个一元多项式:\n系数指数\n");a=creat();tiaozhen(a);printf("\n输入第二个一元多项式:\n系数指数\n");b=creat();tiaozhen(b);c=add(a,b);printf("第一个一元多项式如下:");shuchu(a);printf("第二个一元多项式如下:");shuchu(b);printf("两式相加如下:");shuchu(c);}void sub_main(){pnode * a,*b,*c;printf("\n输入第一个一元多项式:\n系数指数\n");a=creat();tiaozhen(a);printf("\n输入第二个一元多项式:\n系数指数\n");b=creat();tiaozhen(b);c=sub(a,b);printf("第一个一元多项式如下:");shuchu(a);printf("第二个一元多项式如下:");shuchu(b);printf("两式相减如下:");shuchu(c);}void open(){printf("\n****************************************************\n");printf(" 功能项: * 1 两个一元多项式相加;2 两个一元多项式相减;0 退出*\n");printf("****************************************************\n\n请选择操作: ");}void main(){int choose;open();while(choose!=0){scanf("%d",&choose);getchar();switch(choose){case 0:return;case 1:printf("\n 两个一元多项式相加\n");add_main();choose=-1;open();break;case 2:printf("\n 两个一元多项式相减\n");sub_main();choose=-1;open();break;default:printf("没有该选项!请重新选择操作!\n\n");open();}}}三、测试方案及结果1、测试方案在Visual C++ 6.0环境中调试运行。

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

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

数据结构实习报告——一元稀疏多项式运算器的设计一、引言在计算机科学领域中,数据结构是构建各种算法和程序的基础。

本次实习项目旨在设计一个一元稀疏多项式运算器,通过合理的数据结构和算法实现多项式的加法、减法和乘法运算,以及求导和求值等功能。

本文将详细介绍该运算器的设计思路、数据结构选择、算法实现和性能优化等方面。

二、设计思路为了实现一元稀疏多项式的运算,我们需要选择合适的数据结构来存储和操作多项式的系数和指数。

考虑到多项式中只有少数系数非零,我们可以使用链表来表示多项式,每个节点存储一个非零系数和对应的指数。

这样可以节省空间,并且方便插入和删除操作。

三、数据结构选择在设计中,我们选择了一个单向链表作为多项式的数据结构。

链表节点的定义如下:```struct Node {int coefficient; // 系数int exponent; // 指数Node* next; // 下一个节点指针};```链表的头节点指针指向第一个非零项,便于遍历和操作。

四、算法实现1. 多项式的输入用户可以通过标准输入方式输入多项式的系数和指数,我们通过读取用户输入的系数和指数,并根据其大小构建链表。

2. 多项式的加法和减法运算多项式的加法和减法运算可以通过遍历两个多项式的链表,并根据指数的大小进行合并操作。

具体的实现可以使用双指针的方式,分别指向两个链表的当前节点,比较指数的大小,然后将较小的节点插入到结果链表中,并将指针向后移动。

3. 多项式的乘法运算多项式的乘法运算可以通过遍历两个多项式的链表,并将每一项相乘得到新的项,然后将新的项插入到结果链表中。

具体的实现中,可以使用一个嵌套的循环,先遍历一个多项式的链表,再遍历另一个多项式的链表,将每一项相乘,并根据指数的大小插入到结果链表中。

4. 多项式的求导和求值多项式的求导可以通过遍历链表,将每一项的系数乘以指数,并将指数减一得到新的项。

多项式的求值可以通过遍历链表,将每一项的系数乘以变量的值的指数次方,并累加得到结果。

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

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

数据结构实验报告——一元稀疏多项式计算器安子烨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("未找到该项。

数据结构课程设计

数据结构课程设计

第一章问题分析与任务定义1 .题目:设计一个一元稀疏多项式的简单计算器。

输入并用带表头结点的单链表存储多项式;以整数序列:n,c1,e1,c2,e2……cn,en的形式输出多项式,其中n是多项式的项数,ci,ei分别为第i项的系数和指数,序列按指数降序排列;实现多项式a、b的相加和相减操作,输出相加、相减后的多项式。

2.问题分析:符号多项式的操作,已经成为标处理的典型应用例子,多项式可由n+1个系数唯一确定,因此在计算机里可以用一个线性表来表示,每一项的指数隐含在其系数序号里,只要在结点的data域里多加一项即可,显然我们可以对该存储采取顺序存储,使得多项式相加的算法定义十分简洁,然而通常的应用里多项式的次数可能很高而且很大,使得顺序存储结构的最大长度很难确定。

这种对内存空间的浪费是应当避免的,因此若只对多项式进行求值等不改变多项式系数和指数的运算则采用类似于顺序表的顺序存储结构即可,否则采用链式存储表示比较好。

1.如何实现这种线性链表表示的多项式的加法呢?根据一元多项式的加减法运算法则:对于两个一元多项式中的所有指数相同的项,对应系数相加减,若其和不为零,则构成和或差多项式中的一项,对于两个一元多项式中的所有指数不同的向分别复抄到和火差多项式里去。

在此,按照数据类型Polynomial中的基本操作的定义,和或差多项式中的结点无需另生成,而应该从两个多项式的链表中摘取,其运算规则如下:假设指针qa和qb分别指向多项式A和B中当前进行比较的某个结点,则比较两个结点中的指数项,有下列三种情况(1)指针qa所指结点的指数值<指针qb所指结点的指数值,则应摘取qa所致结点插入到和差多项式链表中去(2)指针qa所致结点的指数值>指针qb所指结点的指数值,则应摘取指针qb所指结点插入到和差多项式里链表中去(3)指针qa所指结点的指数值=指针qb所指结点的指数值,则将两个结点中的系数相加减,若和差数不为零,则修改qa所指结点的系数值,同时释放qb所直接点;繁殖,从多项式Adequate链表中删除相应结点,并释放指针qa和qb所致结点。

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

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

数据结构课程设计系别电子信息系专业计算机科学与技术班级学号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后移。

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

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

数据结构实习报告班级 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。

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

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

数据结构课程方案一元稀疏多项式计算

数据结构课程方案一元稀疏多项式计算

#include<stdio.h>#include<malloc.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的一元多项式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>。

数据结构课程设计——一元多项式计算

数据结构课程设计——一元多项式计算

数据结构课程设计——一元多项式计算一、课程设计题目及要求二、设计思路和方法三、程序流程图四、程序代码及注释五、测试结果及分析六、结论七、参考文献本次课程设计的题目为“一元多项式计算”,要求设计一个程序,能够实现一元多项式的加、减、乘、求导和求值等操作。

在设计思路和方法上,我们采用了链表的数据结构来存储多项式,同时设计了相应的函数来实现各种操作。

程序的流程图如下所示:插入流程图)程序的代码及注释如下所示:插入代码及注释)在测试结果及分析方面,我们对程序进行了多组测试,并对其进行了详细的分析和比较。

结果表明,我们的程序能够正确地实现各种操作,并且具有较高的效率和稳定性。

综上所述,本次课程设计的目标已经得到了圆满地实现,我们对于所取得的成果感到非常满意。

同时,我们也希望能够通过这次课程设计,加深对于数据结构及其应用的理解和掌握,为今后的研究和工作打下坚实的基础。

设计目标:本课程设计旨在结合理论与实际应用,提高学生组织数据及编写大型程序的能力。

通过掌握数据组织、算法设计和算法性能分析的方法,培养学生良好的程序设计能力。

具体实现是利用单链表表示一元多项式,实现多项式的输入、建立、输出、相加、相减和相乘。

总体设计:2.1 数据结构描述与定义:一元多项式定义系数和指数结构如下:coef,expn和next。

定义多项式的结构为线性链表的存储结构,每个结点包含三个元素:系数coef,指数expn和指向下一个结点的指针*next。

多个单项式通过指针连接起来,形成一个多项式。

2.2 模块设计:从实现多项式运算过程的角度来分析,至少需要以下子功能模块:多项式创建、销毁、输出、相加、相减和相乘。

定义并调用的函数有:Insert、CreatePolyn、DestroyPolyn、PrintPolyn、AddPolyn、SubtractPolyn、XXX和main函数。

注:该文章中没有明显的格式错误和需要删除的段落,因此没有进行小幅度改写。

数据结构一元稀疏多项式

数据结构一元稀疏多项式

要求完成如下功能:(1)输入并建立多项式——creatpolyn()(2)输出多项式,输出形式为整数序列,序列按指数升序排列——printpolyn() (3)多项式a和b相加,建立多项式a+b,输出相加的多项式——addpolyn() (4)多项式a和b相减,建立多项式a-b,输出相减的多项式——subpolyn()用带表头结点的单链表存储多项式。

课程设计学生姓名:学号:专业班级:课程名称:数据结构学年学期:指导教师:目录1.需求分析说明 (1)2.概要设计说明 (3)3.详细设计说明 (5)4.调试分析 (10)5.用户使用说明 (11)6.课程设计总结 (12)7.测试结果 (13)8.参考书目 (16)9. 附录 (17)1 需求分析说明1.程序所能达到的功能是(1)输入并建立多项式——creatpolyn()(2)输出多项式,输出形式为整数序列,序列按指数升序排列——printpolyn() (3)多项式a和b相加,建立多项式a+b,输出相加的多项式——addpolyn()(4)多项式a和b相减,建立多项式a-b,输出相减的多项式——subpolyn()用带表头结点的单链表存储多项式。

2.输入的形式和输入值的范围:本系统要输入的数据主要是有多项式中每项的系数和指数,可以把它们定义为整形数据,既可以为整数也可以为非负整数,即有符号的整形数据,由于整形数据在内存里占用两个字节,所以它的取值范围为-32768—32767。

其次还有就是选择功能时,要输入的功能号,它们是字符型数据,取值范围是ASS||表中的字符。

例如输入的格式如下:请输入a的项数:3请输入第一项的系数与指数:2,1请输入第二项的系数和指数:5,8请输入第三项的系数和指数:-3.1,11请输入b的项数:3请输入第一项的系数和指数:7,0请输入第一项的系数和指数:5,8请输入第三项的系数和指数:11,9******************************************************************多项式操作程序* A:输出多项式a B:输出多项式b ** C:输出a+b D:输出a-b ** F:退出程序 *********************************************************************请选择操作:Ca+b=2x+5x8-3.1x11+7-5x8+11x9请选择操作:Da-b=2x+5x8-3.1x11-7+5x8-11x93.输出的形式:本系统要输出的是把创建好的第一个多项式和第二个多项式按指数升序排列,并把进行运算后的结果也按指数升序排列输出,输出形式如上面所示。

一元稀疏多项式的表示及加法运算

一元稀疏多项式的表示及加法运算

一元稀疏多项式的表示及加法运算一、需求分析1.程序的功能(1).按照指数升序顺序,输入并建立多项式M与N。

(2).计算多项式M与N的和(3).输出多项式M、N、M+N。

2.输入输出的要求多项式按指数递增顺序输入;设计的数据结构应有利于表示任意一元稀释多项式;多项式的输出采用数学多项式的表示形式。

3.测试数据(1)7+3x+9x8+5x17, 8x+22x7-9x8(2) 0, 8x+22x7-9x8(3)8x10+22x7-9x8 , -1二、概要设计1.通过建立链表来实现多项式的输入在多项式输入之前,要先定义一个带有头结点的单链表,紧接着以指数递增的顺序输入多项式中系数不为零的项,其中每一项对应一个结点,每项对应的结点依次插入直至遇到结束标志,这样结完成了多项式的输入。

2. 两个多项式相加两个多项式中如果指数相同则系数相加,构成和多项式的一项;如果指数不同,则直接构成和多项式的一项。

3. 多项式的输出采用数学多项式的表达方式三、详细设计1.定义数据类型:typedef struct pnode{float coef; //系数int exp; //指数struct pnode *next; //指针,指向下一个系数不为的子项}PNode, *PLink;PLink M,N,P; //多项式M、N、P2.通过建立链表来实现多项式的输入在多项式输入之前,要先定义一个带有头结点的单链表,先输入多项式项数,紧接着以指数递增的顺序输入多项式中系数不为零的项,其中每一项对应一个结点,每项对应的结点依次插入,当项数达到时结束,这样完成了多项式的输入。

PNode *createList(PNode *p) //建立多项式链表{float a;int b;int c;int d;p=new PNode;PNode *nNode;PNode *kNode=p;if(p==NULL){return NULL;}else{p->next=NULL;cout<<"请输入多项式项数"<<endl;cin>>d;cout<<"请输入系数和指数"<<endl;for(c=0;c<d;c++){cin>>a>>b;nNode=new PNode;if(nNode==NULL){return p;}nNode->coef=a;nNode->exp=b;kNode->next=nNode;kNode=nNode;}nNode->next=NULL;}return p;}3. 两个多项式相加两个多项式中如果指数相同则系数相加,构成和多项式的一项;如果指数不同,则直接构成和多项式的一项。

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

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

一元多项式加法一、实验目的通过实现多项式加法,对链表有更深入的了解二、实验内容问题描述:设计一个一元稀疏多项式简单的加法计算器实现要求:一元稀疏多项式简单计算器的基本功能是:(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 (1)

数据结构课程设计1 (1)

1.一元稀疏多项式计算器(不选)[问题描述]设计一个一元稀疏多项式简单计算器。

[基本要求]输入并建立多项式;输出多项式,输出形式为整数序列:n, c1, e1, c2, e2,……, cn, en ,其中n是多项式的项数,ci, ei分别是第i项的系数和指数,序列按指数降序排序;多项式a和b相加,建立多项式a+b;多项式a和b相减,建立多项式a-b;[测试数据](2x+5x8-3.1x11)+(7-5x8+11x9)=(-3.1x11+11x9+2x+7)(6x-3-x+4.4x2-1.2x9)-(-6x-3+5.4x2-x2+7.8x15)=(-7.8x15-1.2x9-x+12x-3)(1+x+x2+x3+x4+x5)+(-x3-x4)=(x5+x2+x+1)(x+x3)+(-x-x3)=0(x+x2+x3)+0=(x3+x2+x)[实现提示]用带头结点的单链表存储多项式,多项式的项数存放在头结点中。

2.背包问题的求解(一人)[问题描述]假设有一个能装入总体积为T的背包和n件体积分别为w1, w2, …,wn的物品,能否从n件物品中挑选若干件恰好装满背包,即使w1+w2+…+wn=T,要求找出所有满足上述条件的解。

例如:当T=10,各件物品的体积为{1,8,4,3,5,2}时,可找到下列4组解:(1,4,3,2)、(1,4,5)、(8,2)、(3,5,2)[实现提示]可利用回溯法的设计思想来解决背包问题。

首先,将物品排成一列,然后顺序选取物品转入背包,假设已选取了前i件物品之后背包还没有装满,则继续选取第i+1件物品,若该件物品“太大”不能装入,则弃之而继续选取下一件,直至背包装满为止。

但如果在剩余的物品中找不到合适的物品以填满背包,则说明“刚刚”装入背包的那件物品“不合适”,应将它取出“弃之一边”,继续再从“它之后”的物品中选取,如此重复,直至求得满足条件的解,或者无解。

由于回溯求解的规则是“后进先出”因此自然要用到栈。

一元稀疏多项式计算器课程设计

一元稀疏多项式计算器课程设计

一元稀疏多项式计算器课程设计-CAL-FENGHAI-(2020YEAR-YICAI)_JINGBIAN软件学院课程设计报告书课程名称数据结构设计题目一元稀疏多项式计算器专业班级软件工程11级1班学号 07姓名指导教师2013 年 1月目录1设计时间 ............................................................ 错误!未定义书签。

2设计目的 ............................................................ 错误!未定义书签。

3设计任务 ............................................................ 错误!未定义书签。

4设计内容 ............................................................ 错误!未定义书签。

需求分析 ........................................................... 错误!未定义书签。

程序所能达到的功能 ................................. 错误!未定义书签。

输入的形式和输入值的范围...................... 错误!未定义书签。

输出的形式................................................. 错误!未定义书签。

测试数据..................................................... 错误!未定义书签。

总体设计 ........................................................... 错误!未定义书签。

本程序中用到的所有抽象数据类型的定义 ..... 错误!未定义书签。

课题_编制一个一元稀疏多项式基本运算的程序

课题_编制一个一元稀疏多项式基本运算的程序

题目:编制一个一元稀疏多项式基本运算的程序班级:计算机02(8)姓名:学号:04完成日期:2004.7.6一、需求分析1.在通常的应用中,多项式的次数可能很高且变化很大,使得顺序存储结构的最大长度很难确定。

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

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

3.输出形式为类数学表达式,例如多项式: 2x+5x^8-3.1x^11; 指数升序排列。

4.测试数据(附后) 。

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

6.程序执行的命令为:1)一多项式求值; 2) 一元多项式加法; 3)一元多项式减法;4)一元多项式乘法; 5) 一元多项式求导; 6)退出二、概要设计1.抽象数据类型一元多项式的定义如下:ADT Polynpial{数据对象:D={a i|a i∈TermSet,i=1,2,…,n,n≥0}数据关系:R1={<a i-1,a i>|a i-1∈D,i=2,…,n}基本操作:InitPolyn( polynomail &P)操作结果:构造一个多项式,创建头结点.MakeNode( polynomail &pp,float Ncoef,int Nexpn)初始条件:一元多项式P已存在.操作结果:创建一个结点.CreatPolyn( polynomail &P,int m)初始条件:一元多项式P已存在.操作结果:输入m项的系数和指数,建立表示一元多项式的有序链表P.ClearPolyn( polynomail &P)初始条件:一元多项式P已存在.操作结果:将单链表清空,并释放原链表的结点空间.DestroyPolyn( polynomail &P)初始条件:一元多项式P已存在..操作结果:销毁一元多项式P.PrintPolyn( polynomail P)初始条件:一元多项式P已存在.操作结果:打印输出一元多项式PPolynLength( polynomail P)初始条件:一元多项式P已存在.操作结果:返回一元多项式P中的项数MergePolynCoef(polynomail &Pn)初始条件:一元多项式Pn已存在.操作结果:在序链表中,合并同类项SortPolyn(polynomail &Pn)初始条件:一元多项式Pn已存在.操作结果:根据链表的expn指数域,对链表进行升序排序DelZeroNode(polynomail &Pn)初始条件:一元多项式Pn已存在.操作结果:释放无用结点,即系数为0项AddPolyn( polynomail Pa,polynomail Pb,polynomail &Pc) 初始条件:一元多项式Pa,Pb和Pc已存在.操作结果:完成多项式相加运算,即:Pc=Pa+PbSubtractPolyn( polynomail Pa,polynomail Pb,polynomail &Pc) 初始条件:一元多项式Pa,Pb和Pc已存在.操作结果:完成多项式相减运算,即:Pc=Pa-PbMultiplyPolyn( polynomail Pa,polynomail Pb,polynomail &Pc) 初始条件:一元多项式Pa,Pb和Pc已存在.操作结果:完成多项式相乘运算,即:Pc=Pa×Pbvoid Difference( polynomail &pa)初始条件:一元多项式pa已存在.操作结果:求多项式的导函数Evaluate(polynomail pn, float x)初始条件:一元多项式pn已存在.操作结果:求多项式的值}ADT Polynpial2.主程序:void main( ){初始化;do {接受命令;选择处理命令;}while(命令!=“退出”)}3.本程序只有两三个模块,调用关系简单.三、详细设计1.元素类型、结点类型和指针类型typedef int status;typedef struct NodeType{float coef; //系数int expn; //指数struct NodeType *next;} NodeType, *LinkType; //结点类型,指针类型typedef LinkType polynomail; //用带头结点的有序链表表示多项式2.基本操作的函数有序链表的基本操作设置如下:void InitPolyn( polynomail &P);//构造一个多项式status MakeNode( polynomail &pp,float Ncoef,int Nexpn);//创建一个结点void CreatPolyn( polynomail &P,int m);//输入m项的系数和指数,建立表示一元多项式的有序链表P void ClearPolyn( polynomail &P);//将单链表清空,并释放原链表的结点空间void DestroyPolyn( polynomail &P);//销毁一元多项式Pvoid PrintPolyn( polynomail P);//打印输出一元多项式Pint PolynLength( polynomail P);//返回一元多项式P中的项数void MergePolynCoef(polynomail &Pn);//在序链表中,合并同类项void SortPolyn(polynomail &Pn);//根据链表的expn指数域,对链表进行升序排序void DelZeroNode(polynomail &Pn);//释放无用结点,即系数为0项void AddPolyn( polynomail Pa,polynomail Pb,polynomail &Pc);//完成多项式相加运算,即:Pc=Pa+Pbvoid SubtractPolyn( polynomail Pa,polynomail Pb,polynomail &Pc);//完成多项式相减运算,即:Pc=Pa-Pbvoid MultiplyPolyn( polynomail Pa,polynomail Pb,polynomail &Pc);//完成多项式相乘运算,即:Pc=Pa×Pbvoid Difference( polynomail &pa);//求多项式的导函数float Evaluate(polynomail pn, float x);//求多项式的值其中部分操作的算法如下void InitPolyn( polynomail &P)//构造一个多项式{ P=(NodeType *)malloc(sizeof(NodeType));P->coef=0;P->expn=0;P->next=NULL; //初始化带头结点的单链表}// InitPolynvoid ClearPolyn( polynomail &P)//将单链表清空,并释放原链表的结点空间{ LinkType q; q=P->next;while(q!=NULL) //释放原链表的结点空间{P->next=q->next;free(q);q=P->next;}}// ClearPolynvoid DestroyPolyn( polynomail &P)//销毁一元多项式P{LinkType q=P;while(q!=NULL){q=P->next;free(P);}//释放所有结点空间}// DestroyPolynvoid SortPolyn(polynomail &Pn)//根据链表的expn指数域,对链表进行升序排序{ MergePolynCoef(Pn);//先合并同类项LinkType p,q,r;q=Pn->next;Pn->next=NULL;while(q!=NULL) //插入法排序{ p=Pn;while(p->next!=NULL&&p->next->expn<q->expn)p=p->next;r=q->next; q->next=p->next; p->next=q; q=r;}}// SortPolynvoid MergePolynCoef(polynomail &Pn)//在序链表中,合并同类项{ LinkType p,p1,p2;p=Pn->next;while(p!=NULL){p1=p;p2=p->next;while(p2!=NULL) //合并指数相同项{ if(p->expn==p2->expn){p->coef+=p2->coef; p1->next=p2->next; free(p2);p2=p1->next;}else {p1=p2;p2=p1->next;}}p=p->next;}DelZeroNode(Pn);//删除合并后系数为0的结点}//MergePolynstatus MakeNode( polynomail &pp,float Ncoef,int Nexpn)//创建一个结点{ if (!(pp=(LinkType)malloc(sizeof(NodeType)))){cout<<"Error, the memory is overflow!"<<endl;return FALSE;}pp->coef=Ncoef; pp->expn=Nexpn; pp->next=NULL;return TRUE;}// MakeNodevoid CreatPolyn( polynomail &P,int m)//输入m项的系数和指数,建立表示一元多项式的有序链表P { float fcoef;int fexpn;NodeType *s,*q;q=P;//if(m==0)cout<<"空表!";for(int i=1;i<=m;i++){ cout<<"第"<<i<<"项式"<<endl;cout<<"系数,指数:";cin>>fcoef>>fexpn;s=(NodeType *)malloc(sizeof(NodeType));s->coef=fcoef;s->expn=fexpn;s->next=NULL;q->next=s;q=s;q->next=NULL;}MergePolynCoef(P); //合并指数相同项DelZeroNode(P); //删除系数为0的结点SortPolyn(P); //按指数域,对链表进行升序排序}// CreatPolynvoid Difference(polynomail &pa)// 稀疏多项式pa 以链表作存储结构,// 将此链表修改成它的导函数,并释放无用结点{ LinkType p,q; p=pa->next; q=pa;while(p!=NULL){ if(p->expn==0) {q->next=p->next;free(p);p=q->next;}//常数项,导数为零,释放结点else { p->coef=p->coef*p->expn; //系数=原系数* 指数(p->expn )--; q=q->next; p=p->next;//指数减1}}}// Differencefloat Evaluate(polynomail pn, float x)//求多项式的值{ LinkType p; p=pn->next;float result=0;while(p!=NULL){ result+=(p->coef)*(float)pow(x,p->expn); //pow函数求x的n次方p=p->next;}return result;}// Evaluatevoid AddPolyn(polynomail Pa,polynomail Pb,polynomail &Pc)//完成多项式相加运算,即:Pc=Pa+Pb{ float x;LinkType p,q,r;NodeType *s;p=Pa->next;q=Pb->next;r=Pc;while(p!=NULL&&q!=NULL){ if(p->expn==q->expn)//指数相同{ x=p->coef+q->coef ;if(x!=0) //指数相同,若系数相加不等于0,插入表中{s=(NodeType *)malloc(sizeof(NodeType));s->coef=x;s->expn=q->expn;s->next=NULL;r->next=s;r=r->next;}p=p->next;q=q->next;}else if(q->expn<p->expn) //指数小的插入表中{ s=(NodeType *)malloc(sizeof(NodeType));s->coef=q->coef;s->expn=q->expn;s->next=NULL;r->next=s;r=r->next; q=q->next;}else { s=(NodeType *)malloc(sizeof(NodeType));s->coef=p->coef;s->expn=p->expn;s->next=NULL;r->next=s;r=r->next; p=p->next;}}//加入余下的多项式while(p!=NULL){ s=(NodeType *)malloc(sizeof(NodeType));s->coef=p->coef;s->expn=p->expn;s->next=NULL;r->next=s;r=r->next; p=p->next;}while(q!=NULL){ s=(NodeType *)malloc(sizeof(NodeType));s->coef=q->coef;s->expn=q->expn;s->next=NULL;r->next=s;r=r->next; q=q->next;}}// AddPolyvoid SubtractPolyn( polynomail Pa,polynomail Pb,polynomail &Pc) //完成多项式相减运算,即:Pc=Pa-Pb{ float x;LinkType p,q,r;NodeType *s;p=Pa->next;q=Pb->next;r=Pc;while(p!=NULL&&q!=NULL){ if(p->expn==q->expn)//指数相同{ x=p->coef-q->coef;if(x!=0) //指数相同,若系数相减不等于0,插入表中{s=(NodeType *)malloc(sizeof(NodeType));s->coef=x;s->expn=q->expn;s->next=NULL;r->next=s;r=r->next;}p=p->next;q=q->next;}else if(q->expn<p->expn) //指数小的插入表中{ s=(NodeType *)malloc(sizeof(NodeType));s->coef=-q->coef; //减数的系数变为相反数s->expn=q->expn;s->next=NULL;r->next=s;r=r->next; q=q->next;}else{ s=(NodeType *)malloc(sizeof(NodeType));s->coef=p->coef;s->expn=p->expn;s->next=NULL;r->next=s;r=r->next; p=p->next;}}//加入余下的多项式,减数的系数变为相反数while(p!=NULL){ s=(NodeType *)malloc(sizeof(NodeType));s->coef=p->coef;s->expn=p->expn;s->next=NULL;r->next=s;r=r->next; p=p->next;}while(q!=NULL){ s=(NodeType *)malloc(sizeof(NodeType));s->coef=-q->coef;s->expn=q->expn;s->next=NULL;r->next=s;r=r->next; q=q->next;}}// SubtractPolynvoid MultiplyPolyn( polynomail Pa,polynomail Pb,polynomail &Pc) //完成多项式相乘运算,即:Pc=Pa×Pb{ LinkType p,q,r;NodeType *s; p=Pa->next; r=Pc;while(p!=NULL){q=Pb->next;while(q!=NULL){ s=(NodeType *)malloc(sizeof(NodeType));s->coef=p->coef*q->coef; s->expn=p->expn+q->expn;s->next=NULL;r->next=s;r=r->next; q=q->next;}p=p->next;}MergePolynCoef(Pc);//合并指数相同项DelZeroNode(Pc); //删除系数为0的结点SortPolyn(Pc); //按指数域,对链表进行升序排序}// MultiplyPolyn3.主函数void main(){inp: while(1){system("cls");int choice;cout<<endl<<" 请选择操作(0-5):";cin>>choice;cout<<endl;switch(choice){ case 1: cout<<"求多项式A的值"<<endl;Evaluate(pa, x);case 2: cout<<"多项式加法C=A+B"<<endl;AddPolyn(pa,pb,pc);case 3: cout<<"多项式减法C=A-B"<<endl;SubtractPolyn(pa,pb,pc);case 4: cout<<"多项式乘法C=A×B"<<endl;MultiplyPolyn(pa,pb,pc);case 5: cout<<"求多项式A的导数"<<endl;Difference(pa);case 0:cout<<"谢谢使用!再见!"<<endl<<endl;return ;default:cout<<"错误命令!"<<endl;cout<<"Press any key to continue!"<<endl;getche();system("cls");goto inp;}//switch}//whlie(1)}4.函数的调用关系图main| | |InitPolyn| CreatPolyn______________________ ____ |________________________________| | | | | Evaluate AddPolyn SubtractPolyn MultiplyPolyn Difference ___________________|_______________ | | |MergePolynCoe---------- DelZeroNode SortPolyn四、调试分析1.刚开始时,忽略了一些变量参数的标识"&",使调试程序时费了不少功夫。

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

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

程序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");}[实验结果]。

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

//***************************************************************************** //***********************一元稀疏多项式的运算********************************** //***************************************************************************** //库函数头文件包含#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define OVERFLOW -1#define OK 1//***************************************************************************** //顺序表结构的定义typedef struct PolyNode {float coef;//多项式的系数int expn;//多项式的指数struct PolyNode *next;}PolyNode , *PolyList ;//***************************************************************************** void Insert(PolyNode * p, PolyNode* h)//多项式的初始化{if(p->coef==0)free(p); //系数为0的话释放结点else{PolyNode * q1;PolyNode * 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;}}}//**************************************************************************** //建立一个头指针为head、项数为m的一元多项式PolyList Createlist(PolyNode * head){int i;int m;PolyNode * p;p=head=(PolyNode *)malloc(sizeof(struct PolyNode ));head->next=NULL;printf("请输入多项式的项数m:");scanf("%d",&m);getchar();printf("\n");for(i=1;i<=m;i++){p=(PolyNode *)malloc(sizeof(struct PolyNode )); //建立新结点以接收数据printf("请输入第%d项的系数与指数: ",i);// printf(“\n”);scanf("%f",&p->coef);scanf("%d",&p->expn);getchar();Insert(p,head); //调用Insert函数插入结点}return head;}//**************************************************************************** //输出多项式链表void Outprintlist(PolyNode * head){PolyNode * cur=head->next->next;printf("%fx^%d",head->next->coef,head->next->expn);while(cur){if((cur->coef)>0){printf( "+");if((cur->expn!=0) && (cur->expn!=1))printf("%fx^%d",cur->coef,cur->expn);else if(cur->expn==0)printf("%f",cur->coef);elseprintf("%fx",cur->coef);}if(cur->coef<0){if((cur->expn!=0) && (cur->expn!=1))printf("%fx^%d",cur->coef,cur->expn);elseif(cur->expn==0)printf("%f",cur->coef);elseprintf("%fx",cur->coef);}cur=cur->next;}printf("\n");}//**************************************************************************** //多项式的调整int Compare(PolyNode * q1,PolyNode * q2){if(q1 && q2){if(!q1||q1->expn>q2->expn)return 1;elseif(!q1||q1->expn<q2->expn)return -1;elsereturn 0;}elseif(!q1&&q2)return -1; //q1多项式已空,但q2多项式非空elsereturn 1; //q2多项式已空,但q1多项式非空}//**************************************************************************** //多项式的加法A+BPolyList Add(PolyNode * q1,PolyNode * q2){q1=q1->next;q2=q2->next;PolyNode * head,* tail,* temp;tail=(PolyNode *)malloc(sizeof(PolyNode ));if(!tail) exit(OVERFLOW);tail->next=NULL;head=tail;while(q1||q2){temp=(PolyNode *)malloc(sizeof(PolyNode ));switch(Compare(q1,q2)){case 1:{temp->coef=q1->coef;temp->expn=q1->expn;q1=q1->next;break;}case 0:{temp->coef=(q1->coef)+(q2->coef);temp->expn=q1->expn;q1=q1->next;q2=q2->next;break;}case -1:{temp->coef=q2->coef;temp->expn=q2->expn;q2=q2->next;break;}}if(temp->coef==0)free(temp);else{temp->next=tail->next;tail->next=temp;tail=temp;}}return head;}//****************************************************************************//多项式的减法A-BPolyList Sub(PolyNode* q1,PolyNode* q2){PolyNode * s=q2;PolyNode *p=q2->next;PolyNode * s1;if(s==NULL){printf("这个多项式空的!\n");return NULL;}else{while(p) //系数取反{p->coef*=-1;p=p->next;}}s1=Add(q1,s);for(p=s->next;p;p=p->next) //恢复q2的系数p->coef*=-1;return s1;}//**************************************************************************** //多项式的乘法ABPolyList Mul(PolyNode *head1,PolyNode *head2)//多项式相乘{PolyNode *h,*s,*q1,*q2;q1=head1->next;//q1和q2用来遍历多项式head1和head2q2=head2->next;h=(PolyNode *)malloc(sizeof(PolyNode));//建立头结点if(!h) exit(OVERFLOW);h->next=NULL;while(q1) //利用两个循环让多项式pa和pb的任意两项相乘{for(q2=head2->next;q2;q2=q2->next){s=(PolyNode *)malloc(sizeof(PolyNode));if(!s) exit(OVERFLOW);s->next=NULL;s->coef=q1->coef*q2->coef; //系数相乘s->expn=q1->expn+q2->expn; //指数相乘Insert(s,h); //调用Insert函数以合并指数相同的项,并按降幂排序}q1=q1->next;}return h;}//**************************************************************************** //多项式的微分PolyList Qiudao(PolyNode* head){PolyNode *p;p=head->next ;while(p!=NULL){if(p->coef!=0) //系数不为零时进行求导{p->coef=p->coef*p->expn; //求导后系数为原系数乘以指数p->expn=p->expn-1; //指数为原指数减一}elsep->coef=0;p=p->next;}return head;}//*************************************************************************** //多项式的积分PolyList Jifen(PolyNode* head){PolyNode *q;q=head->next ;while(q!=NULL){if(q->coef!=0) //系数不为零时进行积分{q->expn=q->expn+1; //指数为原指数加一q->coef=q->coef/q->expn; //积分后系数为原系数除以积分后的指数}elseq->coef=0;q=q->next;}return head;}//**************************************************************************** //输入x值,计算并返回多项式的值float Valuelpolyn(PolyNode * head,float x){PolyNode * p;int i;float sum=0,t;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;}//*************************************************************************** int main(){int flag=0,g=0;float x;PolyNode * A=NULL, * B=NULL, * pc,* pd=NULL;//定义各式的头指针,pa与pb在使用前赋初值NULLprintf("\n");printf("建立多项式A\n");printf("\n");A=Createlist(A);//建立多项式Aprintf("建立多项式B\n");printf("\n");B=Createlist(B);//建立多项式B//输出菜单printf("******************************\n");printf("*******数据结构课程设计*******\n");printf("*******班级:电10—2 *********\n");printf("*******姓名:*********\n");printf("*******学号: 201001051004******\n");printf("*****一元稀疏多项式的运算*****\n");printf("******************************\n");printf("请选择操作:\n");printf("【0】.退出\n");printf("【1】.两个一元多项式的加法运算\n");printf("【2】.两个一元多项式的减法运算\n");printf("【3】.两个一元多项式的乘法运算\n");printf("【4】.两个一元多项式的微分运算\n");printf("【5】.两个一元多项式的积分运算\n");printf("【6】.两个一元多项式的代值运算\n");while(g==0){printf("请选择操作:\n");scanf("%d",&flag);getchar();switch(flag){case 0:return 0;break;case 1:{printf("你选择的操作是多项式的加法运算:\n");printf("请输入多项式A:\n");Outprintlist(A);printf("请输入多项式B:\n");Outprintlist(B);pc=Add(A,B);printf("多项式A+B:\n");Outprintlist(pc);// continue;break;}case 2:{printf("你选择的操作是多项式的减法运算:\n");printf("请输入多项式A:\n");Outprintlist(A);printf("请输入多项式B:\n");Outprintlist(B);pc=Sub(A,B);printf("多项式A-B:\n");Outprintlist(pc);//continue;break;case 3:{printf("你选择的操作是多项式的乘法运算:\n");printf("请输入多项式A:\n");Outprintlist(A);printf("请输入多项式B:\n");Outprintlist(B);pc=Mul(A,B);printf("多项式AB: \n");Outprintlist(pc);break;}case 4:{printf("你选择的操作是多项式的微分运算:\n");printf("请输入多项式A:\n");Outprintlist(A);printf("请输入多项式B:\n");Outprintlist(B);pc=Qiudao(A);printf("多项式A求导后为: \n");Outprintlist(A);pd=Qiudao(B);printf("多项式B求导后为: \n");Outprintlist(B);break;}case 5:{printf("你选择的操作是多项式的积分运算:\n");printf("请输入多项式A:\n");Outprintlist(A);printf("请输入多项式B:\n");Outprintlist(B);pc=Jifen(A);printf("多项式A积分后为: \n");Outprintlist(A);pd=Jifen(B);printf("多项式B积分后为: \n");Outprintlist(B);break;}case 6:printf("输入x的值:x= ");scanf("%f",&x);getchar();printf("请输入多项式A:\n");Outprintlist(A);printf("请输入多项式B:\n");Outprintlist(B);printf("输入x的值后多项式A的值是: ");printf("%f", Valuelpolyn(A,x));printf("\n");printf("输入x的值后多项式B的值是: ");printf("%f", Valuelpolyn(B,x));printf("\n");break;}}if(flag==0){break;printf("\n");}if(flag<0 || flag>6){int i=0;printf("\n");printf("!!!!!你输入的操作有错噢!!!!!\n");printf("****************************\n");printf("*********重新输入******----1\n");printf("********不重新输入*****----0\n");printf("****************************\n");printf("********请选择:*************\n");scanf("%d",&i);getchar();printf("\n");if(i==1)g=0;elseg=1;printf("\n");}}return 0;}。

相关文档
最新文档