数据结构实验,多项式计算器
数据结构中实现一元多项式简单计算

数据结构中实现一元多项式简单计算:设计一个一元多项式简单的计算器。
基本要求:一元多项式简单计算器的基本功能为:(1)输入并建立多项式;(2)输出多项式;(3)两个多项式相加,建立并输出和多项式;(4)两个多项式相减,建立并输出差多项式;#include<stdio.h>#include<malloc.h>#define MAX 20 //多项式最多项数typedef struct//定义存放多项式的数组类型{float coef; //系数int exp; //指数} PolyArray[MAX];typedef struct pnode//定义单链表结点类型{float coef; //系数int exp; //指数struct pnode *next;} PolyNode;void DispPoly(PolyNode *L) //输出多项式{PolyNode *p=L->next;while (p!=NULL){printf("%gX^%d ",p->coef,p->exp);p=p->next;}printf("\n");}void CreateListR(PolyNode *&L,PolyArray a,int n) //尾插法建表{PolyNode *s,*r;int i;L=(PolyNode *)malloc(sizeof(PolyNode)); //创建头结点L->next=NULL;r=L; //r始终指向终端结点,开始时指向头结点for (i=0;i<n;i++){s=(PolyNode *)malloc(sizeof(PolyNode));//创建新结点s->coef=a[i].coef;s->exp=a[i].exp;r->next=s; //将*s插入*r之后r=s;}r->next=NULL; //终端结点next域置为NULL}void Sort(PolyNode *&head) //按exp域递减排序{PolyNode *p=head->next,*q,*r;if (p!=NULL) //若原单链表中有一个或以上的数据结点{r=p->next; //r保存*p结点后继结点的指针p->next=NULL; //构造只含一个数据结点的有序表p=r;while (p!=NULL){r=p->next; //r保存*p结点后继结点的指针q=head;while (q->next!=NULL && q->next->exp>p->exp)q=q->next; //在有序表中找插入*p的前驱结点*qp->next=q->next; //将*p插入到*q之后q->next=p;p=r;}}}void Add(PolyNode *ha,PolyNode *hb,PolyNode *&hc) //求两有序集合的并{PolyNode *pa=ha->next,*pb=hb->next,*s,*tc;float c;hc=(PolyNode *)malloc(sizeof(PolyNode)); //创建头结点tc=hc;while (pa!=NULL && pb!=NULL){if (pa->exp>pb->exp){s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=pa->coef;tc->next=s;tc=s;pa=pa->next;}else if (pa->exp<pb->exp){s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pb->exp;s->coef=pb->coef;tc->next=s;tc=s;pb=pb->next;}else//pa->exp=pb->exp{c=pa->coef+pb->coef;if (c!=0) //系数之和不为时创建新结点{s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=c;tc->next=s;tc=s;}pa=pa->next;pb=pb->next;}}if (pb!=NULL) pa=pb; //复制余下的结点while (pa!=NULL){s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=pa->coef;tc->next=s;tc=s;pa=pa->next;}tc->next=NULL;}void Cut(PolyNode *ha,PolyNode *hb,PolyNode *&hd) //求两有序集合的并{PolyNode *pa=ha->next,*pb=hb->next,*s,*td;float d;hd=(PolyNode *)malloc(sizeof(PolyNode)); //创建头结点td=hd;while (pa!=NULL && pb!=NULL){if (pa->exp>pb->exp){s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=pa->coef;td->next=s;td=s;pa=pa->next;}else if (pa->exp<pb->exp){s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pb->exp;s->coef=-(pb->coef);td->next=s;td=s;pb=pb->next;}else//pa->exp=pb->exp{d=pa->coef-pb->coef;if (d!=0) //系数之和不为时创建新结点{s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=d;td->next=s;td=s;}pa=pa->next;pb=pb->next;}}if (pb!=NULL) pa=pb; //复制余下的结点while (pa!=NULL){s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=pa->coef;td->next=s;td=s;pa=pa->next;}td->next=NULL;}void main(){PolyNode *ha,*hb,*hc,*hd,*he;PolyArray a={{1.2,0},{2.5,1},{3.2,3},{-2.5,5}};PolyArray b={{-1.2,0},{2.5,1},{3.2,3},{2.5,5},{5.4,10}};CreateListR(ha,a,4);CreateListR(hb,b,5);printf("原多项式A: ");DispPoly(ha);printf("原多项式B: ");DispPoly(hb);Sort(ha);Sort(hb);printf("有序多项式A: ");DispPoly(ha);printf("有序多项式B: ");DispPoly(hb);Add(ha,hb,hc);printf("多项式相加: ");DispPoly(hc);Cut(ha,hb,hd);printf("多项式相减: ");DispPoly(hd); }。
数据结构课程设计一元稀疏多项式计算器报告代码

