数据结构实验,多项式计算器
数据结构中实现一元多项式简单计算
数据结构中实现一元多项式简单计算：设计一个一元多项式简单的计算器。
基本要求：一元多项式简单计算器的基本功能为：（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后移。
数据结构实习报告——一元稀疏多项式运算器的设计
数据结构实习报告班级 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<math.h>#include<stdlib.h>typedef struct{float coef;int expn;}term,ElemType;typedef struct LNode{ElemType data;struct LNode *next;}*Link;typedef struct{Link head,tail;int len;}LinkList;/*====================链表-ADT====================*/ void MakeNode(Link &p,ElemType e){p=(Link)malloc(sizeof(struct LNode));if(!p) exit(1);p->data=e;p->next=NULL;}//MakeNodevoid InitList(LinkList &L){L.head=L.tail=(Link)malloc(sizeof(LNode));if(!L.head) exit(1);L.head->next=NULL;L.len=0;}//InitListvoid DestroyList(LinkList &L){Link p,q;p=L.head->next;while(p){q=p->next;free(p);p=q;}L.head->next=NULL;L.tail=L.head;L.len=0;}//DestroyListvoid InsLast(LinkList &L,Link s){L.tail->next=s;L.tail=s;L.len++;L.tail->next=NULL;}//InsLastvoid Append(LinkList &L,Link s){Link q;int m;if(!s) exit(1);L.tail->next=s;q=s;m=1;while(q->next){m++;q=q->next;}L.len+=m;L.tail=q;}//Append/*====================多项式-ADT====================*/ void CreatPolyn(LinkList &L){term e;Link s;scanf("%f,%d",&e.coef,&e.expn);while(e.coef){MakeNode(s,e);InsLast(L,s);scanf("%f,%d",&e.coef,&e.expn);}L.tail->next=NULL;}//CreatPolynint Judge(int n){if(n>19||n<0){printf("存储位置选择错误!请重新选择0-19.\n");return 1;}elsereturn 0;}//Judgevoid PrintPolyn(LinkList L){Link p;p=L.head->next;if(!p)printf("NULL\n");else {printf("y=");if(p->data.coef>0){if(p->data.expn==0)printf("%f",p->data.coef);elseprintf("%fx^%d",p->data.coef,p->data.expn);p=p->next;}else{if(p->data.expn==0)printf("%f",p->data.coef);elseprintf("%fx^%d",p->data.coef,p->data.expn);p=p->next;}while(p){if(p->data.coef>0){if(p->data.expn==0)printf("+%f",p->data.coef);elseprintf("+%fx^%d",p->data.coef,p->data.expn);p=p->next;}else{if(p->data.expn==0)printf("%f",p->data.coef);elseprintf("%fx^%d",p->data.coef,p->data.expn);if(p->next)p=p->next;}}printf("\n");}}//PrintPolynvoid PrintAll(LinkList S[]){int i;for(i=0;i<20;i++){printf("%d.",i);PrintPolyn(S[i]);}}//PrintAllvoid CopyPolyn(LinkList L,LinkList &S){term e;Link s,p;p=L.head->next;while(p){e.coef=p->data.coef;e.expn=p->data.expn;MakeNode(s,e);InsLast(S,s);p=p->next;}S.tail->next=NULL;}//CopyPolynint AddPolyn(LinkList &L,LinkList P,LinkList Q){ Link a,b,c;term e;a=P.head->next;b=Q.head->next;while((a!=NULL)&&(b!=NULL)){if(a->data.expn<b->data.expn){e.coef=a->data.coef;e.expn=a->data.expn;MakeNode(c,e);InsLast(L,c);a=a->next;}else if(a->data.expn>b->data.expn){e.coef=b->data.coef;e.expn=b->data.expn;MakeNode(c,e);InsLast(L,c);b=b->next;}else if((a->data.coef+b->data.coef)!=0){e.coef=a->data.coef+b->data.coef;e.expn=a->data.expn;MakeNode(c,e);InsLast(L,c);a=a->next;b=b->next;}else if((a->data.coef+b->data.coef)==0){a=a->next;b=b->next;}}if(!a&&!b){L.tail->next=NULL;return 0;}if(!b){while(a){e.coef=a->data.coef;e.expn=a->data.expn;MakeNode(c,e);InsLast(L,c);a=a->next;}}if(!a){while(b){e.coef=b->data.coef;e.expn=b->data.expn;MakeNode(c,e);InsLast(L,c);b=b->next;}}return 0;}//AddPolynvoid SubtractPolyn(LinkList &L,LinkList P,LinkList Q){ Link p;p=Q.head->next;while(p){p->data.coef=0-p->data.coef;p=p->next;}AddPolyn(L,P,Q);p=Q.head->next;while(p){p->data.coef=0-p->data.coef;p=p->next;}}//SubtractPolyndouble ResultPolyn(LinkList L,float x){Link p;double y=0;p=L.head->next;while(p){y+=(pow(x,p->data.expn)*p->data.coef);p=p->next;}return y;}//ResultPolynvoid MultiplyPolyn(LinkList &L,LinkList P,LinkList Q){ Link l,p,q;LinkList E,F;InitList(E);InitList(F);int i,j;term e;p=P.head->next;q=Q.head->next;for(i=0;i<Q.len;i++){for(j=0;j<P.len;j++){e.coef=p->data.coef*q->data.coef;e.expn=p->data.expn+q->data.expn;MakeNode(l,e);InsLast(E,l);p=p->next;}AddPolyn(L,E,F);DestroyList(E);DestroyList(F);CopyPolyn(L,F);if(i!=Q.len-1)DestroyList(L);q=q->next;p=P.head->next;}}//MultiplyPolynvoid Polyn_NFang(LinkList &L,LinkList P,int n){ int i;LinkList E;InitList(E);CopyPolyn(P,E);for(i=0;i<n;i++){MultiplyPolyn(L,E,P);DestroyList(E);CopyPolyn(L,E);if(i!=n-1)DestroyList(L);}}//Polyn_NFangvoid Polyn_NDao(LinkList &L,LinkList P,int n){ Link p,q;int i,j;CopyPolyn(P,L);for(i=0;i<n;i++){p=L.head->next;q=L.head;for(j=0;j<L.len;j++){if(p->data.expn==0){q->next=p->next;free(p);p=q->next;L.len--;}p->data.coef=p->data.coef*p->data.expn;p->data.expn=p->data.expn-1;p=p->next;q=q->next;}}}//Polyn_NDaoint Polyn_Ji(LinkList &L,LinkList P){Link p;int i;CopyPolyn(P,L);p=L.head->next;for(i=0;i<L.len;i++){if(p->data.expn==-1){printf("对不起，本程序不能实现对-1次方的积分.请重新选择.\n");DestroyList(L);return 0;}elsep=p->next;}for(i=0;i<L.len;i++){p->data.coef=p->data.coef/(p->data.expn+1);++p->data.expn;p=p->next;}return 0;}//Polyn_Jidouble Polyn_Ding(LinkList L,float a,float b){double m,n;double e=0;LinkList P;InitList(P);Polyn_Ji(P,L);m=ResultPolyn(P,a);n=ResultPolyn(P,b);e=n-m;return e;}//Polyn_Ding/*====================main====================*/void main(){int n,m,i,a,b,c;float x,e,f;double d;LinkList S[20];for(i=0;i<20;i++)InitList(S[i]);printf("说明：共有二十个多项式备用位置:0~19。
元稀疏多项式计算器实验报告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以上实验结果均能正确输出。
数据结构课程设计-计算器
数据结构课程设计报告实验一：计算器设计要求1、问题描述：设计一个计算器，可以实现计算器的简单运算，输出并检验结果的正确性，以及检验运算表达式的正确性。
2、输入：不含变量的数学表达式的中缀形式，可以接受的操作符包括+、-、*、/、%、(、)。
具体事例如下：3、输出：如果表达式正确，则输出表达式的正确结果；如果表达式非法，则输出错误信息。
具体事例如下：知识点：堆栈、队列实际输入输出情况：正确的表达式对负数的处理表达式括号不匹配表达式出现非法字符表达式中操作符位置错误求余操作符左右出现非整数其他输入错误数据结构与算法描述解决问题的整体思路：将用户输入的中缀表达式转换成后缀表达式，再利用转换后的后缀表达式进行计算得出结果。
解决本问题所需要的数据结构与算法：用到的数据结构是堆栈。
主要算法描述如下：A．将中缀表达式转换为后缀表达式：1. 将中缀表达式从头逐个字符扫描，在此过程中，遇到的字符有以下几种情况：1）数字2）小数点3）合法操作符+ - * / %4）左括号5）右括号6）非法字符2. 首先为操作符初始化一个map<std::string,int> priority，用于保存各个操作符的优先级，其中+ -为0，* / %为13. 对于输入的字符串from和输出的字符串to，采用以下过程：初始化遍历器std::string::iterator it=infix.begin()在当it!=from.end()，执行如下操作4. 遇到数字或小数点时将其加入到后缀表达式：case'1':case'2':case'3':case'4':case'5':case'6':case'7':case '8':case'9':case'0':case'.':{to=to+*it;break;}5. 遇到操作符（+，-，*，/，%）时，如果此时栈顶操作符的优先级比此时的操作符优先级低，则将其入栈，否则将栈中的操作符从栈顶逐个加入到后缀表达式，直到栈空或者遇到左括号，并将此时的操作符加入到栈中，在此过程中需判断表达式中是否出现输入错误：case'+':case'-':case'*':case'/':case'%':{if((it+1)==from.end()){cout<<"输入错误：运算符号右边缺少运算数"<<endl;return false;}if((*it=='*'||*it=='/')&&it==from.begin()){cout<<"输入错误：运算符号左边缺少运算数"<<endl;return false;}if((it+1)!=from.end()&&(*(it+1)=='+'||*(it+1)=='-'||*(it+1)=='*'||*(it+1)=='/' ||*(it+1)=='%')){cout<<"输入错误：运算符号连续出现"<<endl;return false;}to=to+" ";if(sym.empty()){sym.push(*it);break;}tem=sym.top();while(pri[*it]<=pri[tem]&&!sym.empty()&&tem!='('){to=to+tem+" ";sym.pop();if(sym.empty())break;tem=sym.top();}sym.push(*it);break;}6. 遇到“（”时，直接将其加入操作符栈，并且检测输入错误，并且当括号后的第一个符号为-时，说明用户试图输入负号，这种情况我们向目标表达式输出一个0，以达到处理负号的目的：case'(':{if((it+1)==from.end()){cout<<"输入错误：表达式以左括号结尾"<<endl;return false;}//若以+或者-开头，则按照正负号看待，向目标表达式中加入一个0if(*(it+1)=='-'||*(it+1)=='+'){to=to+'0';}if((it+1)!=from.end()&&((*(it+1)=='*'||*(it+1)=='/'||*(it+1)=='%'||*(it+1)==')'))) {cout<<"输入错误：左括号右边不能为运算符号或右括号"<<endl;return false;}if(it!=from.begin()&&(*(it-1)!='+'&&*(it-1)!='-'&&*(it-1)!='*'&&*(it-1)!='/'&&*(it-1)!='%'&&*(it-1)!='(')){cout<<"输入错误：左括号左边不能为运算数或右括号"<<endl;return false;}sym.push(*it);break;}5.遇到“）”时，将栈中的操作符从栈顶逐个弹出并放入后缀表达式中，直到在栈中遇到“（”，并将“（”从栈中弹出：case')':{if((it+1)!=from.end()&&*(it+1)!='+'&&*(it+1)!='-'&&*(it+1)!='*'&&*(it+1)!='/'&&*(it +1)!='%'&&*(it+1)!=')'){cout<<"输入错误：右括号右边不能为运算数"<<endl;return false;}if(it!=from.begin()&&(*(it-1)=='+'||*(it-1)=='-'||*(it-1)=='*'||*(it-1)=='/'||*(it-1)=='%')){cout<<"输入错误：右括号左边不能为运算符号"<<endl;return false;}to=to+" ";if(sym.empty()){cout<<"输入错误：表达式以右括号开始"<<endl;return false;}tem=sym.top();while(tem!='('){to=to+tem+" ";sym.pop();if(sym.empty()){cout<<"输入错误：括号匹配有误"<<endl;return false;}tem=sym.top();}sym.pop();break;}B．计算后缀表达式的主要思想：逐个字符的扫描后缀表达式，遇到单个数字或小数点时则先将其将其存到一个字符串中，当遇到后缀表达式中的分隔符（这里使用空格）时，则将这个字符串转化为数字放到堆栈numstack 中；case'1':case'2':case'3':case'4':case'5':case'6':case'7':case '8':case'9':case'0':case'.':{numtemp+=*it;break;}case' ':{if(numtemp!=""){if(numtemp.find('.')&&numtemp.find('.',(numtemp.find('.')+1))!=string::npos){cout<<"输入错误：小数点数目超出："+numtemp<<endl;return false;}strm.str(numtemp);strm>>d;numstack.push(d);numtemp="";strm.str("");strm.clear();break;}break;}2.遇到操作符+，-，*，/，%时，将堆栈numstack中的栈顶的两个数取出来，进行相应操作的运算，并将结果加入到堆栈numstack 中；case'+':{d2=numstack.top();numstack.pop();d1=numstack.top();numstack.pop();numstack.push(d1+d2);break;}case'-':{d2=numstack.top();numstack.pop();d1=numstack.top();numstack.pop();numstack.push(d1-d2);break;}case'*':{d2=numstack.top();numstack.pop();d1=numstack.top();numstack.pop();numstack.push(d1*d2);break;}case'/':{d2=numstack.top();numstack.pop();if(fabs(d2)<0.0000001){cout<<"输入错误：除数不能为0"<<endl;return false;}d1=numstack.top();numstack.pop();numstack.push(d1/d2);break;}case'%':{d2=numstack.top();numstack.pop();d1=numstack.top();numstack.pop();if((fabs(d2-(int)d2))<0.0000001&&(fabs(d1-(int)d1))<0.0000001){int n1=(int)d1;int n2=(int)d2;numstack.push((double)(n1%n2));break;}else{cerr<<"输入错误：求模操作只能作用于整数"<<endl;return false;}}3.直到后缀表达式扫描完并且堆栈numstack中只有一个数值，则此数值为计算的最终结果，否则说明输入有误。
(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语言实现了一元稀疏多项式计算器，并体验了多项式运算的具体操作。
数据结构实验,多项式计算器
实验题目：多项式运算器实验内容：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函数用以求两多项式的差，类似求和算法。
数据结构实验-一元多项式的加法运算
一元多项式加法一、实验目的通过实现多项式加法，对链表有更深入的了解二、实验内容问题描述：设计一个一元稀疏多项式简单的加法计算器实现要求：一元稀疏多项式简单计算器的基本功能是：（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指向要比较的下一个结点。
用C语言实现多项式简单计算器的设计
设计题目：用 C 语言实现多项式简单计算器的设计
设计目的
1.巩固和加深课堂所学知识、学会分析研究数据对象的特性及数据的组织方法； 2.选择合适的数据的逻辑结构和存储结构以及相应操作，实现简单的多项式计算； 3.提高程序设计能力、加强查阅、运用资料的能力、算法分析与程序设计素质培养 ；
设计任务 （在规定的时间内完成下列任务）
学号 10212812141
武汉理工大学华夏学院 课程设计报告书
课程名称： 数据结构
题 目：用 C 语言实现多项式简单计算器的设计
系 名：
信息工程系
专业班级：
软件工程 1121 班
姓 名：
邓燕蓉
指 月 28 日
课程设计任务书
学生姓名： 邓燕蓉 指导教师： 王绪梅
专业班级： 软件工程 1121 班 工作单位：华夏学院计算机教研室
为了实现处理，设 p、q2 分别指向单链表 polya 和 polyb 的当前项，比较 p、q2 结点的指数 由此得到下列运算规则：
① 若 p->expn<q2->expn，则结点 q2 所指的结点应是“和多项式”中的一项，令指针 q2 后移。 ② 若 p->expn=q2->expn，则将两个结点中的系数相加，当和不为 0 时修改结点 q2 的系数。 ③ 若 p->expn>q2->expn，则结点 p 所指的结点应是“和多项式”中的一项，将结点 p 插入在结点 q2 之前，且令指针 p 在原来的链表上后移。
2.2 设计思路
（1）定义线性表的动态分配顺序存储结构； （2）建立多项式存储结构，定义指针*next； （3）利用链表实现队列的构造，每次输入一项的系数和指数，可以构造一元多项式； （4）演示程序以用户和计算机的对话方式执行，即在计算机终站上显示“提示信息”之后，由用户在 键盘上输入演示程序中规定的运行命令；最后根据相应的数据进行输入建立多项式以及多项式相加，减， 乘的运行结果在屏幕上显示。 设计思路分析：
数据结构课程设计(一元稀疏多项式计算器)
实习报告：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（）函数里调用输入函数。
数据结构课程方案_一元稀疏多项式计算器
{
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>。
}
}
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>
{
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>
}
printf("未找到该项。\n">。
- 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;}。