一元稀疏多项式计算器实验(报告程序)

合集下载

一元稀疏多项计算器【加法和减法】

Data Structure.实习报告【实习一线性表、堆栈和队列的应用】一元稀疏多项式运算器Xiaohui HuangChina University of Geosciences(Wuhan) , Wuhan,Wuhan , Hubei Province , China ;Email : hxh1994@/hxh20111003570@1.问题描述设计一个一元稀疏多项式简单计算器。

要求为：（1）输入并建立两个多项式；（2）多项式a与b相加，建立和多项式c；（3）多项式a与b相减，建立和多项式d；（4）输出多项式a,b,c,d。

输出格式：比如多项式a为：A(x)=c1x e1+ c2x e2+…+ c m x em，其中，c i 和e i分别为第i项的系数和指数，且各项按指数的升幂排列，即0≤e1＜e2＜…＜e m。

2.设计◆设计思想我们知道，一个一元多项式可表示为A(x)=a0+a1x+a2x2+⋯+a n x n 其中，a0、a1、a2、…、a n为多项式的系数，惟一确定了这个多项式，而每一项的指数这隐藏在系数a i的序号中了。

那么我们可以使用线性表(a0、a1、a2、…、a n)来表示。

设A=(a0、a1、a2、…、a n)，B=(b0、b1、b2、…、b n)，则多项式的加法就相当于A+B=C，其中，C=(c0、c1、c2、…、c n)，其中c i=a i+b i。

◆概要设计从设计思想我们可以得知我们这个程序的主要功能是模拟计算器的加法和减法功能。

那么问题就归结于创建两个线性表，通过线性表相对应元素的相加减来模拟计算器的功能。

现在的问题是：我们应该选择什么类型的线性表、我们应该选择线性表的哪一种存储结构。

通过我们所学习的知识可以知道，我们有线性表、堆栈和队列等来可供选择，而经过考虑后，多项式的建立应该使用一种线性结构，故我们选择线性表。

另一方面，我们知道一个多项式并不是每一项的系数是存在的，比如一个只含有两个项的多项式，其中，一个项的指数是1，一个项的指数是1000，如果此时我们采用线性表的顺序存储结构，那么会极大的浪费内存空间。

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