数据结构课程设计设计题目:一元稀疏多项式计算器专业______________________ 班级______________________ 学号______________________ 姓名______________________ 指导教师___________________2010 年12 月20 H目录一、课程题目 (1)二、需求分析 (1)三、测试数据 (2)四、概要设计 (2)五、调用关系图 (3)六、程序代码 (3)七、测试结果 (11)八、心得体会及总结 (12)数据结构课程设计一、课程题冃一元稀诡多项式计算器二、需求分析1、一元稀疏多项式简单计算器的功能是:1.1输入并建立多项式;1.2输出多项式,输出形式为整数序列:n, cl,el,c2,e2, ......................... c n, en,其中ii是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序排列;1.3求多项式a、b的导函数;1.4计算多项式在x处的值;1.5多项式"和b和加,建立多项认a+b;1.6多项式a和b相减,建立多项式a-b。
2、设计思路:2.1定义线性表的动态分配顺序存储结构;2.2建立多项式存储结构,定义指针*next2.3利用链表实现队列的构造.毎次输入一项的系数和指数,町以输出构造的一元多项式2.4演示程用以用户和计舜机的对话方式执行,即在计舜机终站上显示“提示信息” Z后,由川户化键盘丄输入演示程序小规运的运行•命令;报后根据相应的输入数据〔滤去输入中的4法字符)建立的多项式以及多项式相加的运行结果在屏幕上显示。
多项式显示的格式为:clx*el+c2x*e2+ — +cnx"en3、设计思路分析要解决多项式相加,必须要冇多项式,所以必须首先建立两个多项式,在这电采用链表的方式存储琏表,所以我将结点结构体定义为运川尾插法建立两条单链表,以巾•链表polyn p和polyn h分别表示两个一元多项式a和b, a+b的求和运算等同于单链表的插入问题(将单链表polyn P 中的结点插入到单链表polyn h中),因此“和多项式”中的结点无须另生成。
云南大学软件学院数据结构实验二实验报告——多项式计算器

云南大学软件学院数据结构实验报告2010秋季学期(本实验项目方案受“教育部人才培养模式创新实验区(X3108005)”项目资助)学号:姓名:专业:指导老师:实验难度A□B□ C □承担任务(难度为C时填写)指导教师评分(签名)【实验题目】实验2. 线性表及其应用【问题描述】用C或C++语言设计并实现一个一元稀疏多项式的简单计算器。
【基本要求】一元稀疏多项式简单计算器的基本功能是:1、输入并建立多项式2、输出多项式,序列按指数降序排列3、多项式A(x)和B(x)相加,并建立多项式A(x)+B(x)4、多项式A(x)和B(x)相减,并建立多项式A(x)-B(x)5、给定 x 的值,计算多项式6、多项式A(x)和B(x)相乘,建立多项式A(x)*B(x) (* 选做,作为难度B的操作)【CDIO项目要求】1、有完整的CDIO四个阶段描述2、有友好美观的操作界面3、有软件使用说明或帮助文档4、项目成员分工明确,团结协作【实现提示】一、【实验构思(Conceive)】(10%)本实验通过C语言实现了多项式加法、减法、乘法、多项式求导、多项式积分的功能。
利用了冒泡排序的算法作为排序的核心算法。
运用了高等数学中多项式的求导积分的知识。
二、【实验设计(Design)】(15%)本程序定义了抽象数据结构listnode,用于存储多项式的系数和指数并存储指向下一个listnode的指针来构成链表。
本程序包含如下*个函数:Main函数:调用input函数—>调用bubble_sort函数—>调用operplus函数—>调用oper_minus函数—>调用oper_mul函数—>调用oper_dy函数—>调用oper_jifen 函数。
Oper_plus函数:将两个链表的相应项系数相加,指数不同项不操作,存入新链表,再调用排序算法,使之为降序排列。
Oper_minus函数:将两个链表的相应项系数相减,指数不同项不操作,存入新链表,再调用排序算法,使之为降序排列。
数据结构计算器实验报告

