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

合集下载

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

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

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

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

多项式b,c类似输出。

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

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

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

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

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

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

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()

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

数据结构实验报告——一元稀疏多项式计算器安子烨PB12203079实验目的实现一元多项式的简单运算功能，掌握线性表的知识，提高编程能力。

功能清单1.一元多项式创建2.显示一元多项式3.复制一元多项式4.多项式加法5.多项式减法6.修改一元多项式7.删除一元多项式8.销毁记录实验设计该多项式计算器以菜单驱动的形式实现上述各运算功能。

最多可支持十条记录，分别用指针数组引导存储于十个不同的位置。

以下为程序的部分源代码。

#include<stdio.h>#include<math.h>#include<stdlib.h>typedef struct LinkList{double coef;int expn;LinkList *next;}LNode;void CreatPolyn(LinkList **h)//创建多项式{LinkList *q=NULL, *w=NULL, *p=NULL;double m=0; int n=0;(*h)=(LinkList *)malloc(sizeof(LinkList));(*h)->coef=0; (*h)->expn=0; (*h)->next=NULL;printf("请输入X的系数和指数,当系数为零时结束创建\n");scanf("%lf%d",&m,&n);while(m!=0){q=(LinkList *)malloc(sizeof(LinkList));q->coef=m; q->expn=n; q->next=NULL;if((*h)->next==NULL){if(q->expn==(*h)->expn) (*h)->coef+=q->coef;else if((*h)->expn>q->expn) {q->next=(*h); *h=q; } else (*h)->next=q;}else{for(w=(*h);w->next!=NULL;w=w->next){if(q->expn==w->expn){w->coef+=q->coef;break;}else if((w->expn>q->expn)&&(w==*h)){q->next=(*h);(*h)=q;break;}else if((w->expn<q->expn)&&(w->next->expn>q->expn)){q->next=w->next;w->next=q;break;}}if(w->next==NULL){if(w->expn==q->expn) w->coef+=q->coef;else if(w->expn<q->expn) w->next=q;}}printf("请输入X的系数和指数,当系数为零时结束创建\n");scanf("%lf%d",&m,&n);}}void PrintPolyn(LinkList *p, int i)//打印多项式{printf("第%d个多项式是:",i);while(p!=NULL){if((p->coef)>0) printf("+%lf*X^%d",p->coef,p->expn);else if((p->coef)<0) printf("%lf*X^%d",p->coef,p->expn); p=p->next;}printf("\n");}void CopyPolyn(LinkList **M, LinkList **N)//多项式复制{LinkList *p=NULL, *q=NULL, *w=NULL;(*N)=(LinkList *)malloc(sizeof(LinkList));(*N)->coef=(*M)->coef; (*N)->expn=(*M)->expn; (*N)->next=NULL;for(w=(*N),p=(*M)->next;p!=NULL;p=p->next){q=(LinkList *)malloc(sizeof(LinkList));q->coef=p->coef; q->expn=p->expn; q->next=p->next;w->next=q; w=w->next;}}void AddPolyn(LinkList *M, LinkList *N, LinkList **X)//多项式加法{LinkList *p=NULL, *q=NULL, *w=NULL, *z=NULL;(*X)=(LinkList *)malloc(sizeof(LinkList));(*X)->coef=0; (*X)->expn=0; (*X)->next=NULL;for(p=M,q=N,w=(*X);(p!=NULL)&&(q!=NULL);){z=(LinkList *)malloc(sizeof(LinkList));if(p->expn<q->expn){z->coef=p->coef; z->expn=p->expn; z->next=NULL;p=p->next; w->next=z; w=w->next;}else if(p->expn>q->expn){z->coef=q->coef; z->expn=q->expn; z->next=NULL;q=q->next; w->next=z; w=w->next;}else if(p->expn==q->expn){z->coef=p->coef+q->coef; z->expn=p->expn; z->next=NULL;p=p->next; q=q->next; w->next=z; w=w->next;}}if(p==NULL){for(;q!=NULL;){z=(LinkList *)malloc(sizeof(LinkList));z->coef=q->coef; z->expn=q->expn; z->next=NULL;q=q->next; w->next=z; w=w->next;}}else if(q==NULL){for(;p!=NULL;){z=(LinkList *)malloc(sizeof(LinkList));z->coef=p->coef; z->expn=p->expn; z->next=NULL;p=p->next; w->next=z; w=w->next;}}for(w=(*X);w!=NULL;w=w->next){printf("%lf %d\n",w->coef,w->expn);}}void SubtractPolyn(LinkList *M, LinkList *N, LinkList **X)//多项式减法{LinkList *p=NULL, *q=NULL, *w=NULL, *z=NULL;(*X)=(LinkList *)malloc(sizeof(LinkList));(*X)->coef=0; (*X)->expn=0; (*X)->next=NULL;for(p=M,q=N,w=(*X);(p!=NULL)&&(q!=NULL);){z=(LinkList *)malloc(sizeof(LinkList));if(p->expn<q->expn){z->coef=p->coef; z->expn=p->expn; z->next=NULL;p=p->next; w->next=z; w=w->next;}else if(p->expn>q->expn){z->coef=-q->coef; z->expn=q->expn; z->next=NULL;q=q->next; w->next=z; w=w->next;}else if(p->expn==q->expn){z->coef=p->coef-q->coef; z->expn=p->expn; z->next=NULL;p=p->next; q=q->next; w->next=z; w=w->next;}}if(p==NULL){for(;q!=NULL;){z=(LinkList *)malloc(sizeof(LinkList));z->coef=-q->coef; z->expn=q->expn; z->next=NULL;q=q->next; w->next=z; w=w->next;}}else if(q==NULL){for(;p!=NULL;){z=(LinkList *)malloc(sizeof(LinkList));z->coef=p->coef; z->expn=p->expn; z->next=NULL;p=p->next; w->next=z; w=w->next;}}/*for(w=(*X);w!=NULL;w=w->next){printf("%lf %d\n",w->coef,w->expn);}*/}void ValuePolyn(LinkList *h, double x)//多项式求值{double sum=0, a=0;while(h!=NULL){a=pow(x,h->expn);sum=sum+(h->coef)*a;h=h->next;}printf("所求多项式的值为%lf\n",sum);}void DeletePolyn(LinkList **h){LinkList *p=(*h)->next; (*h)=NULL;while(p!=NULL){free(*h);(*h)=p;p=p->next;}}void RevisePolyn(LinkList **h, int i){int n=0;int choose=0;double m=0;LinkList *q=NULL, *w=NULL;PrintPolyn((*h),i);printf("请输入你想执行的操作代号（添加：1；修改：2；删除：3）\n");scanf("%d",&choose);switch(choose){case 1:{printf("输入你想要添加项的系数和次数\n");scanf("%lf%d",&m,&n);q=(LinkList *)malloc(sizeof(LinkList));q->coef=m; q->expn=n; q->next=NULL;for(w=(*h);w->next!=NULL;w=w->next){if((w->expn>q->expn)&&(w==*h)){q->next=(*h);(*h)=q;break;}else if((w->expn<q->expn)&&(w->next->expn>q->expn)) {q->next=w->next;w->next=q;break;}}if(w->expn<n) w->next=q;break;}case 2:{printf("输入你想要修改项的系数和次数\n");scanf("%lf%d",&m,&n);for(w=(*h);w!=NULL;w=w->next){if(w->expn==n) w->coef=m;}printf("未找到该项。

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