课程设计报告1.需求分析【问题描述】设计一个一元稀疏多项式简单计算器.【基本要求】一元稀疏多项式基本功能包括：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；【测试数据】1)(2x+5x8-3.1x11)+(11x9-5x8+7)=(-3.1x11+11x8+2x+7)2)(-1.2x9+6x-3+4.4x2-x)-(7.8x15+4.4x2-6x-3)=(-7.8x15-1.2x9+12x-3-x)3)(x5+x4+x3+x2+x+1)-(-x4-x3)=(x5+x2+x+1)4)(x3+x)-(-x3-x)=05)(x100+x)+(x200+x100)=(x200+2x100+x)6)(x3+x2+x)+0=x3+x2+x7)互换上述测试数据中的前后两个多项式.2.概要设计ADT Polynomial{数据对象: D={a i|a i∈TermSet, i=1,2,…,m,m≥0,TermS et中的每个元素包含一个表示系数的实数和表示指数的整数}数据对象: R1={<a i,a i-1>|a i,a i-1∈D,且a i-1中的指数值小于ai中的指数,i=2,…,m}基本操作：CreatePolyn(void)Result: 指数由大到小输入m项的系数和指数,建立一元多项式pPrintPoly(LNode Head)Result: 输出一元多项式AddPoly(LNode H1,LNode H2)Condition: 一元多项式pa,pb已存在Result: 完成多项式相加运算,即pa=pa+pb,并销毁一元多项式pb.SubtractPoly(LNode H1,LNode H2)Condition: 一元多项式pa,pb已存在Result: 完成多项式相减运算,即pa=pa-pb,并销毁一元多项式pb.}ADT Polynomial3.详细设计【数据类型定义】typedef struct node{int expn,coef;struct node *next;}Nodetype,*LNode; //定义结点类型【函数原型定义】LNode CreatePolyn(void);Void PrintPoly(LNode Head);LNode AddPolyn(LNode H1,LNode H2);LNode SubPolyn(LNode H1,LNode H2);【核心算法描述】CreatePolyn()LNode CreatePolyn(void) //创建表达式{LNode Head,p,pre,pree;int x,z;Head=(LNode)malloc(sizeof(Nodetype));Head->next=NULL;printf("当你输入的系数为0时，输入将结束！\n");printf("请输入第一项系数:");scanf("%d",&x);if(x==0){p=(LNode)malloc(sizeof(LNode));p->coef=0;p->expn=0;Head->next=p;p->next=NULL;}while(x!=0){printf("请输入指数:");scanf("%d",&z);p=(LNode)malloc(sizeof(Nodetype));p->coef=x;p->expn=z;pre=Head;while(pre->next&&pre->next->expn>=z)//原有项指数大于插入项{pree=pre;pre=pre->next;}p->next=pre->next;//插入项pre->next=p;if(pre->expn==p->expn)//原有项指数等于插入项{pre->coef+=p->coef;pre->next=p->next;free(p);}if(pre->coef==0)//系数为0{pree->next=pre->next;free(pre);}printf("请输入系数:");scanf("%d",&x);}if(Head->next==NULL)//多项式空{pre=(LNode)malloc(sizeof(LNode));pre->coef=0;pre->expn=0;pre->next=Head->next;Head->next=pre;}return Head;}PrintPolyn()void PrintPolyn(LNode Head) //输出表达式{LNode pre;pre=Head->next;if(pre->expn==0)//指数为0printf("%d",pre->coef);elseprintf("%d*X(%d)",pre->coef,pre->expn);pre=pre->next;while(pre)//系数不为0{if(pre->expn==0)//指数为0{if(pre->coef>0)printf("+%d",pre->coef);else if(pre->coef<0)printf("%d",pre->coef);}else//指数不为0{if(pre->coef>0)printf("+%d*X(%d)",pre->coef,pre->expn);else if(pre->coef<0)printf("%d*X(%d)",pre->coef,pre->expn);}pre=pre->next;//遍历每一项}printf("\n");}AddPolyn()LNode AddPolyn(LNode H1,LNode H2) //表达式相加{LNode H3,p1,p2,p3,pre;//p1第一个多项式的项，pre p的前一项H3=(LNode)malloc(sizeof(LNode));H3->next=NULL; //建立一个空的多项式p1=H1->next; //第一个多项式的第一项p2=H2->next;pre=H3; //while(p1&&p2){if(p1->expn>p2->expn)//第一个多项式的项的指数大于第二个的{p3=(LNode)malloc(sizeof(LNode));p3->expn=p1->expn;p3->coef=p1->coef;p3->next=pre->next;pre->next=p3;pre=p3;p1=p1->next;}else if(p1->expn<p2->expn)//第一个多项式的项的指数小于第二个的{p3=(LNode)malloc(sizeof(LNode));p3->expn=p2->expn;p3->coef=p2->coef;p3->next=pre->next;pre->next=p3;pre=p3;p2=p2->next;else if(p1->coef+p2->coef!=0)//相加为不0，指数相同系数相加{p3=(LNode)malloc(sizeof(LNode));p3->expn=p1->expn;p3->coef=p1->coef+p2->coef;p3->next=pre->next;pre->next=p3;pre=p3;p1=p1->next;p2=p2->next;}else//相加为0{p1=p1->next;p2=p2->next;}}while(p2){p3=(LNode)malloc(sizeof(LNode));p3->expn=p2->expn;p3->coef=p2->coef;p3->next=pre->next;pre->next=p3;pre=p3;p2=p2->next;}while(p1){p3=(LNode)malloc(sizeof(LNode));p3->expn=p1->expn;p3->coef=p1->coef;p3->next=pre->next;pre->next=p3;pre=p3;p1=p1->next;}return H3;}LNode SubstractPolyn(LNode H1,LNode H2) //表达式相减{//让系数变负，代入加法LNode H3,pre;pre=H2->next;while(pre){pre->coef=-pre->coef;pre=pre->next;}H3=AddPolyn(H1,H2);pre=H2->next;while(pre){pre->coef=-pre->coef;pre=pre->next;}return H3;}【函数调用关系】main()调用CreatePoly()，PrintPoly()，AddPoly()，scanf()函数输入，printf()函数输出。

实验报告——2一元稀疏多项式计算器