数据结构计算器实验报告1. 引言数据结构是计算机科学的基础,它提供了一种组织和存储数据的方式,以便能够高效地访问和操作这些数据。
计算器是一种常见的应用程序,它可以执行各种数学运算。
本实验的主要目的是设计和实现一个简单的数据结构计算器,用于实现基本的四则运算功能。
2. 设计思路在设计数据结构计算器时,我们需要考虑以下几个方面的问题:2.1 数据结构选择为了实现四则运算功能,我们首先需要选择合适的数据结构来存储和操作数学表达式。
在本实验中,我们选择使用栈作为数据结构,因为栈具有后进先出的特性,非常适合处理运算符和操作数的顺序。
2.2 表达式解析在计算器中,我们需要将用户输入的数学表达式解析成运算符和操作数,以便进行计算。
为了实现表达式解析功能,我们可以使用字符串的分割和转换操作来提取运算符和操作数,并将它们存储到栈中。
2.3 运算符优先级在进行四则运算时,运算符的优先级非常重要。
我们需要确保高优先级的运算符先于低优先级的运算符进行计算。
为了实现这一功能,我们可以使用栈来存储运算符,并在遇到运算符时进行比较和计算。
2.4 计算结果输出最后,我们需要将计算结果输出给用户。
为了实现这一功能,我们可以使用一个变量来存储计算结果,并在计算完成后将结果输出到屏幕上。
3. 实现步骤基于上述设计思路,我们可以按照以下步骤来实现数据结构计算器:3.1 定义栈数据结构首先,我们需要定义一个栈数据结构来存储运算符和操作数。
栈可以使用数组或链表来实现,具体选择取决于实际需求。
3.2 解析数学表达式接下来,我们需要编写代码来解析用户输入的数学表达式。
我们可以使用字符串的分割和转换操作来提取运算符和操作数,并将它们存储到栈中。
3.3 实现运算符优先级比较和计算在解析数学表达式的过程中,我们需要实现运算符的优先级比较和计算功能。
每当遇到一个运算符时,我们可以将其与栈顶的运算符进行比较,如果栈顶的运算符优先级较高,则可以进行相应的计算。
数据结构课程设计___一元稀疏多项式计算器(报告 代码)__完整版