1．一元稀疏多项式简单的计算器（实验类型：综合型）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功能模块图为实现上述程序功能,用带表头结点的单链表存储多项式。

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

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

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

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

一元稀疏多项式计算器实习报告[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表示指向下一个多项式结点的指针）。

一元稀疏多项式实验报告

华北水利水电学院数据结构实验报告2010～2011学年第一学期 09 级计算机科学与技术专业班级：学号：姓名：一、实验目的：实现一元稀疏多项式的输出及简单运算。

加强对链表插入的理解。

二、实验要求：一元稀疏多项式简单计算器的基本功能是：（1）输入并建立多项式。

（2）输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,…,cn,en,其中n是多项式的项数，ci,ei分别是i项的系数和指数，序列按指数降序排列；（3）多项式a和b相加，建立多项式a+b;(4) 多项式a和b相减，建立多项式a-b.三、实验内容：1、(2x+5x8-3.1x11)+(7-5x8+11x9)=(-3.1x11+11x9+2x+7);2、(6x-3-x+4.4x2-1.2x9+1.2x9)-(-6x-3+5.4x2-x2+7.8x15)=(-7.8x15-1.2x9+12x-3-x);3、(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5);4、(x+x3)+(-x-x3)=0;5、(x+x100)+(x100+x200)=(x+2x100+x200);6、(x+x2+x3)+0=x+x2+x3.四、程序源代码#include<stdio.h>#include<stdlib.h>typedef struct polynomial{float cofe; //系数int expn; //指数struct polynomial *next;}*polyn,polynomial;void Insert(polyn p,polyn h){if (p->cofe==0)free(p);else{polyn q1,q2;q1=h;q2=h->next;while (q2&&p->expn<q2->expn){q1=q2;q2=q2->next;}if(q2&&p->expn==q2->expn){q2->cofe+=p->cofe;free(p);if(!q2->cofe){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(polynomial)); head->next=NULL;for(i=0;i<m;i++){p=(polyn)malloc(sizeof(polynomial));printf("输入第%d项的系数与指数：",i+1);scanf("%f%d",&p->cofe,&p->expn);Insert(p,head);}return head;}void Printfpolyn(polyn p){polyn q=p->next;int flag=1;if(!q){putchar('0');printf("\n");return;}while(q){if(q->cofe>0&&flag!=1)putchar('+');if(q->cofe!=1&&q->cofe!=-1){printf("%g",q->cofe);if(q->expn==1)putchar('x');else if(q->expn)printf("x^%d",q->expn);}else{if(q->cofe==1){if(!q->expn)putchar('1');else if(q->expn==1)putchar('x');else printf("x^%d",q->expn );}if(q->expn==-1){if(!q->expn)printf("-1");else if(q->expn==1)printf("-x");elseprintf("-x^%d",q->expn);}}q=q->next;flag++;}}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 return 1;}polyn Addpolyn(polyn pa,polyn pb){polyn qa=pa->next;polyn qb=pb->next;polyn headc,hc,qc;headc=hc=(polyn)malloc(sizeof(polynomial));hc->next=NULL;while(qa||qb){qc=(polyn)malloc(sizeof(polynomial));switch(Compare(qa,qb)){case 1:{qc->cofe=qa->cofe;qc->expn=qa->expn;qa=qa->next;break;}case 0:{qc->cofe=qa->cofe+qb->cofe;qc->expn=qa->expn;qa=qa->next;qb=qb->next;break;}case -1:{qc->cofe=qb->cofe;qc->expn=qb->expn;qb=qb->next;break;}}if(qc->cofe!=0){qc->next=hc->next;hc->next=qc;hc=qc;}elsefree(qc);}return headc;}polyn Subpolyn(polyn pa,polyn pb){polyn h=pb;polyn p=pb->next ;polyn pd;while(p){p->cofe*=-1;p=p->next;}pd=Addpolyn(pa,h);for(p=h->next;p;p=p->next){p->cofe*=-1;}return pd;}void main(){int m,n,a;char flag;polyn pa=0,pb=0,pc;printf("输入a的项数:");scanf("%d",&m);pa=Createpolyn(pa,m);printf("输入b的项数:");scanf("%d",&n);pb=Createpolyn(pb,n);printf("A:输出多项式a： B:输出多项式b：");printf("C:输出a+b: D:输出a-b:");while(a){printf("选择操作:\n");getchar();scanf("%c",&flag);switch(flag){case 'A':case 'a':{printf("多项式a=");Printfpolyn(pa);break;}case 'B':case 'b':{printf("多项式b=");Printfpolyn(pb);break;}case 'C':case 'c':{pc=Addpolyn(pa,pb);printf("a+b=");Printfpolyn(pc);break;}case 'D':case 'd':{pc=Subpolyn(pa,pb);printf("a-b=");Printfpolyn(pc);break;}default:printf("选择错误！");}}return 0;}五、运行结果六、小结（不少于100字）1刚开始的时候由于对多项式的减法考虑不周全，代码很复杂，后来经过仔细思考，减法时把每项的系数变成它的相反数，然后调用加法的函数即可，但是实现了减法之后要把系数恢复，不然会影响后面的运算。

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

云南大学软件学院实验报告指导教师：朱艳萍 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。

课程设计报告(一元稀疏矩阵计算器)

目录一、课程题目 (3)二、设计目的 (3)三、需求分析 (3)四、总体设计 (3)五、详细设计 (2)六、实现部分 (3)七、程序测试 (3)八、设计总结 (12)一、课程题目一元稀疏多项式计算器二、设计目的掌握稀疏矩阵的相关运算。

掌握广义表的操作。

三、需求分析一元稀疏多项式简单计算器的基本功能是：输入并建立多项式；输出多项式,输出形式为整数序列：n,c1,e1,,c2,e2 ……cn,en,其中n是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序排列。

多项式a和b相加,建立多项式a+b多项式a和b相减,建立多项式a-b四、总体设计创建两个类，把一个作为另一个的友元类！两个类分别是listnode和polynomial！创建一个链表，包括指数，次数以及下一个结点信息，然后利用冒泡排序法进行排序，排完之后输出多项式！最后一个环节就是进行多项式的最原始运算，即加减运算！其中运用的内容包括链表知识，冒泡排序的知识！五、详细设计类listnode中包含friend class polynomial、double coef、int exp、listnode *next！类polynomial包含poly(); void printpoly();void bubblesort();polynomial operator+(polynomial &p1); polynomial operator-(polynomial &p1);在这个程序设计中，为了实现多项式的运算必须首先创建两个多项式，存储多项式的存储结构是链表，其结构如下：else if(p->exp<q->exp){double m;int n;m=p->coef;p->coef=q->coef;q->coef=m;n=p->exp;p->exp=q->exp;q->exp=n;s=q;q=q->next;｝再就是实现多项式的加减法运算，在加减法运算中为了实现处理，设p、q分别指向单链表的两个多项式，比较p、q结点的指数项，由此得到下列运算规则：①若p->exp<q->exp，则结点p所指的结点应是“和多项式”中的一项，令指针p后移。

一元稀疏多项式简单计数器___实验报告

一元稀疏多项式简单计数器题目：编制一个演示一元稀疏多项式简单计数器的程序班级：计算机科学与技术1301班姓名：刘濛学号：1026 完成日期：一、需求分析本演示程序中，多项式是以带头结点的单链表存储的，在单链表中有两个数据域，分别存储多项式的一个节点的系数，指数；还有一个指针域，存储指向下一个节点的指针。

演示程序以用户和计算机的对话方式执行，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运算命令；相应的输入数据和运算结果显示在其后。

程序执行的命令包括：1）构造多项式a;2)构造多项式b；3）输出多项式，并且多项式的序列按指数的降序排列；4）求a+b；5）求a-b；6）求a*b；7) 求多项式a的导函数a’;8）求多项式在x处的值。

测试数据(1)（2x+5x^^11）+（7-5x^8+11x^9）=^11+11x^9+2x+7)(2)(6x^(-3)-x+^^9)-(-6x^(-3)+^2-x^2-x^2+^15)=^^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)互换上述测试数据中的前后两个多项式二、概要设计为实现上述程序的功能，应以带头结点的单链表表示多项式。

为此，需要一个抽象数据类型：单链表。

单链表的抽象数据类型定义ADT LinkList{数据对象：D={ai|ai∈TermSet,i=1,2,…,m,m≥0TermSet中的每个元素包含一个表示系数的实数和表示指数的整数}数据关系：R1={<ai-1,ai>ai-1,ai∈D且ai-1中的指数值<ai中的指数值,i=2,…,n}基本操作：CreatLinkList(&p,m)操作结果：输入m项的系数和指数，建立一元多项式p。