一元稀疏多项式计算器(数据结构)
一元稀疏多项式计算器实现（完整实现版详细源码）
1.5一元稀疏多项式计算器实习报告一、需求分析1．输入并建立多项式；2．输出多项式，输出形式为整数序列：n，c1，e1，c2，e2，……，c n，e n，其中n是多项式的项数，c i和ei分别是第i项的系数和指数，序列按指数降序排列；3．多项式a和b相加，建立多项式a＋b；4．多项式a和b相减，建立多项式a—b；5．多项式a和b相乘，建立多项式a×b；6．计算多项式在x处的值；7．求多项式P的导函数P'；8.多项式的输出形式为类数学表达式；9.做出计算器的仿真界面；10.测试数据：（1） (2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=(-3.1x^11+11x^9+2x+7)（2） (6x^-3-x+4.4x^2-1.2x^9+1.2x^9)-(-6x^-3+5.4x^2-x^2+7.8x^15 ) =(-7.8x^15-1.2x^9+12x^-3-x);（3）(1+x+x^2+x^3+x^4+x^5)+(-x^3-x^4)=(1+x+x^2+x^5);（4）(x+x^3)+(-x-x^3)=0（5）(x+x^100)+(x^100+x^200)=(x+2x^100+x^200)（6）(x+x^2+x^3)+0=x+x^2+x^3（7）互换上述测试数据中的前后两个多项式二、概要设计1.链表的抽象数据类型定义为：ADT LinkLi st{数据对象：D＝{ ai | ai∈ElemSe t, i=1,2,...,n, n≥0 }数据关系：R1＝{ <ai-1, ai>|ai-1, ai∈D, i=2,...,n }基本操作：InitLi st(&L)操作结果：构造一个空的线性表L。
Destro yList(&L)初始条件：线性表L已存在。
操作结果：销毁线性表L。
数据结构实习报告——一元稀疏多项式运算器的设计
数据结构实习报告——一元稀疏多项式运算器的设计一、引言在计算机科学领域中，数据结构是研究数据组织、存储和管理的关键概念之一。
在本次实习中，我设计并实现了一个一元稀疏多项式运算器，旨在使用适当的数据结构和算法来高效地进行多项式的加法、减法和乘法运算。
本报告将详细介绍该运算器的设计思路、算法实现以及性能评估。
二、设计思路1. 多项式的表示在设计多项式运算器时，首先需要确定多项式的表示方法。
为了高效地处理稀疏多项式，我选择使用链表作为基本数据结构。
每个节点包含多项式的系数和指数，并通过指针连接在一起形成链表。
这种表示方法可以有效地处理稀疏多项式，减少了不必要的空间浪费。
2. 多项式的输入和输出为了方便用户输入和输出多项式，我设计了简单的交互界面。
用户可以通过命令行输入多项式的系数和指数，并选择进行的运算操作。
运算结果将直接在命令行中输出。
三、算法实现1. 多项式的加法多项式的加法是指将两个多项式相加得到一个新的多项式。
为了实现这个功能，我设计了一个算法如下：- 创建两个空的链表，分别表示两个多项式。
- 逐个读取用户输入的系数和指数，并将其插入到相应的链表中。
- 对两个链表进行遍历，根据指数的大小关系进行合并操作。
- 将合并后的结果链表输出。
2. 多项式的减法多项式的减法是指将一个多项式减去另一个多项式得到一个新的多项式。
为了实现这个功能，我设计了一个算法如下：- 创建两个空的链表，分别表示两个多项式。
- 逐个读取用户输入的系数和指数，并将其插入到相应的链表中。
- 对第二个链表中的每个节点的系数取相反数。
- 对两个链表进行遍历，根据指数的大小关系进行合并操作。
- 将合并后的结果链表输出。
3. 多项式的乘法多项式的乘法是指将两个多项式相乘得到一个新的多项式。
为了实现这个功能，我设计了一个算法如下：- 创建一个空的链表，表示乘法结果。
- 逐个读取用户输入的系数和指数，并将其插入到链表中。
- 对第一个链表中的每个节点，与第二个链表中的每个节点进行乘法运算，并将结果插入到结果链表中。
一元稀疏多项式计算器数据结构
一元稀疏多项式计算器数据结构一元稀疏多项式计算器是一种用于计算多项式的工具，该工具可以用于代数计算、数学分析以及计算机科学中的算法设计。
它可以通过一种特殊的数据结构来存储多项式，并可以对其进行加法、减法、乘法、除法等运算。
这种数据结构被称为稀疏多项式，它是一种基于链表的数据结构。
在稀疏多项式中，每个节点表示一个单项式，节点的数据包含该单项式的系数和指数。
在一个稀疏多项式中，只有少数几个节点表示一个多项式，这就是稀疏性的来源。
稀疏多项式的加法和减法非常简单，只需要对两个多项式的对应节点进行加减即可。
而稀疏多项式的乘法需要更复杂的算法。
乘法的过程中需要将两个多项式的每个单项式乘起来，并将同类项合并成一个新的多项式。
这个过程涉及到大量的链表操作，但只要注意一些细节，将会得到正确的结果。
除了基本的加法、减法、乘法运算，一元稀疏多项式计算器还有一个非常重要的运算，那就是求导。
求导是一种将多项式每个单项式的指数减一，并将系数乘以指数的运算。
它常用于解决微积分、概率论等问题。
求导操作可以通过修改节点的指数和系数来实现。
在计算机科学中，稀疏多项式可以用于设计高效的算法，例如在数论、密码学、图像处理、计算器表达式求值等方面。
稀疏多项式的优点在于它可以有效地节省存储空间和计算时间。
通过动态链表的形式，可以轻松地添加、删除节点，使得稀疏多项式非常适合用于处理大规模的数据。
总的来说，一元稀疏多项式计算器是一种非常实用的工具。
它可以用于解决多项式运算问题，并可以为计算机科学方面的算法设计提供很大的帮助。
通过了解这种数据结构，我们可以更深入地理解代数学、微积分学等数学原理，并且能够更好地应用于实际问题中。
数据结构实习报告——一元稀疏多项式运算器的设计
数据结构实习报告——一元稀疏多项式运算器的设计一、引言在计算机科学领域中，数据结构是构建各种算法和程序的基础。
本次实习项目旨在设计一个一元稀疏多项式运算器，通过合理的数据结构和算法实现多项式的加法、减法和乘法运算，以及求导和求值等功能。
本文将详细介绍该运算器的设计思路、数据结构选择、算法实现和性能优化等方面。
二、设计思路为了实现一元稀疏多项式的运算，我们需要选择合适的数据结构来存储和操作多项式的系数和指数。
考虑到多项式中只有少数系数非零，我们可以使用链表来表示多项式，每个节点存储一个非零系数和对应的指数。
这样可以节省空间，并且方便插入和删除操作。
三、数据结构选择在设计中，我们选择了一个单向链表作为多项式的数据结构。
链表节点的定义如下：```struct Node {int coefficient; // 系数int exponent; // 指数Node* next; // 下一个节点指针};```链表的头节点指针指向第一个非零项，便于遍历和操作。
四、算法实现1. 多项式的输入用户可以通过标准输入方式输入多项式的系数和指数，我们通过读取用户输入的系数和指数，并根据其大小构建链表。
2. 多项式的加法和减法运算多项式的加法和减法运算可以通过遍历两个多项式的链表，并根据指数的大小进行合并操作。
具体的实现可以使用双指针的方式，分别指向两个链表的当前节点，比较指数的大小，然后将较小的节点插入到结果链表中，并将指针向后移动。
3. 多项式的乘法运算多项式的乘法运算可以通过遍历两个多项式的链表，并将每一项相乘得到新的项，然后将新的项插入到结果链表中。
具体的实现中，可以使用一个嵌套的循环，先遍历一个多项式的链表，再遍历另一个多项式的链表，将每一项相乘，并根据指数的大小插入到结果链表中。
4. 多项式的求导和求值多项式的求导可以通过遍历链表，将每一项的系数乘以指数，并将指数减一得到新的项。
多项式的求值可以通过遍历链表，将每一项的系数乘以变量的值的指数次方，并累加得到结果。
一元稀疏多项式计算器(数据结构)
院系：计算机科学学院专业：软件工程年级： 2013级课程名称：数据结构姓名：韦宜（201321092034）指导教师：宋中山2015年 12 月 15日题目：设计一个一元稀疏多项式简单计算器班级：软件工程1301 姓名：韦宜学号：201321092034 完成日期：12月15日一、需求分析问题描述：设计一个一元多项式加法器基本要求：输入并建立多项式；(2)两个多项式相加；(3)输出多项式：n, c1, e1, c2, e2, …cn , en, 其中，n是多项式项数，ci和ei分别是第 i 项的系数和指数，序列按指数降序排列。
(4)计算多项式在x处的值；(5)求多项式的导函数。
软件环境：Windows，UNIX，Linux等不同平台下的Visual C++ 6.0硬件环境: 512MB内存,80Gb硬盘,Pentium4 CPU,CRT显示器。
概要分析本程序有五个函数：PolyNode *Input()(输入函数)；PolyNode *Deri(PolyNode *head)（求导函数）；PolyNode * Plus(PolyNode *A,PolyNode *B)（求和函数）；void Output(PolyNode*head)（输出函数）；int main()（主函数）本程序可使用带有附加头结点的单链表来实现多项式的链表表示，每个链表结点表示多项式的一项，命名为node，它包括两个数据成员：系数coef和指数exp，他们都是公共数据成员，*next为指针域，用链表来表示多项式。
适用于不定的多项式，特别是对于项数再运算过程中动态增长的多项式，不存在存储溢出的问题。
其次，对于某些零系数项，在执行加法运算后不再是零系数项，这就需要在结果多项式中增添新的项；对于某些非零系数项，在执行加法运算后可能是零系数项，这就需要在结果多项式中删去这些项，利用链表操作，可以简单的修改结点的指针以完成这种插入和删除运算（不像在顺序方式中那样，可能移动大量数据项）运行效率高。
数据结构课程设计___一元稀疏多项式计算器(报告 代码)__完整版
数据结构课程设计一、课程题目一元稀疏多项式计算器二、需求分析1、一元稀疏多项式简单计算器的功能是：1.1 输入并建立多项式；1.2 输出多项式，输出形式为整数序列：n，c1,e1,c2,e2,………cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列；1.3 求多项式a、b的导函数；1.4 计算多项式在x处的值；1.5多项式a和b相加，建立多项式a+b；1.6 多项式a和b相减，建立多项式a-b。
2、设计思路:2.1 定义线性表的动态分配顺序存储结构；2.2 建立多项式存储结构，定义指针*next2.3利用链表实现队列的构造。
每次输入一项的系数和指数，可以输出构造的一元多项式2.4演示程序以用户和计算机的对话方式执行，即在计算机终站上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运行命令；最后根据相应的输入数据（滤去输入中的非法字符）建立的多项式以及多项式相加的运行结果在屏幕上显示。
多项式显示的格式为：c1x^e1+c2x^e2+…+cnx^en3、设计思路分析要解决多项式相加，必须要有多项式，所以必须首先建立两个多项式，在这里采用链表的方式存储链表，所以我将结点结构体定义为运用尾插法建立两条单链表，以单链表polyn p和polyn h分别表示两个一元多项式a和b，a+b的求和运算等同于单链表的插入问题（将单链表polyn p中的结点插入到单链表polyn h中），因此“和多项式”中的结点无须另生成。
为了实现处理，设p、q分别指向单链表polya和polyb的当前项，比较p、q结点的指数项，由此得到下列运算规则：① 若p->expn<q->expn，则结点p所指的结点应是“和多项式”中的一项，令指针p后移。
② 若p->expn=q->expn，则将两个结点中的系数相加，当和不为0时修改结点p的系数。
③ 若p->expn>q->expn，则结点q所指的结点应是“和多项式”中的一项，将结点q插入在结点p之前，且令指针q在原来的链表上后移。
数据结构课程设计_一元稀疏多项式计算器
数据结构实验报告——一元稀疏多项式计算器安子烨PB12203079实验目的实现一元多项式的简单运算功能，掌握线性表的知识，提高编程能力。
功能清单1.一元多项式创建2.显示一元多项式3.复制一元多项式4.多项式加法5.多项式减法6.修改一元多项式7.删除一元多项式8.销毁记录实验设计该多项式计算器以菜单驱动的形式实现上述各运算功能。
最多可支持十条记录，分别用指针数组引导存储于十个不同的位置。
以下为程序的部分源代码。
#include<stdio.h>#include<math.h>#include<stdlib.h>typedef struct LinkList{double coef;int expn;LinkList *next;}LNode;void CreatPolyn(LinkList **h)//创建多项式{LinkList *q=NULL, *w=NULL, *p=NULL;double m=0; int n=0;(*h)=(LinkList *)malloc(sizeof(LinkList));(*h)->coef=0; (*h)->expn=0; (*h)->next=NULL;printf("请输入X的系数和指数,当系数为零时结束创建\n");scanf("%lf%d",&m,&n);while(m!=0){q=(LinkList *)malloc(sizeof(LinkList));q->coef=m; q->expn=n; q->next=NULL;if((*h)->next==NULL){if(q->expn==(*h)->expn) (*h)->coef+=q->coef;else if((*h)->expn>q->expn) {q->next=(*h); *h=q; } else (*h)->next=q;}else{for(w=(*h);w->next!=NULL;w=w->next){if(q->expn==w->expn){w->coef+=q->coef;break;}else if((w->expn>q->expn)&&(w==*h)){q->next=(*h);(*h)=q;break;}else if((w->expn<q->expn)&&(w->next->expn>q->expn)){q->next=w->next;w->next=q;break;}}if(w->next==NULL){if(w->expn==q->expn) w->coef+=q->coef;else if(w->expn<q->expn) w->next=q;}}printf("请输入X的系数和指数,当系数为零时结束创建\n");scanf("%lf%d",&m,&n);}}void PrintPolyn(LinkList *p, int i)//打印多项式{printf("第%d个多项式是:",i);while(p!=NULL){if((p->coef)>0) printf("+%lf*X^%d",p->coef,p->expn);else if((p->coef)<0) printf("%lf*X^%d",p->coef,p->expn); p=p->next;}printf("\n");}void CopyPolyn(LinkList **M, LinkList **N)//多项式复制{LinkList *p=NULL, *q=NULL, *w=NULL;(*N)=(LinkList *)malloc(sizeof(LinkList));(*N)->coef=(*M)->coef; (*N)->expn=(*M)->expn; (*N)->next=NULL;for(w=(*N),p=(*M)->next;p!=NULL;p=p->next){q=(LinkList *)malloc(sizeof(LinkList));q->coef=p->coef; q->expn=p->expn; q->next=p->next;w->next=q; w=w->next;}}void AddPolyn(LinkList *M, LinkList *N, LinkList **X)//多项式加法{LinkList *p=NULL, *q=NULL, *w=NULL, *z=NULL;(*X)=(LinkList *)malloc(sizeof(LinkList));(*X)->coef=0; (*X)->expn=0; (*X)->next=NULL;for(p=M,q=N,w=(*X);(p!=NULL)&&(q!=NULL);){z=(LinkList *)malloc(sizeof(LinkList));if(p->expn<q->expn){z->coef=p->coef; z->expn=p->expn; z->next=NULL;p=p->next; w->next=z; w=w->next;}else if(p->expn>q->expn){z->coef=q->coef; z->expn=q->expn; z->next=NULL;q=q->next; w->next=z; w=w->next;}else if(p->expn==q->expn){z->coef=p->coef+q->coef; z->expn=p->expn; z->next=NULL;p=p->next; q=q->next; w->next=z; w=w->next;}}if(p==NULL){for(;q!=NULL;){z=(LinkList *)malloc(sizeof(LinkList));z->coef=q->coef; z->expn=q->expn; z->next=NULL;q=q->next; w->next=z; w=w->next;}}else if(q==NULL){for(;p!=NULL;){z=(LinkList *)malloc(sizeof(LinkList));z->coef=p->coef; z->expn=p->expn; z->next=NULL;p=p->next; w->next=z; w=w->next;}}for(w=(*X);w!=NULL;w=w->next){printf("%lf %d\n",w->coef,w->expn);}}void SubtractPolyn(LinkList *M, LinkList *N, LinkList **X)//多项式减法{LinkList *p=NULL, *q=NULL, *w=NULL, *z=NULL;(*X)=(LinkList *)malloc(sizeof(LinkList));(*X)->coef=0; (*X)->expn=0; (*X)->next=NULL;for(p=M,q=N,w=(*X);(p!=NULL)&&(q!=NULL);){z=(LinkList *)malloc(sizeof(LinkList));if(p->expn<q->expn){z->coef=p->coef; z->expn=p->expn; z->next=NULL;p=p->next; w->next=z; w=w->next;}else if(p->expn>q->expn){z->coef=-q->coef; z->expn=q->expn; z->next=NULL;q=q->next; w->next=z; w=w->next;}else if(p->expn==q->expn){z->coef=p->coef-q->coef; z->expn=p->expn; z->next=NULL;p=p->next; q=q->next; w->next=z; w=w->next;}}if(p==NULL){for(;q!=NULL;){z=(LinkList *)malloc(sizeof(LinkList));z->coef=-q->coef; z->expn=q->expn; z->next=NULL;q=q->next; w->next=z; w=w->next;}}else if(q==NULL){for(;p!=NULL;){z=(LinkList *)malloc(sizeof(LinkList));z->coef=p->coef; z->expn=p->expn; z->next=NULL;p=p->next; w->next=z; w=w->next;}}/*for(w=(*X);w!=NULL;w=w->next){printf("%lf %d\n",w->coef,w->expn);}*/}void ValuePolyn(LinkList *h, double x)//多项式求值{double sum=0, a=0;while(h!=NULL){a=pow(x,h->expn);sum=sum+(h->coef)*a;h=h->next;}printf("所求多项式的值为%lf\n",sum);}void DeletePolyn(LinkList **h){LinkList *p=(*h)->next; (*h)=NULL;while(p!=NULL){free(*h);(*h)=p;p=p->next;}}void RevisePolyn(LinkList **h, int i){int n=0;int choose=0;double m=0;LinkList *q=NULL, *w=NULL;PrintPolyn((*h),i);printf("请输入你想执行的操作代号（添加：1；修改：2；删除：3）\n");scanf("%d",&choose);switch(choose){case 1:{printf("输入你想要添加项的系数和次数\n");scanf("%lf%d",&m,&n);q=(LinkList *)malloc(sizeof(LinkList));q->coef=m; q->expn=n; q->next=NULL;for(w=(*h);w->next!=NULL;w=w->next){if((w->expn>q->expn)&&(w==*h)){q->next=(*h);(*h)=q;break;}else if((w->expn<q->expn)&&(w->next->expn>q->expn)) {q->next=w->next;w->next=q;break;}}if(w->expn<n) w->next=q;break;}case 2:{printf("输入你想要修改项的系数和次数\n");scanf("%lf%d",&m,&n);for(w=(*h);w!=NULL;w=w->next){if(w->expn==n) w->coef=m;}printf("未找到该项。
一元稀疏多项式计算器课程设计
软件学院课程设计报告书课程名称数据结构设计题目一元稀疏多项式计算器专业班级软件工程11级1班学号 1120010107姓名指导教师2013 年 1月目录1设计时间 42设计目的 43设计任务 44设计内容 44.1需求分析 44.1.1.程序所能达到的功能 44.1.2.输入的形式和输入值的范围 44.1.3.输出的形式 44.1.4.测试数据 54.2总体设计 54.2.1.本程序中用到的所有抽象数据类型的定义 54.2.2.主程序的流程 74.2.3.各程序模块之间的层次（调用）关系 74.3详细设计 74.3.1实现概要设计中定义的所有数据类型，对每个操作只需要写出伪码算法 74.3.2.对主程序和其它主要函数伪码算法 114.3.3.函数的调用关系图 124.4测试与分析 124.4.1测试 124.4.2分析 134.5 附录 135 总结与展望 19参考文献 20 成绩评定 204.1.3.输出的形式本程序要输出的是分别把创建的第一个多项式和第二个多项式按指数升序排序，并且把计算加减后的运算结果按指数升序排列输出。
4.1.4.测试数据(1)正确：图1程序输出(2)错误：图2程序输出4.2总体设计4.2.1.本程序中用到的所有抽象数据类型的定义ADT List{初始条件：多项式L已存在。
操作结果：显示多项式。
AddPoly( L_1,L_2,L_add )初始条件：多项式L_1,L_2,L_add已存在。
操作结果：生成L_1,L_2之和的多项式L_add DiffPoly( L ,L_diff)初始条件：多项式L ,L_diff已存在。
操作结果：生成L的导数多项式L_add。
AlterPoly( L )初始条件：多项式L已存在。
操作结果：将L多项式取相反数。
}ADT Poly4.2.2.主程序的流程图3主程序流程4.2.3.各程序模块之间的层次（调用）关系图4模块层次调用关系4.3详细设计4.3.1实现概要设计中定义的所有数据类型，对每个操作只需要写出伪码算法Typedef Polynomial //定义结构体类型{float coef; //多项式系数int expn; //多项式指数struct Polynomial *next; //多项式的下一个指针域}*Polyn,Polynomial;void Insert( &p,&h) //定义插入函数{if(p.coef==0) //若p的系数是则释放pfree(p);else{q1=h;q2=h->next;while(q2&&q2.expn<p.expn) //找到链表中第一个指数大于p的指数的项{q1=q2;q2=q2.next;}PrintPolyn(pc);pc=SubtractPolyn(pa,pb);printf("\n输出多项式之差a-b="); PrintPolyn(pc);printf("\n 感谢使用此程序！\n"); DestroyPolyn(pa);DestroyPolyn(pb);4.3.3.函数的调用关系图图5函数调用关系4.4测试与分析4.4.1测试输入：a=2X+3X^2; b=2X^3+7X^4输出：a+b=2X+3X^2+ 2X^3+7X^4a-b=2X+3X^2-2X^3-7X^4图6程序输出。
数据结构课程设计___一元稀疏多项式计算器(报告+代码)__完整版.
数据结构课程设计系别电子信息系专业计算机科学与技术班级学号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。
多项式链表生成的函数：函数的返回值应该为定义的结构体类型，不需要设置参数。
函数内部，需要有多项式指数和系数的输入，直至输入的系数为零时结束，将每一对输入的指数和系数保存到新结点中，并将结点插入到链表中。
一元稀疏多项式简单计算器
一、课程设计概述：本次数据结构课程设计共完成五个题：一元稀疏多项式计算器、迷宫问题、成绩分析问题、图的基本操作与实现以及背包问题的求解使用语言：C编译环境：TC3.0二、课程设计题目一[实验内容]一元稀疏多项式计算器[问题描述]设计一个一元稀疏多项式简单计算器。
[基本要求]一元稀疏多项式简单计算器的基本功能是：（1）输入并建立多项式；（2）输出多项式，输出形式为整数序列：n,c1,e1, c2,e2,,,,,,, c n,e n,其中n是多项式的项数，c i,e i,分别是第i项的系数和指数，序列按指数降序排序；（3）多项式a和b相加，建立多项式a+b；（4）多项式a和b相减，建立多项式a-b；（5）计算多项式在x处的值。
（6）计算器的仿真界面。
（选做）[概要设计]-=ADT=-Test1:主类，程序的启动Item :项，表示多项式中的某一项Ploynomial：多项式类[存储结构]Item属性：private double c;//系数private int e;//指数Item方法：public void setC(double c){//设置系数}public void setE(int e){ //设置指数}public double getC(){//获取系数}public int getE(){//获取指数}public double resultItem(double x){//在x处Item的值}private double fac(double x,int e){//求x的e次方,当e为整数时}Polynomial属性：private LinList list;//单链表Polynomial方法：public Polynomial(){}public Polynomial(Item [] item)throws Exception{ //构造函数}private void initItem(Item [] item){//初始化Item数组，使其是按降序排序}public int getItemNum(){//获取项数}public void print()throws Exception{//打印多项式不空行}public void println()throws Exception{//打印多项式空行}public LinList getLinList(){//获取单链表}public void printPolynomial()throws Exception{//只打印项数、系数和指数}public Polynomial add(Polynomial other)throws Exception{//多项式相加}}public Polynomial subtraction(Polynomial other)throws Exception{//多项式相减}public double result(double x)throws Exception{}[详细设计]Item类：public class Item {private double c;//系数private int e;//指数public Item(){}public Item(double c,int e){this.c=c;this.e=e;}public void setC(double c){this.c=c;}public void setE(int e){this.e=e;}public double getC(){return c;}public int getE(){return e;}public double resultItem(double x){return getC()*fac(x,getE());}private double fac(double x,int e){//求x的e次方,当e为整数时if(e==0) return 1;return x*fac(x,e-1);}}Polynomial类：import java.util.*;public class Polynomial{//多项式类private LinList list;//单链表public Polynomial(){list=new LinList(0,null);}public Polynomial(Item [] item)throws Exception{ //构造函数int n=item.length;list=new LinList(n,null);if(n==0){return;}initItem(item);try{for(int i=0;i<n;i++)list.insert(i,item[i]);}catch(Exception e){}}private void initItem(Item [] item){//初始化Item数组，使其是按降序排序int n=item.length;int max;for(int i=0;i<n;i++){max=i;for(int j=i+1;j<n;j++)if(item[j].getE()>item[max].getE()) max=j;if(max!=i){Item temp=item[i];item[i]=item[max];item[max]=temp;}}}public int getItemNum(){//获取项数Object temp=list.head.getElement();int n=-1;if(temp instanceof Integer){Integer i=(Integer)temp;n=i.intValue();}return n;}public void print()throws Exception{//打印多项式不空行int n=getItemNum();// System.out.println(n);if(n==-1) return ;if(n==0){System.out.print("0");return;}boolean flag=true;//是不是输出第一项的标志for(int i=0;i<n;i++){Item temp=(Item)list.getData(i);double c=temp.getC();if(c==0) continue;//系数为0时不输出if(flag && temp.getE()!=0 ){System.out.print(c+"x^"+temp.getE());}else if(flag && temp.getE()==0)System.out.print(temp.getC());else {if(c>0)System.out.print("+"+c+"x^"+temp.getE());else if(c<0)System.out.print(c+"x^"+temp.getE());}flag=false;}}public void println()throws Exception{//打印多项式空行print();System.out.println();}public LinList getLinList(){//获取单链表return list;}public void printPolynomial()throws Exception{//只打印项数、系数和指数int n=getItemNum();if(n==0) return ;System.out.print(n+",");for(int i=0;i<n;i++){Item item=(Item)this.getLinList().getData(i);if(i!=n-1){System.out.print("c"+i+"="+item.getC()+", "+"e"+i+"="+item.getE()+", ");}else{System.out.print("c"+i+"="+item.getC()+", "+"e"+i+"="+item.getE());}}System.out.println();}public Polynomial add(Polynomial other)throws Exception{//多项式相加LinList otherList=other.getLinList();int n1=getItemNum();//该多项式的项数int n2=other.getItemNum();//另一个多项式的项数if(n2==0) return this;if(n1==0) return other;Polynomial temp=new Polynomial();int i=0,j=0;while (+i<n1 && j<n2){Item item=new Item();Item item1=(Item)list.getData(i);Item item2=(Item)otherList.getData(j);double c1=item1.getC();//获得系数double c2=item2.getC();int e1=item1.getE();//获得指数int e2=item2.getE();if(e1==e2){//相等时double c=c1+c2;item.setC(c);item.setE(e1);i++;j++;}else if(e1<e2){//不相等时指数的大的增加item=item2;j++;}else {item=item1;i++;}try{if(item.getC()==0)//当得到项的系数为0时就没有必要加入continue;temp.getLinList().insert(temp.getLinList().size(),item);}catch(Exception e){}}//将没有参加比较的项加进去，注意比较之后有且只有一个有多余的项while(i<n1){Item item1=(Item)list.getData(i);try{temp.getLinList().insert(temp.getLinList().size(),item1);}catch(Exception e){}i++;}while(j<n2){Item item1=(Item)otherList.getData(j);try{temp.getLinList().insert(temp.getLinList().size(),item1);}catch(Exception e){}j++;}temp.getLinList().head.setElement(temp.getLinList().size());//设置项数return temp;}public Polynomial subtraction(Polynomial other)throws Exception{//多项式相减int n=other.getItemNum();if(n==0) return this;Polynomial temp=new Polynomial();LinList l=temp.getLinList();for(int i=0;i<n;i++){Item item =(Item)other.getLinList().getData(i);double c=-1*item.getC();//取反l.insert(i,new Item(c,item.getE()));}l.head.setElement(n);//设置项数return add(temp);}public double result(double x)throws Exception{double sum=0;int n=getItemNum();//该多项式的项数if(n==0) return 0;for(int i=0;i<n;i++){Item item=(Item)list.getData(i);sum+=item.resultItem(x);}return sum;}}T est1类：import java.io.*;import java.util.Scanner;public class T est1 {Scanner scanner =new Scanner(System.in);public static void main(String[] args)throws Exception{ T est1 test1=new T est1();Scanner scanner1 =new Scanner(System.in);while(true){System.out.println("请输入你要操作的系号：\n"+"1)输出多项式\n"+"2)多项式相加\n"+"3)多项式相减\n"+"4)计算多项式在x处的值\n"+"5)退出");String s=scanner1.next();int t=-1;try{t=Integer.parseInt(s);}catch(Exception e){}switch(t){case 1:test1.printPolynomial();break;case 2:test1.add();break;case 3:test1.subtraction();break;case 4:test1.resultOfPolynomia();break;case 5:System.exit(0);break;default:System.out.println("你输入的操作有误，请重试\n");continue;}}}private void printPolynomial()throws Exception{//选择1时System.out.println("请输入要输出的多项式的信息：");Item[] item=creatItemShuZu();Polynomial p=new Polynomial(item);p.printPolynomial();}private void add()throws Exception{//选择2时System.out.println("请输入第一个多项式的信息：");Item[] item1=creatItemShuZu();Polynomial p1=new Polynomial(item1);System.out.println("请输入第二个多项式的信息：");Item[] item2=creatItemShuZu();Polynomial p2=new Polynomial(item2);Polynomial p=p1.add(p2);System.out.print("(");p1.print();System.out.print(")+(");p2.print();System.out.print(")=");p.print();System.out.println();}private void subtraction()throws Exception{//选择3时System.out.println("请输入第一个多项式的信息：");Item[] item1=creatItemShuZu();Polynomial p1=new Polynomial(item1);System.out.println("请输入第二个多项式的信息：");Item[] item2=creatItemShuZu();Polynomial p2=new Polynomial(item2);Polynomial p=p1.subtraction(p2);System.out.print("(");p1.print();System.out.print(")-(");p2.print();System.out.print(")=");p.print();System.out.println();}private void resultOfPolynomia()throws Exception{//选择4时System.out.println("请输入要输出的多项式的信息：");Item[] item=creatItemShuZu();Polynomial p=new Polynomial(item);System.out.println("请输入x=");double x=scanner.nextDouble();System.out.println(p.result(x));}private Item[] creatItemShuZu()throws Exception{//构造多项式数组System.out.print("项数n=");int n=scanner.nextInt();double []c=new double[n];int [] e=new int[n];Item[] item=new Item[n];System.out.print("请输入各项的系数：");for(int i=0;i<n;i++)c[i]=scanner.nextDouble();System.out.print("请输入各项的指数：");for(int i=0;i<n;i++)e[i]=scanner.nextInt();for(int i=0;i<n;i++){item[i]=new Item(c[i],e[i]);}return item;}}[调试分析]本程序主要的操作对象是记录数组，使用的存储结构是结构体数组。
一元稀疏多项式计算器
#include"stdio.h"#include"stdlib.h"#include"conio.h"typedef int elemtype;typedef struct list // 定义结构体链表{float c; // 多项式的常数域elemtype e; // 指数域struct list *next; //指针域}lnode,*linklist; // 结构体名称void create_jisuanqi_linklist(linklist *l) // 初始化结构体{(*l)=(linklist)malloc(sizeof(lnode));(*l)->next= NULL;}void insert_jisuqnai_linklist(linklist l) // 创建结构体{int e,n,i=1;float c;lnode *p=l;printf("How many terms in the polynomial:");scanf("%d",&n); // 输入多项式中的项数while(n){lnode *q=(linklist)malloc(sizeof(linklist));printf("Please input NO.%d's c and e:",i);fflush(stdin); // 清除缓存数据scanf("%f%d",&c,&e); // 分别输入多项式的常数域和指数域q->c=c;q->e=e;p->next=q; // 将结点q 接入链表中q->next=NULL;p=q;n--;i++;}}void chose_jisuanqi_linklist(linklist *l) // 对多项式按指数进行降序排序{lnode *p=(*l)->next;lnode *q=(lnode *)malloc(sizeof(linklist)); // 定义一个结点，用于循环比较指数域的值int tempc,tempe;while(p!=NULL)// 一直循环，直到遍历完链表中所有结点{q=p;while(q!=NULL){if(p->e<q->e) // 交换两节点中的常数和指数域的值{tempe=p->e;tempc=p->c;p->e=q->e;p->c=q->c;q->e=tempe;q->c=tempc;}q=q->next; // 指针下移}p=p->next;}}lnode *add_jisuanqi_linklist(linklist a,linklist b)// 执行多项式A与B相加{linklist c; // 定义一个链表C 用于存放两个多项式的和int x;create_jisuanqi_linklist(&c); // 创建该多项式lnode *p1=a->next;lnode *p2=b->next;lnode *t=c;t->next=NULL;lnode *p3=t;while(p1) // 遍历两个多项式中所有结点，找到指数域相同的结点，将其常数域相加存放到链表C中{p2=b->next;while(p2){if(p1->e==p2->e){lnode *q=(lnode *)malloc(sizeof(lnode));x=p1->c+p2->c;// 将常数域相加q->c=x;q->e=p1->e;p3->next=q;q->next=NULL;p3=q;break;}elsep2=p2->next;}p1=p1->next;}p1=a->next; // 指针复位指向头结点的nextwhile(p1) // 链表a与c比较，将a中指数域的值未在c中出现的结点连接在链表c后{lnode *q=t->next;while(q){if(p1->e!=q->e)q=q->next;else break;}if(q==NULL){lnode *q1=(lnode *)malloc(sizeof(lnode));q1->c=p1->c;q1->e=p1->e;p3->next=q1;q1->next=NULL;p3=q1;}p1=p1->next;}p2=b->next;while(p2) // 链表a与c比较，将a中指数域的值未在c 中出现的结点连接在链表c后{lnode *q=t->next;while(q){if(p2->e!=q->e)q=q->next;else break;}if(q==NULL){lnode *q2=(lnode *)malloc(sizeof(lnode));q2->c=p2->c;q2->e=p2->e;p3->next=q2;q2->next=NULL;p3=q2;}p2=p2->next;}chose_jisuanqi_linklist(&c); // 对链表c进行安指数降序排序return t; // 返回c的头结点}lnode *jian_jisuanqi_linklist(linklist a,linklist b) // 执行多项式A与B相减{linklist c;int x;create_jisuanqi_linklist(&c);lnode *p1=a->next;lnode *p2=b->next;lnode *t=c;t->next=NULL;lnode *p3=t;while(p1){p2=b->next;while(p2){if(p1->e==p2->e){lnode *q=(lnode *)malloc(sizeof(lnode));x=p1->c-p2->c; // 将两个多项式的常数项相减q->c=x;q->e=p1->e;p3->next=q;q->next=NULL;p3=q;break;}elsep2=p2->next;}p1=p1->next;}p1=a->next;while(p1){lnode *q=t->next;while(q){if(p1->e!=q->e)q=q->next;else break;}if(q==NULL){lnode *q1=(lnode *)malloc(sizeof(lnode));q1->c=p1->c;q1->e=p1->e;p3->next=q1;q1->next=NULL;p3=q1;}p1=p1->next;}p2=b->next;while(p2){lnode *q=t->next;while(q){if(p2->e!=q->e)q=q->next;else break;}if(q==NULL){lnode *q2=(lnode *)malloc(sizeof(lnode));q2->c=p2->c;q2->e=p2->e;p3->next=q2;q2->next=NULL;p3=q2;}p2=p2->next;}chose_jisuanqi_linklist(&c);return t;}void display_jisuanqi_linklist(linklist l) // 输出链表{lnode *p=l->next;printf("%3.1f^%d",p->c,p->e);p=p->next;while(p){if(p->c>0) // 如果多项式的常数项大于0，则在输出项前面加一个“+”{printf("+%3.1f^%d",p->c,p->e);p=p->next;}else if(p->c<0) // 如果多项式的常数项小于0，则输出原式{printf("%3.1f^%d",p->c,p->e);p=p->next;}else// 常数项为0，不输出p=p->next;}printf("\n");}#include"stdio.h"#include"stdlib.h"#include"conio.h"#include"jisuanqi_linklist.h"void main() // 主函数{linklist a,b,c,d;int k;start: printf("\n\t\t\t欢迎使用多项式计算器系统\n"); // 进入系统提示do{printf("\t|*********************************************************|\n"); // 选择模块printf("\t| 1.输入多项式A、B,并对其进行指数降序排列|\n");printf("\t| 2.输出多项式A 、B|\n");printf("\t| 3.计算多项式C=A+B|\n");printf("\t| 4.计算多项式D=A-B|\n");printf("\t| 5.输出多项式C、D|\n");printf("\t| 0.退出系统|\n");printf("\t|*********************************************************|\n") ;printf("\t 选择功能选项:");scanf("%d",&k); // 输入要选择的功能选项switch(k) // 对号调用子函数{case 1: system("cls"); // 清屏{create_jisuanqi_linklist(&a);insert_jisuqnai_linklist(a);chose_jisuanqi_linklist(&a);create_jisuanqi_linklist(&b);insert_jisuqnai_linklist(b);chose_jisuanqi_linklist(&b);} system("cls");break;case 2:system("cls");{printf("Polynomial A is:\n");display_jisuanqi_linklist(a);display_jisuanqi_linklist(b);getch();} system("cls");break;case 3:system("cls");{c=add_jisuanqi_linklist(a,b);printf("Calculae polynomialC=A+B is successful!!");getch();} system("cls");break;case 4:system("cls");{d=jian_jisuanqi_linklist(a,b);printf("Calculae polynomial C=A-B is successful!!");getch();}system("cls");break;case 5:system("cls");{printf("Polynomial C is:\n");display_jisuanqi_linklist(c);display_jisuanqi_linklist(d);getch();} system("cls");break;case 0:system("exit");exit(0);default:system("cls");goto start;}}while(1);}。
一元稀疏多项式计算器(安冬)
数据结构课程设计学院：信息科学与工程学院专业：计算机科学与技术班级：计算机1006班学号： 20101221001学生姓名：安冬指导教师：王永燕2012 年 3 月 12 日目录一、实验题目的描述与要求 (1)二、总体设计及环境说明、工具等 (1)三、详细设计：本题所需数据结构与模块说明 (1)四、调试过程、测试数据、运行结果及对结果的分析等 (6)五、自我评析与总结 (7)六、程序代码 (7)数据结构课程设计一、实验题目的描述与要求建立一元多项式并按照指数降序排列输出多项式，将一元多项式输入并存储在内存中，能够完成两个多项式的加减运算并输出结果一元稀疏多项式简单计算器的功能是：1.输入并建立多项式；2.输出多项式，输出形式为整数序列：n，c1,e1,c2,e2,………cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列；3.求多项式a、b的导函数；4.计算多项式在x处的值；5.多项式a和b相加，建立多项式a+b；6.多项式a和b相减，建立多项式a-b；7.多项式a和b相乘，建立多项式a*b；8.仿真界面。
二、总体设计及环境说明、工具等三、详细设计：本题所需数据结构与模块说明存储结构：一元多项式的表示在计算机内可以用链表来表示，为了节省存储空间，只存储多项式中系数非零的项。
链表中的每一个结点存放多项式的一个系数非零项，它包含三个域，分别存放该项的系数、指数以及指向下一个多项式项结点的指针。
创建一元多项式链表，对一元多项式的运算中会出现的各种可能情况进行分析，实现一元多项式的相加、相减操作。
typedef struct Polynomial{ //定义多项式的项float coef;//系数int expn;//指数struct Polynomial *next;}*Polyn,Polynomial;1、a+b:构造新的一个多项式pc，不断调用Insert(pc,hdc)函数，在这个过程中就已经对多项式进行了加法运算。
一元稀疏多项式计算器
数据结构课程设计报告课程名称______数据结构_____ 题目名称一元稀疏多项式计算器学生学院_ 计算机学院2012年 07月 01 日一元稀疏多项式计算器1.用了VC6.0，MFC对话框界面编程，下面的LJQList．h和LJQList．cpp是我自己编写的数据结构以及功能操作函数2.源代码LJQList.h的头文件代码：#ifndef LJQLIST#define LJQLIST#include <stdio.h>#include <malloc.h>#include <CString>//多项式链表的结构，第一个链表头的exp值表示为该多项式的项数typedef struct LJQLink{float data;int exp;struct LJQLink *next;}LJQLink,*LJQList;//初始化LJQLinkvoid create(LJQList &L);//插入新的节点次幂为e 系数为dvoid insert(LJQList L,int e,float d);//根据幂数，若存在输出该节点指针，显示该项系数LJQList search(LJQList L,int e);//打印多项式L，以幂数下降为序显示CString changeCString(LJQList L);//A 多项式和B多项式相加，输出到L A+B = Lvoid Add(LJQList &A,LJQList &B,LJQList &L);//A 多项式和B多项式相减，输出到L A-B = Lvoid Cut(LJQList &A,LJQList &B,LJQList &L);//A 多项式和B多项式相乘，输出到L A*B = Lvoid Multiply(LJQList &A,LJQList &B,LJQList &L);//A 多项式的求导函数，并输出到L (A)' = Lvoid Derivation(LJQList A,LJQList &L);//删除以e为次幂的节点void DeleteOne(LJQList &L,int e);//清空该单链表bool clear(LJQList &L);#endif //LJQLIST这里是LJQList.cpp的代码：#include"stdafx.h"#include "LJQList.h"//链表的初始化void create(LJQList &L){L = (LJQList)malloc(sizeof(struct LJQLink));L->next = NULL;L->exp = 0;L->data = 0;}//插入一个新的节点赋值幂数e，系数dvoid insert(LJQList L,int e,float d){LJQList n;n = (LJQList)malloc(sizeof(struct LJQLink));n->exp = e;n->data = d;n->next =NULL;if(n->data==0) free(n); //系数为0的话释放结点else{LJQList q1,q2;q1=L;q2=L->next;while(q2&&n->exp<q2->exp){ //查找插入位置q1=q2;q2=q2->next; }if(q2&&n->exp==q2->exp){//将指数相同相合并q2->data+=n->data;free(n);if(!q2->data){//系数为0的话释放结点L->exp--;q1->next=q2->next;free(q2);}} else{ //指数为新时将结点插入并使项数加1L->exp++;n->next=q2;q1->next=n;}}}//根据幂数，若存在输出该节点指针，显示该项系数LJQList search(LJQList L,int e){LJQList l = L->next;for(;l;l = l->next)if(l->exp ==e) {return l;}return NULL;}//打印多项式L，以幂数下降为序显示CString changeCString(LJQList L){LJQList l;CString s,cs;s = "";if(L->exp){l = L->next;if(l->data ==1) cs.Format(_T("X^%d"),l->exp),s+=cs;else if(l->data ==-1) cs.Format(_T("-X^%d"),l->exp),s+=cs;else cs.Format(_T("%0.1fX^%d"),l->data,l->exp),s+=cs;l = l->next;for(;l;l = l->next){if(l->data ==1) cs.Format(_T("+X^%d"),l->exp),s+=cs;else {if(l->data>=0)cs.Format(_T("+%0.1fX^%d"),l->data,l->exp),s+=cs;else if(l->data != -1) cs.Format(_T("%0.1fX^%d"),l->data,l->exp),s+=cs;else cs.Format(_T("-X^%d"),l->exp),s+=cs;}}}return s;}//A 多项式和B多项式相加，输出到L A+B = Lvoid Add(LJQList &A,LJQList &B,LJQList &L){LJQList la,lb;float d ;int e;la = A->next;lb = B->next;for(la = A->next;la;la = la->next){e = la->exp;d = la->data;insert(L,e,d);}for(lb = B->next;lb;lb = lb->next){e = lb->exp;insert(L,e,d);}}//A 多项式和B多项式相减，输出到L A-B = L void Cut(LJQList &A,LJQList &B,LJQList &L){ LJQList la,lb;float d ;int e;la = A->next;lb = B->next;for(la = A->next;la;la = la->next){e = la->exp;d = la->data ;insert(L,e,d);}for(lb = B->next;lb;lb = lb->next){e = lb->exp ;d = -lb->data ;insert(L,e,d);}}//A 多项式和B多项式相乘，输出到L A*B = L void Multiply(LJQList &A,LJQList &B,LJQList &L){ LJQList la,lb;float d ;int e;la = A->next;lb = B->next;while(la) {for(lb = B->next;lb;lb = lb->next){e = la->exp + lb->exp;d = la->data * lb->data;insert(L,e,d);}la = la->next;}}//A 多项式的求导函数，并输出到L (A)' = L void Derivation(LJQList A,LJQList &L){LJQList l = A->next;float d ;int e;for(;l;l = l->next){e = l->exp-1;insert(L,e,d);}}//删除以e为次幂的节点void DeleteOne(LJQList &L,int e){LJQList l,q;q = L;if( l = search(L,e))if(l->next) {for(;q->next;q = q->next)if(q->next->exp ==l->exp ) {if(!l->next) q->next = NULL;elseq->next = l->next;free(l);L->exp--;}}else {for(;q;q = q->next){if(q->next->exp ==l->exp ) {if(!l->next) q->next = NULL;elseq->next = l->next;free(l);L->exp--;}}}}//清空该单链表用一个递归函数清空bool clear(LJQList &L){if(L->next){LJQList q;q = L->next;if(q) DeleteOne(L,q->exp);clear(L);}else return true;return false;}这里是MFC自动生成的LJQDlg界面类的头文件，里面申明了各种参数，函数// CLJQDlg dialogclass CLJQDlg : public CDialog{// Constructionpublic:CLJQDlg(CWnd* pParent = NULL); // standard constructor// Dialog Data//{{AFX_DATA(CLJQDlg)enum { IDD = IDD_LJQ_DIALOG };int m_edit_exp;CString m_A;CString m_B;float m_edit_data;CString m_Show;int m_Radio_Kind;CString m_Message;int m_RadioAB;//}}AFX_DATA// ClassWizard generated virtual function overrides//{{AFX_VIRTUAL(CLJQDlg)protected:virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support //}}AFX_VIRTUAL// Implementationprotected:LJQList L;LJQList B;LJQList A;HICON m_hIcon;// Generated message map functions//{{AFX_MSG(CLJQDlg)virtual BOOL OnInitDialog();afx_msg void OnPaint();afx_msg HCURSOR OnQueryDragIcon();afx_msg void OnButtonJisuan();afx_msg void OnButtonTianjia();afx_msg void OnButtonClear();afx_msg void OnButtonDel();//}}AFX_MSGDECLARE_MESSAGE_MAP()};这里是LJQDlg.cpp文件的按钮上的各个事件响应函数：//对应的是“”按钮void CLJQDlg::OnButtonJisuan() {// TODO: Add your control notification handler code hereUpdateData(true);if(B->exp ==0|| A->exp ==0 ) MessageBox("A 或B各至少需要添加一次才可以参加计算！");else {clear(L);// TODO: Add your control notification handler code hereswitch(m_Radio_Kind){case 0:Add(A,B,L);m_Show = "A ＋ B ＝";m_Show += changeCString(L);break;case 1:Cut(A,B,L);m_Show = "A － B ＝";m_Show += changeCString(L);break;case 2:Multiply(A,B,L);m_Show = "A × B ＝";m_Show += changeCString(L);break;case 3:Derivation(A,L);m_Show = "对A求导＝";m_Show += changeCString(L);break;}}UpdateData(false);}//对应的是“”按钮void CLJQDlg::OnButtonTianjia(){// TODO: Add your control notification handler code hereUpdateData(true);CString s="";m_Message = "";if(m_edit_exp*10%10 == 0)switch(m_RadioAB){case 0:insert(A,m_edit_exp,m_edit_data);m_A = changeCString(A);m_Message= "当前A多项式共有";s.Format(_T("%d项!"),A->exp);m_Message += s;break;case 1:insert(B,m_edit_exp,m_edit_data);m_B = changeCString(B);m_Message= "当前B多项式共有";s.Format(_T("%d项!"),B->exp);m_Message += s;break;}UpdateData(false);}//对应的是“”按钮void CLJQDlg::OnButtonClear(){UpdateData(true);// TODO: Add your control notification handler code hereswitch(m_RadioAB){case 0:m_A = "";clear(A);m_Message = "清空A成功！";break;case 1:m_B = "";clear(B);m_Message = "清空B成功！";break;}UpdateData(false);}//对应的是“”按钮void CLJQDlg::OnButtonDel(){// TODO: Add your control notification handler code hereUpdateData(true);CString s ="";LJQList l;switch(m_RadioAB){case 0:if(!A->exp) {MessageBox("当前A多项式为空，删除失败！");break;}if( l = search(A,m_edit_exp)){m_Message = "删除A中";s.Format(_T("%d"),l->exp);m_Message +=s;m_Message+="次幂项成功!";m_Message+= "该项系数为";s.Format(_T("%0.1f"),l->data);m_Message +=s;DeleteOne(A,m_edit_exp);break;}else m_Message ="删除失败！A中不存在该次幂项。
一元稀疏多项式简单计算器数据结构
一元稀疏多项式简单计算器数据结构
一元稀疏多项式简单计算器需要输入并建立两个多项式，然后对其进行相加和相减操作，最终输出结果。
为了实现这个功能，可以使用带头结点的单链表来存储多项式，其中每个节点存储一个项的系数和指数。
如果多项式 a 和 b 中有指数相等的两项，则可以直接相加，否则需要对指数更大的项进行插入到该项的前面。
在计算多项式 a 和 b 的和或差时，需要忽略多项式中系数为零的项。
最后，将输出的多项式按照指数的升幂排列，以便于打印输出。
具体实现可以参考博客中提供的参考信息，其中使用了一个Term 类来存储一个项，包括项的系数和指数，以及一个 Polynome 类来存储多项式，包括多项式的头结点和操作。
在 Polynome 类的构造函数和复制构造函数中，初始化多项式的头结点和每一项，同时在复制过程中，将新对象的头结点指向一个相同的链表。
在 Term 类的构造函数中，初始化类成员 ceof 和 exp，以及 next 指针指向下一项。
在 main 函数中，从文件中读取多项式数据，然后对其进行相加和相减操作，并输出结果。
需要注意的是，实现过程中需要考虑多项式的符号问题，即当指数为负数时需要特殊处理。
此外，为了实现仿真界面，可以使用 GUI 库，如 Visual Studio 2017 自带的 MFC 库，来实现计算器的界面设计。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
【问题描述】设计一个一元稀疏多项式简单计算器【基本要求】一元多项式简单计算器的基本功能是：1，输入并建立多项式;2，输出多项式，输出形式为整数序列:n,c1,e1,c2,c2,...,cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列;3,多项式a和b相加，建立多项式a+b;4,多项式a和b相减，建立多项式a-b.【测试数据】1，(2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=(-3.1x^11+11x^9+2x+7)【实现提示】用带表头结点的单链表存储多项式。
#include <stdio.h>#include <malloc.h>typedef struct node{float coef;int expn;struct node *next;}Lnode, *polynmial;void create(polynmial &L); //输入并建立多项式Lvoid display(polynmial L); //显示，输出多项式Lvoid sort(polynmial &L); //多项式L按指数排序void reverse(polynmial &L); //逆置void select(); //用户选择加减操作void add(polynmial La, polynmial Lb, polynmial &Lc); //多项式La,Lb相加void subtract(polynmial La, polynmial Lb, polynmial &Ld); //多项式La减去Lb，结果给Ldvoid create(polynmial &L) //输入并建立多项式L{int i, n;static struct node *p;scanf("%d", &n);L = (struct node *)malloc (sizeof(struct node));L->next = NULL;for(i = 0; i < n; i++){p = (struct node *)malloc(sizeof(struct node));scanf("%f %d", &p->coef, &p->expn);p->next = L->next;L->next = p;}}void display(polynmial L)//显示，输出多项式L {struct node *p, *q;int flag = 0;int k = 0;q = L->next;while(q){if(q->coef != 0)k++;q = q->next;}printf("%d, ", k);p = L->next;if(p->coef != 0){printf("%.1f,%d, ", p->coef, p->expn);flag++;}for(p = p->next; p; p = p->next){if(p->coef != 0){printf("%.1f,%d, ", p->coef, p->expn);flag++;}}if(flag == 0)printf("%d\n", flag);elseprintf("\n");}void sort(polynmial &L)//多项式L按指数排序{polynmial p, q, r, u;p = L->next;L->next = NULL;while(p != NULL){r = L;q = L->next;while((q != NULL) && (q->expn <= p->expn)) {r = q;q = q->next;}u = p->next;r->next = p;p->next = q;p = u;}}void reverse(polynmial &L)//逆置{polynmial H;static struct node *p, *q, *s;H = (struct node*)malloc(sizeof(struct node)); H->next = NULL;p = (struct node*)malloc(sizeof(struct node)); s = L->next;p->coef = s->coef;p->expn = s->expn;p->next = s->next;while(s){p->coef = s->coef;p->expn = s->expn;p->next = s->next;q = H->next;H->next = p;p->next = q;p = (struct node*)malloc(sizeof(struct node)); s = s->next;}p = H->next;q = L->next;while(p){q->coef = p->coef;q->expn = p->expn;q = q->next;p = p->next;}}void select() //用户选择加减操作{printf("请选择加减操作\n");printf("1.两个一元多项式相加\n");printf("2.两个一元多项式相减\n");}void add(polynmial La, polynmial Lb, polynmial &Lc)//多项式La,Lb相加{struct node *pa, *pb;static struct node *pc;Lc = (struct node*)malloc(sizeof(struct node));pa = La->next;pb = Lb->next;Lc->next = NULL;while(pa && pb){pc = (struct node*)malloc(sizeof(struct node));if(pa->expn < pb->expn){pc->next = Lc->next;Lc->next = pc;pc->coef = pa->coef;pc->expn = pa->expn;pa = pa->next;}elseif(pa->expn == pb->expn){pc->next = Lc->next;Lc->next = pc;pc->expn = pa->expn;pc->coef = pa->coef + pb->coef;pa = pa->next;pb = pb->next;}else{pc->next = Lc->next;Lc->next = pc;pc->coef = pb->coef;pc->expn = pb->expn;pb = pb->next;}}while(pa){pc = (struct node*)malloc(sizeof(struct node));pc->next = Lc->next;Lc->next = pc;pc->coef = pa->coef;pc->expn = pa->expn;pa = pa->next;}while(pb){pc = (struct node*)malloc(sizeof(struct node));pc->next = Lc->next;Lc->next = pc;pc->coef = pb->coef;pc->expn = pb->expn;pb = pb->next;}}void subtract(polynmial La, polynmial Lb, polynmial &Ld)//多项式La减去Lb，结果给Ld{struct node *pa, *pb;static struct node *pd;Ld = (struct node*)malloc(sizeof(struct node));pa = La->next;pb = Lb->next;Ld->next = NULL;while(pa && pb){pd = (struct node*)malloc(sizeof(struct node));if(pa->expn < pb->expn){pd->next = Ld->next;Ld->next = pd;pd->coef = pa->coef;pd->expn = pa->expn;pa = pa->next;}elseif(pa->expn == pb->expn){pd->next = Ld->next;Ld->next = pd;pd->expn = pa->expn;pd->coef = pa->coef - pb->coef;pa = pa->next;pb = pb->next;}else{pd->next = Ld->next;Ld->next = pd;pd->coef = pb->coef;pd->expn = pb->expn;pb = pb->next;}}while(pa){pd = (struct node*)malloc(sizeof(struct node)); pd->next = Ld->next;Ld->next = pd;pd->coef = pa->coef;pd->expn = pa->expn;pa = pa->next;}while(pb){pd = (struct node*)malloc(sizeof(struct node)); pd->next = Ld->next;Ld->next = pd;pd->coef = -pb->coef;pd->expn = pb->expn;pb = pb->next;}}int main(){int sign;polynmial La, Lb, Lc, Ld;printf("请输入第一个多项式：\n");create(La);sort(La);printf("请输入第二个多项式：\n");create(Lb);sort(Lb);select();scanf("%d", &sign);switch(sign){case 1:printf("多项式之和为:\n"); add(La, Lb, Lc);sort(Lc);reverse(Lc);display(Lc);break;default:printf("多项式之差为:\n"); subtract(La, Lb, Ld); sort(Ld);reverse(Ld);display(Ld);break;}return 0;}。