数据结构课程设计一、课程题目一元稀疏多项式计算器二、需求分析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.实验目的本次实验的目的是使用C语言实现一个多项式计算器,分析其计算性能,并对计算结果进行验证。
2.实验内容(1)多项式计算器的原理多项式计算器是指利用多项式的定义,结合多项式的加法、减法、乘法、除法等运算,实现多项式进行计算的一类计算器。
多项式定义:当n>=0时,若存在一个多项式P(x)=a(0)+(x)+a(1)(x^1)+...+a(n)(x^n),且其中有一个a(i)!=0,则称多项式P(x)为a(0)+(x)+a(1)(x^1)+...+a(n)(x^n)。
其中a(i)称为多项式P(x)的系数,并且n+1称为多项式P(x)的次数。
多项式运算:(1)多项式加法:若存在多项式A(x)和B(x),则A(x)+B(x)的值为:A(x)+B(x)=a(0)+(x)+a(1)(x^1)+...+a(i)(x^i)+...+a(n)(x^n)+b(0)+(x)+b(1)(x^1)+...+b(i)(x^i)+...+b(n)(x^n)=c(0)+(x)+c(1)(x^1)+. ..+c(i)(x^i)+...+c(n)(x^n)其中c(i)=(a(i)+b(i))(0<=i<=n),即多项式A(x)+B(x)=C(x),其中C(x)的次数=max{A(x)的次数,B(x)的次数}。
(2)多项式减法:若存在多项式A(x)和B(x),则A(x)-B(x)的值为:A(x)-B(x)=a(0)+(x)+a(1)(x^1)+...+a(i)(x^i)+...+a(n)(x^n)-b(0)+(x)-b(1)(x^1)-...-b(i)(x^i)-...-b(n)(x^n)=c(0)+(x)+c(1)(x^1)+...+c(i)(x^i)+...+c(n)(x^n)其中c(i)=(a(i)-b(i))(0<=i<=n),即多项式A(x)-x)=C(x),其中C(x)的次数=max{A(x)的次数。
数据结构课程设计_一元稀疏多项式计算器

数据结构实验报告——一元稀疏多项式计算器安子烨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("未找到该项。
数据结构课程设计___一元稀疏多项式计算器(报告+代码)__完整版.

数据结构课程设计系别电子信息系专业计算机科学与技术班级学号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后移。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验题目:多项式运算器实验内容:1、熟悉编程环境2、用链式存储结构实现稀疏一元多项式运算器实验目的和要求:1、通过本实验,掌握VC++6.0的基本使用,包括源程序的输入,编译运行及调试。
调试的目的是找程序的运行错误,通过DEBUG菜单设置断点实现。
2、用链式存储结构实现一元多项式的运算。
熟练掌握指针和链表的基本操作,利用菜单进行功能选择。
功能基本要求:创建、显示、求和、求差、求值、销毁、清空、修改实验算法:1、数据结构描述:输入的稀疏每一个多项式用一个链表存储,链表的每一个节点存储多项式的一个非零项。
定义为LNode型结构体,其中保存该项的系数和指数。
主函数中用一个数组存储每一个多项式的第一项的头指针以调用多项式。
2、函数和算法描述:主函数main定义LNode*数组a[]存储每一个多项式头节点的地址,并构建菜单以选择调用函数进行多项式的操作,对多项式进行操作的函数返回新改动的多项式头结点地址。
Createpolyn函数用以创建一个多项式,在用户输入结束指令之前,不断的申请空间,构建LNode型结点并加至构建的链表的表尾,输入结束指令之后,表尾设NULL并返回表头指针。
Printpolyn函数用以在屏幕上打印多项式,接收需要打印的多项式链表的头结点,构造循环体在表尾之前,不断以mx^n格式打印对应结点中的数据。
Copypolyn函数用以复制多项式,接收需要复制的多项式a和复制位置b 的指针,构造循环体,在a到表尾之前循环,在b对应的链表中构建新的结点,结点上的数据赋值为a中对应的值,返回b的头结点地址。
Addpolyn函数用以求两个已知多项式a、b的和存入c,先构建循环体,在a、b链表都未进行到表尾时,比较两个结点中的次数值,如果相同,将系数相加赋于c的当前结点,如果不同,将次数较小多项式y(a或b)的结点赋值给c当前结点,在将y链表向后推。
Subtract函数用以求两多项式的差,类似求和算法。
Value函数用以求一个多项式的值,接收x的值,构建循环体,在表尾之前循环以遍历多项式链表。
内置循环体,以次数n为限循环,求出x^n的值,乘以系数并将每一项的值叠加得值。
Destroypolyn函数用以销毁已有的多项式,将此多项式链表的空间FREE 掉,返回空指针。
Clearpolyn函数用以清空多项式,构建循环体,将多项式的各项的系数、指数置零。
3、时空分析:L= sizeof(struct LNode)一个含有N项的多项式占用的储存空间为NL+1主要函数的时间复杂度:(N项多项式)Createpolyn:NPrintpolyn:NCopypolyn:NAddpolyn:N1+N2实验结果:控制菜单:显示多项式:多项式求值:求和、求差、复制、销毁、清空也均能得到正常结果源代码:#include<stdio.h>#include <stdlib.h>#define N 20#define L sizeof(struct LNode)struct LNode{int n;double m;struct LNode*next;};struct LNode* createpolyn (struct LNode*p){double i=1;int j,a=0;struct LNode*u;p=(struct LNode*)malloc(L);p->m=0;p->n=0;p->next=NULL;u=p;while(i!=0){printf("从低次到高次输入X的非零项的次数及系数:'0 0'表示结束:\n");scanf("%d %lf",&j,&i);if(i!=0){p->next=(struct LNode*)malloc(L);p=p->next;p->m=i;p->n=j;}};p->next=NULL;printf("completed!\n");return(u);}void printpolyn (struct LNode*p){p=p->next;while (p!=NULL){printf("+%lfX^%d\n",p->m,p->n);p=p->next;}//printf("NULL");}struct LNode* copypolyn (struct LNode*p,struct LNode*q){struct LNode* u;q=(struct LNode*)malloc(L);u=q;while (p->next!=NULL){q->m=p->m;q->n=p->n;p=p->next;q->next=(struct LNode*)malloc(L);q=q->next;}q->m=p->m;q->n=p->n;q->next=NULL;printf("completed!\n");return(u);}/*struct LNode* addpolyn (struct LNode*p,struct LNode*q,struct LNode*r) {struct LNode*u;r=(struct LNode*)malloc(L);u=r;while((q->next!=NULL)&&(p->next!=NULL)){if((q->n)>(p->n)){r->n=p->n;r->m=p->m;p=p->next;}else{if((q->n)==(p->n)){r->n=p->n;r->m=(p->m)+(q->m);p=p->next;q=q->next;}else{r->n=q->n;r->m=q->m;q=q->next;}}r->next=(struct LNode*)malloc(L);r=r->next;}if((q->next)==NULL){while((q->n>p->n)&&(p->next!=NULL)){ if((q->n)>(p->n)){r->n=p->n;r->m=p->m;p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;}}if((q->n)<=(p->n)){if((q->n)==(p->n)){r->n=p->n;r->m=(p->m)+(q->m);}else{r->n=q->n;r->m=q->m;}}if(p->next!=NULL){r->next=(struct LNode*)malloc(L);r=r->next;p=p->next;while(p->next!=NULL){r->n=p->n;r->m=p->m;r->next=(struct LNode*)malloc(L);r=r->next;p=p->next;}r->n=p->n;r->m=p->m;r->next=(struct LNode*)malloc(L);r->next=NULL;}else{r->next=(struct LNode*)malloc(L);r->next=NULL;}}else{ if((q->n)>(p->n)){r->n=p->n;r->m=p->m;}else{if((q->n)==(p->n)){r->n=p->n;r->m=(p->m)+(q->m);}while((q->n<p->n)&&q->next!=NULL){r->n=q->n;r->m=q->m;q=q->next;r->next=(struct LNode*)malloc(L);r=r->next;}}if(q->next!=NULL){r->next=(struct LNode*)malloc(L);r=r->next;q=q->next;while(q->next!=NULL){r->n=q->n;r->m=q->m;r->next=(struct LNode*)malloc(L);r=r->next;q=q->next;}r->n=q->n;r->m=p->m;r->next=(struct LNode*)malloc(L);r->next=NULL;}else{r->next=(struct LNode*)malloc(L);r->next=NULL;}}printf("completed!\n");return(u);}整理之前的ADDPOLYN函数*/struct LNode*addpolyn(struct LNode*p,struct LNode*q,struct LNode*r){struct LNode* u=NULL;if((q==NULL)||(p==NULL)){return(u);}r=(struct LNode*)malloc(L);u=r;while(((q->next)!=NULL)&&((p->next)!=NULL)){ if(q->n>p->n){r->n=p->n;r->m=p->m;p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;}if(q->n==p->n){r->n=p->n;r->m=p->m+q->m;q=q->next;p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;}if(q->n<p->n){r->n=q->n;r->m=q->m;q=q->next;r->next=(struct LNode*)malloc(L);r=r->next;}}if((q->next==NULL)&&(p->next==NULL)){ if(q->n>p->n){r->n=p->n;r->m=p->m;r->next=(struct LNode*)malloc(L);r=r->next;r->n=q->n;r->m=q->m;}if(q->n==p->n){r->n=p->n;r->m=p->m+q->m;}if(q->n<p->n){r->n=q->n;r->m=q->m;r->next=(struct LNode*)malloc(L);r=r->next;r->m=p->m;r->n=p->n;}}if((q->next==NULL)&&(p->next!=NULL)){ if(q->n<p->n){r->n=q->n;r->m=q->m;r->next=(struct LNode*)malloc(L);r=r->next;while(p->next!=NULL){r->n=p->n;r->m=p->m;p=p->next;r->next=(structLNode*)malloc(L);r=r->next;}r->n=p->n;r->m=p->m;}if(q->n==p->n){r->n=q->n;r->m=q->m+p->m;p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;while(p->next!=NULL){r->n=p->n;r->m=p->m;p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;}r->n=p->n;r->m=p->m;}if(q->n>p->n){while(p->n<q->n){r->n=p->n;r->m=p->m;p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;}if(q->n==p->n){r->n=q->n;r->m=q->m+p->m;p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;while(p->next!=NULL){r->n=p->n;r->m=p->m; p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;}r->n=p->n;r->m=p->m;}if(q->n<p->n){r->n=q->n;r->m=q->m;q=q->next;r->next=(struct LNode*)malloc(L);r=r->next; while(p->next!=NULL){r->n=p->n;r->m=p->m; p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;}r->n=p->n;r->m=p->m;}}}if((p->next==NULL)&&((q->next)!=NULL)){ if(p->n<q->n){r->n=p->n;r->m=p->m;r->next=(struct LNode*)malloc(L);r=r->next;while(q->next!=NULL){r->n=q->n;r->m=q->m;q=q->next;r->next=(struct LNode*)malloc(L);r=r->next;}r->n=q->n;r->m=q->m;}if((p->n)==(q->n)){r->n=p->n;r->m=p->m+q->m;q=q->next;r->next=(struct LNode*)malloc(L);r=r->next;while((q->next)!=NULL){r->n=q->n;r->m=q->m;r->next=(struct LNode*)malloc(L);r=r->next;q=q->next;}r->n=q->n;r->m=q->m;}if(p->n>q->n){while(q->n<p->n){r->n=q->n;r->m=q->m;q=q->next;r->next=(struct LNode*)malloc(L);r=r->next;}if(p->n==q->n){r->n=p->n;r->m=p->m+q->m;q=q->next;r->next=(struct LNode*)malloc(L);r=r->next;while(q->next!=NULL){r->n=q->n;r->m=q->m; q=q->next;r->next=(struct LNode*)malloc(L);r=r->next;}r->n=q->n;r->m=q->m;}if(q->n>p->n){r->n=p->n;r->m=p->m;r->next=(struct LNode*)malloc(L);r=r->next; while(q->next!=NULL){r->n=q->n;r->m=q->m; q=q->next;r->next=(struct LNode*)malloc(L);r=r->next;}r->n=q->n;r->m=q->m;}}}r->next=NULL;printf("completed!\n");return(u);}struct LNode*subtract(struct LNode*p,struct LNode*q,struct LNode*r){struct LNode* u=NULL;if((q==NULL)||(p==NULL)){return(u);}r=(struct LNode*)malloc(L);u=r;while(q->next!=NULL&&p->next!=NULL){ if(q->n>p->n){r->n=p->n;r->m=p->m;p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;}if(q->n==p->n){r->n=p->n;r->m=p->m-q->m;q=q->next;p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;}if(q->n<p->n){r->n=q->n;r->m=-q->m;q=q->next;r->next=(struct LNode*)malloc(L);r=r->next;}}if((q->next==NULL)&&(p->next==NULL)){ if(q->n>p->n){r->n=p->n;r->m=p->m;r->next=(struct LNode*)malloc(L);r=r->next;r->n=q->n;r->m=-q->m;}if(q->n==p->n){r->n=p->n;r->m=p->m-q->m;}if(q->n<p->n){r->n=q->n;r->m=-q->m;r->next=(struct LNode*)malloc(L);r=r->next;r->m=p->m;r->n=p->n;}}if((q->next==NULL)&&(p->next!=NULL)){ if(q->n<p->n){r->n=q->n;r->m=-q->m;r->next=(struct LNode*)malloc(L);r=r->next;while(p->next!=NULL){r->n=p->n;r->m=p->m;p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;}r->n=p->n;r->m=p->m;}if(q->n==p->n){r->n=q->n;r->m=-q->m+p->m;p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;while(p->next!=NULL){r->n=p->n;r->m=p->m;p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;}r->n=p->n;r->m=p->m;}if(q->n>p->n){while(p->n<q->n){r->n=p->n;r->m=p->m;p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;}if(q->n==p->n){r->n=q->n;r->m=-q->m+p->m;p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;while(p->next!=NULL){r->n=p->n;r->m=p->m; p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;}r->n=p->n;r->m=p->m;}if(q->n<p->n){r->n=q->n;r->m=-q->m;q=q->next;r->next=(struct LNode*)malloc(L);r=r->next; while(p->next!=NULL){r->n=p->n;r->m=p->m; p=p->next;r->next=(struct LNode*)malloc(L);r=r->next;}r->n=p->n;r->m=p->m;}}}if((p->next==NULL)&&(q->next!=NULL)){ if(p->n<q->n){r->n=p->n;r->m=p->m;r->next=(struct LNode*)malloc(L);r=r->next;while(q->next!=NULL){r->n=q->n;r->m=-q->m;q=q->next;r->next=(struct LNode*)malloc(L);r=r->next;}r->n=q->n;r->m=-q->m;}if(p->n==q->n){r->n=p->n;r->m=p->m-q->m;q=q->next;r->next=(struct LNode*)malloc(L);r=r->next;while(q->next!=NULL){r->n=q->n;r->m=-q->m;q=q->next;r->next=(struct LNode*)malloc(L);r=r->next;}r->n=q->n;r->m=-q->m;}if(p->n>q->n){while(q->n<p->n){r->n=q->n;r->m=-q->m;q=q->next;r->next=(struct LNode*)malloc(L);r=r->next;}if(p->n==q->n){r->n=p->n;r->m=p->m-q->m;q=q->next;r->next=(struct LNode*)malloc(L);r=r->next;while(q->next!=NULL){r->n=q->n;r->m=-q->m; q=q->next;r->next=(struct LNode*)malloc(L);r=r->next;}r->n=q->n;r->m=-q->m;}if(q->n>p->n){r->n=p->n;r->m=p->m;r->next=(struct LNode*)malloc(L);r=r->next; while(q->next!=NULL){r->n=q->n;r->m=-q->m; q=q->next;r->next=(struct LNode*)malloc(L);r=r->next;}r->n=q->n;r->m=-q->m;}}}r->next=(struct LNode*)malloc(L); r->next=NULL;printf("completed!\n");return(u);}double value (struct LNode*p,double x){double a,b; int i;p=p->next;a=0;while(p->next!=NULL){b=1;i=0;while(i<p->n){b=b*x;i++;}b=p->m*b;a=a+b;p=p->next;}b=1;i=0;while(i<p->n){b=b*x;i++;}b=p->m*b;a=a+b;return(a);}struct LNode* destroypolyn(struct LNode*p){struct LNode* u;p=NULL;u=p;printf("completed!\n");return(u);}struct LNode* clearpolyn(struct LNode*p){struct LNode* u=p;while(p!=NULL){p->m=0;p=p->next;}printf("completed!\n");return(u);}void main(){struct LNode *a[N]={NULL};double x,z;int n,n1,n2,n31,n32,n41,n42,n43,n51,n52,n53,n6,n7,n8,n9;top: printf("********************多项式运算器********************\n");printf(" 1----------------创建多项式\n");printf(" 2----------------显示多项式\n");printf(" 3----------------复制多项式\n");printf(" 4----------------多项式求和\n");printf(" 5----------------多项式求差\n");printf(" 6----------------多项式求值\n");printf(" 7----------------销毁多项式\n");printf(" 8----------------清空多项式\n");printf(" 9----------------修改多项式\n");printf(" 0----------------退出\n");printf(" 输入您要的运算:");scanf("%d",&n);switch(n){case 1:printf("输入您要创建的多项式存储位置\n");scanf("%d",&n1);a[n1-1]=createpolyn(a[n1-1]);break;case 2:printf("输入您要显示的多项式序号\n");scanf("%d",&n2);if(a[n2-1]!=NULL){printpolyn(a[n2-1]);}else printf("NULL\n");break;case 3:printf("输入您要复制的多项式序号和复制后的多项式的存储位置\n");scanf("%d",&n31);scanf("%d",&n32);a[n32-1]=copypolyn(a[n31-1],a[n32-1]);break;case 4:printf("输入您要求和的多项式以及和式存储位置\n");scanf("%d",&n41);scanf("%d",&n42);scanf("%d",&n43);a[n43-1]=addpolyn(a[n41-1],a[n42-1],a[n43-1]);break;case 5:printf("输入您要求差的被减式、减式以及差式存储位置\n");scanf("%d",&n51);scanf("%d",&n52);scanf("%d",&n53);a[n53-1]=subtract(a[n51-1],a[n52-1],a[n53-1]);break;case 6:printf("输入您要求值的多项式以及X的值\n");scanf("%d",&n6);scanf("%lf",&x);z=value(a[n6-1],x);printf("the value is:%lf\n",z);break;case 7:printf("输入您要销毁的多项式存储位置\n");scanf("%d",&n7);a[n7-1]=destroypolyn(a[n7-1]);break;case 8:printf("输入您要清空的多项式存储位置\n");scanf("%d",&n8);a[n8-1]=clearpolyn(a[n8-1]);break;case 9:printf("输入您要修改的多项式存储位置\n");scanf("%d",&n9);a[n9-1]=destroypolyn(a[n9-1]);a[n9-1]=createpolyn(a[n9-1]);break;case 0:printf("bye bye\n");break;}if(n!=0) goto top;}。