2345、z34、
(3)(1+x+x +x +x +x ) +( -x-x )
(4)(x+x2+x3)+0
(5)(x+x3)-(-x-x-3)
⑹(x+x2+x3)+0
三、实验内容
主要算法设计
typedef struct Node
{
float coef;
int in dex;
struct Node *n ext;
{
LinkList *pc;
int flag=0;
while(flag==0)
{
if(pb->next==NULL)
flag=1;
else
{
pb=pb->next;
pc=(LinkList *)malloc(sizeof(LinkList));
pc->coef=-pb->coef; pc->index=pb->index; pc->next=NULL;
主冃主冃斗冃主
2,1
5,B -3.1,11
项式b的项数；3 7,0-5.8ffl-ltb疏多项式计算器
3
»■快I列歹序序1数2数弓整t(展lt4L2^^bm、」丄-TrJ二上M?E--uMr.选项选项选现岀岀岀4-.冷丄#-W
3
nV为===*
,2,1
,7,
请输更入塾项更蠢製扌吐亟人第2项更薑癒吋备入第咗项的系数却1逼△鄴项翌謎I诰倉△第2项更舍魅吐亟人＞项聶入第4项的系数稲
Insert(pc,head);
}
}
return head;
void main()

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

1．一元稀疏多项式简单的计算器（实验类型：综合型）1）问题描述：用线性表表示一元稀疏多项式，设计一个一元多项式运算器2）实验要求:✧采用单链表存储结构一元稀疏多项式✧输入并建立多项式✧输出多项式✧实现多项式加、减运算3) 实现提示：以两个多项式相加为例✧结果多项式另存✧扫描两个相加多项式，若都未检测完：⏹若当前被检测项指数相等，系数相加，若结果未变成0，则将结果插入到结果多项式。

⏹若当前被检测项指数不等，则将指数较小者插入到结果多项式。

若有一个多项式已检测完，则将另一个多项式剩余部分直接连接到结果多项式。

4.一元稀疏多项式简单的计算器（实验类型：综合型）#include<stdio.h>#include<stdlib.h>typedef struct{float coef;//系数int expn;//指数} Term;typedef struct ploynomial{Term term;ploynomial* next;} ploynomial,*LinkList;void InitList(LinkList&L){//初始化链表L= (ploynomial*)malloc(sizeof(ploynomial));//头结点L->term.coef=0.0;L->term.expn=-1; L->next=NULL;}int cmp(Term a,Term b){//比较结点的系数大小函数if(a.expn>b.expn) return -1;else if(a.expn==b.expn) return 0; else return 1;}void insertNode(LinkList&L,Term e){//将结点插入多项式链表的适当位置，可以同时起到创建链表和多项式相加的功能ploynomial* q=L;while(q->next!=NULL){if(cmp(q->next->term,e)<0)//如果当前结点q的下一个结点的指数大于要插入的结点的指数q=q->next;//q指向下一个结点else break;//此时，q.term.expn>e.expn>=q->next->term.expn }if(q->next!=NULL&&cmp(q->next->term,e)==0) //指数相同，系数相加{q->next->term.coef+=e.coef;}else{ploynomial* node =(ploynomial*) malloc(sizeof(ploynomial));node->term.coef=e.coef;node->term.expn=e.expn;if(q->next==NULL)node->next=NULL; //如果q结点为尾结点，则node的指针域设为NULLelsenode->next=q->next; //否则node的指针域指向q的下一个结点q->next=node;//将node结点插入链表中}}void CreatPolyn(LinkList&L,int m){//输入m项的系数和指数，建立表示一元多项式的有序链表L Term e;InitList(L);for(int i=1; i<=m; i++){printf("\n第%d项的系数和指数：",i);scanf("%f%d",&e.coef,&e.expn);insertNode(L,e);}}void addPolyn(LinkList&L,LinkList L1,LinkList L2){//用L返回L1+L2的结果ploynomial* q;for(q=L1->next; q!=NULL; q=q->next){insertNode(L,q->term);//将L1的每一项插入到L中}for(q=L2->next; q!=NULL; q=q->next) //将L2的每一项插入到L 中{insertNode(L,q->term);}}void SubtracatPolyn(LinkList&L,LinkList L1,LinkList L2){//用L返回L1-L2的结果ploynomial* q;for(q=L1->next; q!=NULL; q=q->next){insertNode(L,q->term);//将L1的每一项插入到L中}for(q=L2->next; q!=NULL; q=q->next){q->term.coef = -(q->term.coef); //把系数变成相反数,再进行相加操作，即为L1-L2insertNode(L,q->term);//将L2的每一项插入到L中}}void multiplyPolyn(LinkList&L,LinkList L1,LinkList L2) {//用L返回L1*L2的结果ploynomial *p,*q;Term term;term.coef=0.0;term.expn=0;for(q=L1->next; q!=NULL; q=q->next){for(p=L2->next; p!=NULL; p=p->next){term.coef=(q->term.coef)*(p->term.coef);//系数相乘term.expn=(q->term.expn)+(p->term.expn);// 指数想加insertNode(L,term);}}}void derivativePolyn(LinkList&L,LinkList L1){//用L返回L1的导数ploynomial *p;Term term;for(p=L1->next; p!=NULL; p=p->next){if(p->term.expn==0){ continue;//指数为0时，导数为0 ，跳过此次循环}else{ term.coef=(p->term.coef)*(p->term.expn); //系数乘以指数term.expn=(p->term.expn)-1;//指数减一insertNode(L,term);}}}void visitList(LinkList L){//以类数学表达式的形式打印输出一元多项式L，//即指数或者系数为1的情况下省略1ploynomial* q=L;int flag;while(q->next!=NULL){q=q->next;flag=1;if(q->term.coef==0) continue;//系数为0 不输出if(q->term.expn==0&&flag==1) //指数为1{if(q->term.coef>0)printf("+%.2f",q->term.coef);elseprintf("%.2f",q->term.coef);flag=0;}if((q->term.coef==1||q->term.coef==-1)&&flag==1)//系数为1{if(q->term.expn==1){ if(q->term.coef==1)printf("+X"); elseprintf("-X");}else{if(q->term.coef==1)printf("+X^%d",q->term.expn); elseprintf("-X^%d",q->term.expn); } flag=0;}if(flag==1){ if(q->term.coef>0)printf("+%.2fX^%d",q->term.coef,q->term.expn);elseprintf("%.2fX^%d",q->term.coef,q->term.expn);} } printf("\n");}int main(){LinkList L1,L2; int n1,n2;printf("请输入多项式L1的项数：");scanf("%d",&n1);CreatPolyn(L1,n1);printf("请输入多项式L2的项数：");scanf("%d",&n2);CreatPolyn(L2,n2);printf("\n多项式L1:");visitList(L1);printf("\n多项式L2: ");visitList(L2);LinkListadd,sub,multiply,derivative1,derivative2;InitList(ad d);InitList(sub);InitList(multiply);InitList(derivative1);InitList(derivative2);derivativePol yn(derivative1,L1);derivativePolyn(derivative2,L2);printf("\nL1的导数：");visitList(derivative1);printf("\nL2的导数：");visitList(derivative2);addPolyn(add,L1,L2);SubtracatPolyn(sub,L1,L2);multiplyPolyn(multiply ,L1,L2);printf("\nL1 + L2: ");visitList(add);printf("\nL1 - L2: ");visitList(sub);printf("\nL1 * L2: ");visitList(multiply);}实验心得：无。

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

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

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

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

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

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

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

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

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

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

一元稀疏多项式计算器实习报告[1]

一元稀疏多项式计算器实习报告[1]实习报告题目：设计一个一元稀疏多项式计算器班级: 姓名学号_________完成日期：__一、课程题目一元稀疏多项式计算器二、需求分析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利用链表实现队列的构造。

每次输入一项的系数和指数，可以输出构造的一元多项式3、测试数据：（1）、(2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=(-3.1x^11+11x^9+2x+7);（2）、(6x^-3-x+4.4x^2-1.2x^9+1.2x^9)-(-6x^-3+5.4x^2-x^2+7.8x^15)=(-7.8x^15-1.2x^9+12x^-3-x);（3）、(1+x+x^2+x^3+x^4+x^5)+(-x^3-x^4)=(1+x+x^2+x^5);（4）、(x+x^3)+(-x-x^3)=0;（5）、(x+x^100)+(x^100+x^200)=(x+2x^100+x^200);（6）、(x+x^2+x^3)+0=x+x^2+x^3.三、概要设计1. 有序表的抽象数据类型定义为：ADT List{数据对象：D={ai | ai ∈R,i=1,2,…,n,n ≧0}数据关系：R1={| ai-1, a i ∈D, ai-1,基本操作：InitList()操作结果：构造一个空的有序表L 。

DestroyList(L)初始条件：有序表L 已存在。

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

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

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

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

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

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

2）subtract（多项式减法）：将两个多项式相减并返回结果多项式。

3）multiply（多项式乘法）：将两个多项式相乘并返回结果多项式。

4）differential（求导）：求一个多项式的导数并返回结果多项式。

5）integral（积分）：对一个多项式进行积分并返回结果多项式。

6）evaluate（求值）：给定一个值，计算多项式在该值处的值并返回结果。

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

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

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

一元稀疏多项式计算器实验报告级班年月日学号_1．实验题目设计一个一元稀疏多项式简单计算器。

2．需求分析本程序用VC编写，实现一元浮点系数，整数指数稀疏多项式的创建、两个一元多项式相加、两个一元多项式相减、输出一元多项式。

①输入的形式和输入值的围：A.输入指定的数字，以此选择两个多项式的运算方式，运算方式有两个一元多项式相加、两个一元多项式相减。

B.创建多项式时，需要输入此多项式，每一项的系数和指数。

②输出的形式：每次输入一个完整的多项式后、每次得出多项式运算结果时，会以指定的方式输出多项式。

③程序所能达到的功能：实现一元稀疏多项式的创建、两个一元多项式相加、两个一元多项式相减、输出一元多项式。

④测试数据：输入数据：A.出现选择两个多项式的运算方式菜单时，输入1（即使两个多项式相加）；B.首先输入多项式p的每一项系数和指数，当输入的指数为-5000时，表示该多项式输入完毕，输入的数据依次为：3，3，0，-5000；C．其次输入多项式q的每一项系数和指数，输入数据依次为：2，2，0，-5000。

输出结果：多项式q+p的结果为：多项式为：3x3+2x23．概要设计1)为了实现上述程序功能，需要定义多项式结点的抽象数据类型：class Term{数据对象：float coef; 该数据对象为多项式一项中的系数。

int exp; 该数据对象为多项式一项中的指数。

Term* link; 该数据对象为指向下一个多项式结点的指针。

基本操作：A. Term (float c, int e)初始条件：无操作结果：初始化多项式结点对象，将c赋值给该结点的数据成员coef（表示系数），将e赋值给该结点的数据成员exp（表示指数），将该结点的数据成员link赋值为0。

B.Term (float c, int e, Term* next)初始条件：无操作结果：初始化多项式结点对象，将c赋值给该结点的数据成员coef（表示系数），将e赋值给该结点的数据成员exp（表示指数），将next赋值给该结点的数据成员link（link表示指向下一个多项式结点的指针）。

一个一元稀疏多项式简单计算器课程设计报告

一个一元稀疏多项式简单计算器课程设计报告课程课课课告学院,课程名,称课课班课,学生姓名, ,学号目课1 一元稀疏多课式课算器1.1 述概课了课课任意多课式的加法～法～因此课课课课表的课～有一系～指～下减构体它个数数一指课个个元素3使用课言,课言C课课课境,VC++ 6.01.2 课课容内、课课描述1课课一一元稀疏多课式课课课算器。

个基本要求,一元稀疏多课式课课课算器的基本功能是,;,课入建立多课式～并1;,课出多课式～课出形式课整序列,数～其中是多课式2n,c1,e1,c2,e2,…cn,en,n的课～数分课是第课的系和指～序按指降序排序～数数数数c1,e1,i;,多课式和相加～建立多课式3aba+b;;,多课式和相～建立多课式减4aba-b;;,课算多课式在课的课～5x;,课算器的界面;课做,。

仿真6、需求分析2;,课入的形式和课入课的范课,1课入是课课课入的～课入的容课多课式的系和指～课任意的整～指课大于从内数数数数数等于的整数0;,课出的形式2从屏并减幕课出～课示用课课入的多课式～课示多课式加以后的多课式的课。

;,程序所能到的功能达3,课入建立多课式～并a,课出多课式～课出形式课整序列,数其中是多课式的课数～bn,c1,e1,c2,e2,……,cn,en,n和分课是第课的系和指～序列按指降序排列～数数数cieii,多课式和相加～建立多课式～caba+b,多课式和相～建立多课式减～daba-b,多课式的课出形式课课表式～数学达e,系课课数的非零课的课出形式中略去系数～而的课出形式课。

f11-1x-x1.3 要课课概、存课课构1typedef struct Polynomial { float coef; int expn; struct Polynomial *next;}*Polyn,Polynomial;课课用以存放第构体课的系和指和下一指课～以课课课基课。

数数个i、函数2Polyn CreatePolyn(Polyn head,int m)课函用于建立一课指课课数个～课课数的一元多课式headm课函用于课毁多课式数void DestroyPolyn(Polyn p)课函用于课出多课式数void PrintPolyn(Polyn P) aPolyn AddPolyn(Polyn pa,Polyn pb)课函用于求解建立多课式数并～返回其课指课a+bPolyn SubtractPolyn(Polyn pa,Polyn pb)课函用于求解建立多课式数并～返回其课指课a-bfloat ValuePolyn(Polyn head,int x)课函用于课入数课～课算返回多课式的课并x课函用于比课数和的指数int compare(Polyn a,Polyn b) ab、流程课3一元稀疏多课式课算器课入建立多课式并课出多课式课算多课式在x课的课课算a+b课算a-b课束1.4 课课分析1、课课分析2、行课果运1.5 源程序代课#include<stdio.h>#include<stdlib.h>typedef struct Polynomial { float coef; int expn; struct Polynomial *next;}*Polyn,Polynomial;void Insert(Polyn p,Polyn h) { if(p->coef==0) free(p); else { Polynq1,q2; q1=h; q2=h->next; while(q2&&p->expn<q2->expn) { q1=q2; q2=q2->next; }if(q2&&p->expn==q2->expn) { q2->coef+=p->coef; free(p);if(!q2->coef){q1->next=q2->next;free(q2);}}else{p->next=q2;q1->next=p; } } } Polyn CreatePolyn(Polyn head,int m) { int i; Polyn p;p=head=(Polyn)malloc(sizeof(struct Polynomial)); head->next=NULL;for(i=0;i<m;i++) { p=(Polyn)malloc(sizeof(struct Polynomial));课课入第课的系指数与数用空格隔课printf("%d ,:",i+1);scanf("%f %d",&p->coef,&p->expn); Insert(p,head); } return head; } void DestroyPolyn(Polyn p) {Polyn q1,q2; q1=p->next; q2=q1->next;while(q1->next) { free(q1); q1=q2; q2=q2->next; } }void PrintPolyn(Polyn P) {Polyn q=P->next; int flag=1;if(!q) { putchar('0'); printf("\n"); return; } while(q) { if(q->coef>0&&flag!=1) putchar('+'); if(q->coef!=1&&q->coef!=-1){ printf("%g",q->coef);if(q->expn==1) putchar('X'); else if(q->expn) printf("X^%d",q->expn); }else { if(q->coef==1) { if(!q->expn) putchar('1');else if(q->expn==1) putchar('X'); else printf("X^%d",q->expn); }if(q->coef==-1) { if(!q->expn) printf("-1"); else if(q->expn==1)printf("-X");else printf("-X^%d",q->expn); } } q=q->next; flag++; } printf("\n");} int compare(Polyn a,Polyn b) { if(a&&b) {if(!b||a->expn>b->expn) return 1; else if(!a||a->expn<b->expn)return -1; else return 0; } else if(!a&&b) return -1; else return1; }Polyn AddPolyn(Polyn pa,Polyn pb) {Polyn qa=pa->next; Polyn qb=pb->next; Polyn headc,hc,qc;hc=(Polyn)malloc(sizeof(struct Polynomial)); hc->next=NULL; headc=hc;while(qa||qb) { qc=(Polyn)malloc(sizeof(struct Polynomial));switch(compare(qa,qb)) {case 1: { qc->coef=qa->coef; qc->expn=qa->expn; qa=qa->next; break; } case 0: { qc->coef=qa->coef+qb->coef; qc->expn=qa->expn;qa=qa->next; qb=qb->next; break; }case-1:{qc->coef=qb->coef;qc->expn=qb->expn;qb=qb->next;break;}}if(qc->coef!=0){ qc->next=hc->next; hc->next=qc; hc=qc; }else free(qc); }return headc; }Polyn SubtractPolyn(Polyn pa,Polyn pb) {Polyn h=pb; Polyn p=pb->next; Polyn pd; while(p){ p->coef*=-1; p=p->next; } pd=AddPolyn(pa,h);for(p=h->next;p;p=p->next) p->coef*=-1; return pd;}float ValuePolyn(Polyn head,int x) {Polyn p; int i,t; floatsum=0;for(p=head->next;p;p=p->next){t=1;for(i=p->expn;i!=0;){if(i<0){t/=x;i++;} else{t*=x;i--;} } sum+=p->coef*t; }return sum; }Polyn MultiplyPolyn(Polyn pa,Polyn pb){ Polyn hf,pf; Polyn qa=pa->next; Polyn qb=pb->next;hf=(Polyn)malloc(sizeof(structPolynomial)); hf->next=NULL;for(;qa;qa=qa->next) {for(qb=pb->next;qb;qb=qb->next) {pf=(Polyn)malloc(sizeof(struct Polynomial)); pf->coef=qa->coef*qb->coef;pf->expn=qa->expn+qb->expn; Insert(pf,hf); } } return hf; }void main(){ int m,n,a,x,f,k=1; Polyn pa=0,pb=0,pc; while(k!=0){ 课课入的课数printf("a :"); scanf("%d",&m); pa=CreatePolyn(pa,m);课课入的课数printf("b :"); scanf("%d",&n); pb=CreatePolyn(pb,n);课出多课式课出多课式printf(" * 1:a 2:b \n");代入的课课算代入的课课算printf(" * 3:xa 4:xb\n");课出课出printf(" * 5:a+b 6:a-b\n");课出退出printf(" * 7:a*b 0:\n");课课课操作,while(a) { printf("\n "); scanf(" %d",&f); switch(f) { 多课式case 1: { printf("\na="); PrintPolyn(pa); break; }多课式case 2: { printf("\nb="); PrintPolyn(pb); break; }课入的课,case 3: { printf("xx="); scanf("%d",&x);课 printf("\n x=%da=%.3f\n",x,ValuePolyn(pa,x)); break; }课入的课,case 4: {printf("xx="); scanf("%d",&x);课 printf("\n x=%d b=%.3f\n",x,ValuePolyn(pb,x)); break; } case5:{ pc=AddPolyn(pa,pb); printf("\n a+b="); PrintPolyn(pc); break; } case 6:{ pc=SubtractPolyn(pa,pb);printf("\n a-b="); PrintPolyn(pc); break; }case 7:{ pc=MultiplyPolyn(pa,pb);printf("\na*b=");PrintPolyn(pc); break; }case 0:{ DestroyPolyn(pa); DestroyPolyn(pb); a=0; break; }您的课课课课～课重新课default: printf("\n !\n"); } } } }2 哈夫曼课/课课器2.1 述概本课程课课用于建立哈夫曼课～课其课行课课、课课以及打印。

(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语言实现了一元稀疏多项式计算器，并体验了多项式运算的具体操作。

实验报告(实验二：一元稀疏多项式计算器)

云南大学软件学院实验报告指导教师：朱艳萍 2009秋季学期学号：20081120064 姓名：李雪寒【实验题目】实验2. 一元稀疏多项式简单计算器【问题描述】设计并实现一个一元稀疏多项式的简单计算器。

【基本要求】一元稀疏多项式简单计算器的基本功能是：1.输入并建立多项式；2.输出多项式，序列按指数降序排列；3.多项式a和b相加，并建立多项式a+b；4.多项式a和b相减，并建立多项式a-b；【实现提示】1.用带头节点的单链表作为多项式的存储结构；一、【概要设计】链式存储结构，由于不要求逻辑上相邻的元素在物理上也相邻，因此，能够迅速进行插入或删除操作，而且不像顺序存储结构那样需要移动大量元素，但也没有顺序表那样随机存取的优点。

主程序中通过调用void create(polynmial &L) 创建存储在单链表中的多项式，调用void display(polynmial L); 输出显示多项式，调用void sort(polynmial &L)和void reverse(polynmial &L)对多项式进行排序，使其按降序排列，调用void add(polynmial La,polynmial Lb, polynmial &Lc) 和void subtract(polynmial La, polynmial Lb, polynmial &Ld) 对两个多项式进行加减操作。

二、【详细设计】在此次试验中，主要通过以下7个子函数对存储在单链表中的多项式进行操作：void create(polynmial &L) //输入并建立多项式L{int i, n;static struct node *p;printf("输入多项式项数：\n");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));printf("输入一个项的系数和指数，用空格隔开：\n");scanf("%f %d", &p->c, &p->e);p->next = L->next;L->next = p;}//利用for循环输入多项式中每一项的系数和指数}void display(polynmial L)//显示，输出多项式L{struct node *p, *q;//建立两个结点int flag = 0;int k = 0;q = L->next;while(q){if(q->c!= 0)k++;//计算多项式的项数q = q->next;}printf("共%d项\n", k);//输出多项式的项数p = L->next;if(p->c != 0){printf("+%.1fx^%d", p->c, p->e);flag++;}//判断该项是否为零，不为零则输出for(p = p->next; p; p = p->next){if(p->c != 0){printf("+%.1fx^%d", p->c, p->e);flag++;}}//输出多项式if(flag == 0)printf("%d\n", flag);elseprintf("\n");}void sort(polynmial &L)//多项式L按指数排序{polynmial p, q, r, s;p = L->next;L->next = NULL;while(p != NULL){r = L;q = L->next;while((q != NULL) && (q->e <= p->e)){r = q;q = q->next;}s = p->next;r->next = p;p->next = q;p = s;}}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->c = s->c;p->e = s->e;p->next = s->next;while(s){p->c = s->c;p->e = s->e;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->c = p->c;q->e = p->e;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相加，并付给Lc {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->e < pb->e){pc->next = Lc->next;Lc->next = pc;pc->c = pa->c;pc->e = pa->e;pa = pa->next;}elseif(pa->e == pb->e){pc->next = Lc->next;Lc->next = pc;pc->e = pa->e;pc->c = pa->c + pb->c;pa = pa->next;pb = pb->next;}else{pc->next = Lc->next;Lc->next = pc;pc->c= pb->c;pc->e = pb->e;pb = pb->next;}}while(pa){pc = (struct node*)malloc(sizeof(struct node));pc->next = Lc->next;Lc->next = pc;pc->c = pa->c;pc->e = pa->e;pa = pa->next;}while(pb){pc = (struct node*)malloc(sizeof(struct node));pc->next = Lc->next;Lc->next = pc;pc->c = pb->c;pc->e = pb->e;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->e< pb->e){pd->next = Ld->next;Ld->next = pd;pd->c= pa->c;pd->e = pa->e;pa = pa->next;}elseif(pa->e == pb->e){pd->next = Ld->next;Ld->next = pd;pd->e= pa->e;pd->c = pa->c - pb->c;pa = pa->next;pb = pb->next;}else{pd->next = Ld->next;Ld->next = pd;pd->c = pb->c;pd->e = pb->e;pb = pb->next;}}while(pa){pd = (struct node*)malloc(sizeof(struct node));pd->next = Ld->next;Ld->next = pd;pd->c = pa->c;pd->e = pa->e;pa = pa->next;}while(pb){pd = (struct node*)malloc(sizeof(struct node));pd->next = Ld->next;Ld->next = pd;pd->c = -pb->c;pd->e = pb->e;pb = pb->next;}}三、【测试结果】四、【实验总结】此次实验较实验一来说要难得多，算法也复杂得多，原因主要有：1、C语言的应用很生疏，有待加强；2、对于单链表的插入和删除操作不熟练，需要借助课本和资料进行参考；3、程序比较复杂，算法思想也很难理清，需要多加锻炼。

(完整word版)一元稀疏多项式计算器实验(报告+程序)

一元稀疏多项式计数器预习报告姓名：刘茂学号222012315220062一、实验要求（1)输入并建立多项式；(2）输出多项式，输出形式为整数序列:n，c1，e1，c2，e2……cn，en，其中n是多项式的项数,ci，ei分别为第i项的系数和指数.序列按指数降序排列；（3）多项式a和b相加，建立多项式a+b；（4)多项式a和b相减，建立多项式a—b。

（5）多项式求值;(6）多项式求导；（7）求多项式的乘积。

二、测试数据: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、互换上述测试数据中的前后两个多项式.三、思路分析用带表头结点的单链表存储多项式.本程序要求输入并建立多项式,能够降幂显示出多项式,实现多项式相加相减的计算问题，输采用链表的方式存储链表，定义结点结构体.运用尾差法建立两条单链表，以单链表polyn p 和polyn h分别表示两个一元多项式a和b.为实现处理，设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在原来的链表上后移.四、实验程序//头文件#include〈stdio.h>#include<malloc。

一元稀疏多项式计算器

数据结构课程设计报告课程名称______数据结构_____ 题目名称一元稀疏多项式计算器学生学院_ 计算机学院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中不存在该次幂项。