一元稀疏多项式简单的计算器
一元稀疏多项式计算器实现（完整实现版详细源码）
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。
一元稀疏多项计算器【加法和减法】
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，如果此时我们采用线性表的顺序存储结构，那么会极大的浪费内存空间。
一个一元稀疏多项式简单计算器
//设计一个一元稀疏多项式简单计算器#include<stdio.h>#include<stdlib.h>struct tagNode{int coef; //多项式的系数int exp; //多项式的指数struct tagNode *next;};typedef struct tagNode Node; //重新定义结点名称typedef struct tagNode* pNode; //重新定义指针名称void TrailInsertList(pNode,int,int); //在链表表尾部插入结点void AddPolynomial(pNode,pNode); //将两个多项式相加void PrintPolynomial(pNode); //打印多项式int main(void){pNode pa,pb;//定义两个头指针pNode pFree;//定义一个释放指针pa=pb=NULL;Node heada,headb; //定义两个头结点heada.coef=headb.coef=0; //头结点的coef作为结点的个数heada.exp=headb.exp=-1; //头结点的exp无意义故赋给其-1的值heada.next=headb.next=NULL;//让头指针指向头结点pa=&heada;pb=&headb;int coef=0; //系数int exp =0; //指数//第一个多项式的输入printf("请分别输入第一个多项式的系数和指数，并以输入系数为0作为结束标志!\n");do{printf("系数: ");scanf("%d",&coef);printf("指数: ");scanf("%d",&exp);printf("\n");if(coef!=0)TrailInsertList(pa,coef,exp);}while(coef!=0);//第二个多项式的输入printf("请分别输入第二个多项式的系数和指数，并以输入系数为0作为结束标志!\n");do{printf("系数: ");scanf("%d",&coef);printf("指数: ");scanf("%d",&exp);printf("\n");if(coef!=0)TrailInsertList(pb,coef,exp);}while(coef!=0);AddPolynomial(pa,pb); //将两个多项式相加PrintPolynomial(pa); //打印出相加后的多项式pFree=pa->next;free(pFree); //释放动态申请的内存空间return 0;}void TrailInsertList(pNode pHead,int coef,int exp){pNode trail=NULL; //定义一个指向链表尾部的指针pNode newnode=NULL; //定义一个指向新结点的指针//让trail指针指向尾部的结点trail=pHead;while(trail->next!=NULL){trail=trail->next;}newnode=(struct tagNode *)malloc(sizeof(Node)); //申请一块大小为Node的内存空间if(!newnode) //如果申请失败{printf("Allocte memory failure!\n");exit(1); //退出}//初始化申请的新结点newnode->coef=coef;newnode->exp=exp;newnode->next=NULL;trail->next=newnode; //插入新结点pHead->coef++; //头结点的计算器加一}void AddPolynomial(pNode p1,pNode p2){pNode cur1=p1->next; //链表1,结果存放的地方pNode cur2=p2->next; //链表2pNode pre1=p1;pNode temp=NULL; //临时指针while(cur1!=NULL && cur2!=NULL)//当前两个链表都不为空{if(cur1->exp<cur2->exp)//比较链表1与链表2当前指数大小{pre1=cur1;cur1=cur1->next; //cur1指向下一个结点}else if(cur1->exp==cur2->exp) //链表1与链表2指数相等时{cur1->coef+=cur2->coef;if(cur1->coef!=0){pre1=cur1;}else{pre1->next=cur1->next; //保持链表1的连续性free(cur1);}cur1=pre1->next; //cur1指向要比较的下一个结点//下面是删除指针cur2指向的结点，因为结果已经存放在链表1的结点中temp=cur2;cur2=cur2->next;free(temp);}else //链表1当前结点的指数比链表2的大时{p2->next=cur2->next;cur2->next=cur1;pre1->next=cur2;pre1=cur2;cur2=p2->next;}}if(cur2) //如果链表2比链表1长{pre1->next=cur2;}p2->next=NULL;}void PrintPolynomial(pNode pHead){pNode p; //定义头指针p=pHead;p=p->next;while(p){printf("%dX(%d)",p->coef,p->exp);if(p->next){printf(" + ");}p=p->next;}printf("\n");}。
实验报告——2一元稀疏多项式计算器
(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()
一元稀疏多项式计算器课程设计
软件学院课程设计报告书课程名称数据结构设计题目一元稀疏多项式计算器专业班级软件工程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程序输出。
一元稀疏多项式简单计数器
一元稀疏多项式简单计数器题目：编制一个演示一元稀疏多项式简单计数器的程序完成日期：2015.4.9一、需求分析1.1本演示程序中，多项式是以带头结点的单链表存储的，在单链表中有两个数据域，分别存储多项式的一个节点的系数，指数；还有一个指针域，存储指向下一个节点的指针。
1.2演示程序以用户和计算机的对话方式执行，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运算命令；相应的输入数据和运算结果显示在其后。
1.3程序执行的命令包括：1）构造多项式a;2)构造多项式b；3）输出多项式，并且多项式的序列按指数的降序排列；4）求a+b；5）求a-b；6）求a*b；7) 求多项式a的导函数a’;8）求多项式在x处的值。
1.4测试数据(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)-(-6x^(-3)+5.4x^2-x^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)互换上述测试数据中的前后两个多项式二、概要设计为实现上述程序的功能，应以带头结点的单链表表示多项式。
为此，需要一个抽象数据类型：单链表。
2.1单链表的抽象数据类型定义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。
一个一元稀疏多项式简单计算器课程设计报告
一个一元稀疏多项式简单计算器课程设计报告课程课课课告学院,课程名,称课课班课,学生姓名, ,学号目课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 述概本课程课课用于建立哈夫曼课～课其课行课课、课课以及打印。
一元稀疏多项式简单计数器___实验报告
一元稀疏多项式简单计数器题目：编制一个演示一元稀疏多项式简单计数器的程序班级：计算机科学与技术1301班姓名：刘濛学号：201321091026 完成日期：2015.4.9一、需求分析1.1本演示程序中，多项式是以带头结点的单链表存储的，在单链表中有两个数据域，分别存储多项式的一个节点的系数，指数；还有一个指针域，存储指向下一个节点的指针。
1.2演示程序以用户和计算机的对话方式执行，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运算命令；相应的输入数据和运算结果显示在其后。
1.3程序执行的命令包括：1）构造多项式a;2)构造多项式b；3）输出多项式，并且多项式的序列按指数的降序排列；4）求a+b；5）求a-b；6）求a*b；7) 求多项式a的导函数a’;8）求多项式在x处的值。
1.4测试数据(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)-(-6x^(-3)+5.4x^2-x^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)互换上述测试数据中的前后两个多项式二、概要设计为实现上述程序的功能，应以带头结点的单链表表示多项式。
为此，需要一个抽象数据类型：单链表。
2.1单链表的抽象数据类型定义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。
一元稀疏多项式简单计算器
一、课程设计概述：本次数据结构课程设计共完成五个题：一元稀疏多项式计算器、迷宫问题、成绩分析问题、图的基本操作与实现以及背包问题的求解使用语言：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;}}[调试分析]本程序主要的操作对象是记录数组，使用的存储结构是结构体数组。
数据结构 一元稀疏多项式计算器
一、课程题目一元稀疏多项式计算器二、需求分析1、一元稀疏多项式简单计算器的功能是：1.1 输入并建立多项式；1.2 输出多项式，输出形式为整数序列：n，c1,e1,c2,e2,………cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列；1.3多项式a和b相加，建立多项式a+b；1.4多项式a和b相减，建立多项式a-b。
1.5多项式a和b相乘，建立乘积多项式ab。
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在原来的链表上后移。
实验报告(实验二：一元稀疏多项式计算器)
云南大学软件学院实验报告指导教师：朱艳萍 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、程序比较复杂，算法思想也很难理清，需要多加锻炼。
一元稀疏多项式计算器
#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);}。
一元稀疏多项式计算器实验报告(c++编写,附源代码)
一元稀疏多项式计算器实验报告级班年月日姓名学号_1 •实验题目设计一个一元稀疏多项式简单计算器。
2 •需求分析本程序用VC编写，实现一元浮点系数，整数指数稀疏多项式的创建、两个一元多项式相加、两个一元多项式相减、输出一元多项式。
①输入的形式和输入值的范围：A. 输入指定的数字，以此选择两个多项式的运算方式，运算方式有两个一元多项式相加、两个一元多项式相减。
B. 创建多项式时，需要输入此多项式，每一项的系数和指数。
②输出的形式：每次输入一个完整的多项式后、每次得出多项式运算结果时，会以指定的方式输出多项式。
③程序所能达到的功能：实现一元稀疏多项式的创建、两个一元多项式相加、两个一元多项式相减、输出一元多项式。
④测试数据：输入数据：A. 出现选择两个多项式的运算方式菜单时，输入 1 （即使两个多项式相加）；B. 首先输入多项式p的每一项系数和指数，当输入的指数为-5000时，表示该多项式输入完毕，输入的数据依次为：3, 3, 0, -5000 ;C•其次输入多项式q的每一项系数和指数，输入数据依次为：2, 2, 0, -5000。
输出结果：多项式q+p的结果为：多项式为：3 23x +2x3 •概要设计1）为了实现上述程序功能，需要定义多项式结点的抽象数据类型：class Term{数据对象：floatcoef;该数据对象为多项式一项中的系数。
intexp;该数据对象为多项式一项中的指数。
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表示指向下一个多项式结点的指针)。
一元稀疏多项式简单计算器
数据结构课程设计系别计算机与通信工程学院专业计算机科学与技术班级学号姓名/raichen 指导教师成绩2012年7 月12 日一、需求分析1、问题描述：（需求分析和背景意义）设计一个一元稀疏多项式简单计算器.2、基本要求：（设计阶段，概要设计和详细设计）一元稀疏多项式简单计算器的基本功能是:(1)输入并建立多项式;(2)输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,…,cn,en,其中n是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序排列;(3)多项式a和b相加,建立多项式a+b;(4)多项式a和b相减,建立多项式a-b.3、测试数据：(2x+5x8-3.1x11)+(7-5x8+11x9)=(-3.1x11+11x9+2x+7)(6x-3-x+4.4x-2-1.2x9)-(-6x-3+5.4x2-x2+7.8x15)(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5)(x+x3)+(-x-x3)=0(x+x100)+(x100+x200)=(x+2x100+x200)(x+x2+x3)+0=x+x2+x3互换上述测试数据中的前后两个多项式4、实现提示：用带表头结点的单链表存储多项式5、选做内容：(1)计算多项式在x处的值.(2)求多项式a的导函数a′.(3)多项式a和b相乘,建立乘积多项式ab.(4)多项式的输出形式为类数学表达式.例如,多项式-3x8+6x3-18的输出形式为-3x∧8+6x∧3 -18,x15+(-8)x7-14的输出形式为x∧15-8x∧7-14.注意,系数值为1 的非零次项的输出形式中略去系数1,如项1x8的输出形式为x8,项-1x3的输出形式为-x3.(5) 计算器的仿真界面.二、详细设计本程序采用VS2010编写，开始创建了一个工程，本程序的文件有：头文件：define.h 用以定义全局变量function.h 用以声明函数源文件：function.cpp 用以定义函数main.cpp 主函数下面罗列每个文件主要代码define.h#ifndef DEFINE_H#define DEFINE_H#include<iostream>using namespace std;#include<stdlib.h>struct linklistmultinomial{float a;int e;struct linklistmultinomial *next;};typedef struct linklistmultinomial *linklist,node;#endiffunction.h#ifndef FUNCTION_H#define FUNCTION_H#include"define.h"void welcome();void goodbye();linklist createlinklist(linklist head,int n);void insert(linklist p,linklist head);void printlinklist(linklist head);void addlinklist(linklist pa,linklist pb);void sublinklist(linklist pa,linklist pb);void dlinklist(linklist pa);void calclinklista(linklist pd,int x);void menu();#endiffunction.cpp#include"define.h"//欢迎界面void welcome(){cout<<"\n\n\n\n\n";cout<<"*********************************************************************\n\n"<<endl ;cout<<" 一元稀疏多项式计算器\n\n"<<endl;cout<<" 制作者：王雨辰学号：4100113 \n\n"<<endl;cout<<"*********************************************************************\n\n\n\n\n\n\ n";cout<<" 请输入请求\n\n"<<endl;cout<<" 1.进入计算器0.退出\n\n"<<endl;}//结束界面void goodbye(){system("cls");cout<<"\n\n\n\n\n"<<endl;cout<<"*********************************************************************\n\n"<<endl ;cout<<" 谢谢使用，再见\n\n"<<endl;cout<<"*********************************************************************\n\n\n\n\n\n\ n";}//创建链表后按照次方从大到小插入void insert(linklist p,linklist head){if(p->a==0) free(p);else{linklist p1,p2;p1=head;p2=p1->next;while(p2&&p2->e>p->e){p1=p2;p2=p2->next;}if(p2&&p2->e==p->e){p2->a=p2->a+p->a;free(p);if(p2->a==0){p1->next=p2->next;free(p2);}}else{p->next=p2;p1->next=p;}}}//创建链表linklist createlinklist(linklist head,int n){linklist p;int i;p=head=(linklist)malloc(sizeof(node));head->next=NULL;for(i=1;i<=n;i++){p=(linklist)malloc(sizeof(node));cout<<"请输入第"<<i<<"项系数"<<endl;cin>>p->a;cout<<"请输入第"<<i<<"项指数"<<endl;cin>>p->e;insert(p,head);}return head;}//输出函数void printlinklist(linklist head)s{linklist p=head->next;if(!p) cout<<"0";else //处理首项，若系数为正，省略+{if(p->a==1){if(p->e==0) cout<<"1";else cout<<"x^"<<p->e;}elseif(p->a==0);elseif(p->a<0){if(p->e==0) cout<<p->a;else cout<<p->a<<"x^"<<p->e;}else{if(p->e==0) cout<<p->a;else cout<<p->a<<"x^"<<p->e;}p=p->next;}while(p){if(p->a==1){if(p->e==0) cout<<"+1";else cout<<"+x^"<<p->e;}elseif(p->a==-1){if(p->e==0) cout<<"-1";else cout<<"-x^"<<p->e;}elseif(p->a==0);elseif(p->a<0){if(p->e==0) cout<<p->a;else cout<<p->a<<"x^"<<p->e;}else{if(p->e==0) cout<<'+'<<p->a;else cout<<'+'<<p->a<<"x^"<<p->e;}p=p->next;}cout<<endl;}//a+bvoid addlinklist(linklist pa,linklist pb){linklist pc;linklist p1,p2,p3,p;p3=pc=(linklist)malloc(sizeof(node));p1=pa->next;p2=pb->next;if(!(p1||p2)) p3->next=NULL;else{while(p1||p2){p=p3->next=(linklist)malloc(sizeof(node));if(p1==NULL) {p->a=p2->a;p->e=p2->e;p2=p2->next;}else if(p2==NULL) {p->a=p1->a;p->e=p1->e;p1=p1->next;}else{if(p1->e==p2->e){p->a=p1->a+p2->a;p->e=p1->e;p1=p1->next;p2=p2->next;}else if(p1->e>p2->e) {p->a=p1->a;p->e=p1->e;p1=p1->next;}else if(p1->e<p2->e) {p->a=p2->a;p->e=p2->e;p2=p2->next;}}if(p->a==0) free(p);else p3=p;}p3->next=NULL;}printlinklist(pc);}//a-bvoid sublinklist(linklist pa,linklist pb){linklist pc;linklist p1,p2,p3,p;p3=pc=(linklist)malloc(sizeof(node));p1=pa->next;p2=pb->next;if(!(p1||p2)) p3->next=NULL;else{while(p1||p2){p=p3->next=(linklist)malloc(sizeof(node));if(p1==NULL) {p->a=p2->a;p->e=p2->e;p2=p2->next;}else if(p2==NULL) {p->a=p1->a;p->e=p1->e;p1=p1->next;}else{if(p1->e==p2->e) {p->a=p1->a-p2->a;p->e=p1->e;p1=p1->next;p2=p2->next;}else if(p1->e>p2->e) {p->a=p1->a;p->e=p1->e;p1=p1->next;}else if(p1->e<p2->e) {p->a=-p2->a;p->e=p2->e;p2=p2->next;} }if(p->a==0) free(p);else p3=p;}p3->next=NULL;}if(pc->next->next==NULL&&pc->next->a==0) //若a-b=0，输出0 cout<<"0"<<endl;else printlinklist(pc);}//对a求导void dlinklist(linklist pa){linklist pd;linklist p1,p4;p1=pa->next;p4=pd=(linklist)malloc(sizeof(node));while(p1!=NULL){p4->next=(linklist)malloc(sizeof(node));p4=p4->next;if(p1->e==0) {p4->a=0;p4->e=0;}else if(p1->e==1) {p4->a=p1->a;p4->e=0;}else {p4->e=p1->e-1;p4->a=p1->a*p1->e;}p1=p1->next;}p4->next=NULL;printlinklist(pd);}//计算多项式在x处的值void calclinklista(linklist pe,int x){int sum=0,t,i;linklist p5;for(p5=pe->next;p5;p5=p5->next){t=1;for(i=p5->e;i!=0;){if(i<0){t/=x;i++;}//指数小于0，进行除法else{t*=x;i--;}//指数大于0，进行乘法}sum+=p5->a*t;}cout<<sum<<endl;}//菜单void menu(){int m,n,q=1,x;linklist pa=0,pb=0;cout<<"请输入多项式a的项数"<<endl;cin>>m;pa=createlinklist(pa,m);cout<<"请输入多项式b的项数"<<endl;cin>>n;pb=createlinklist(pb,n);cout<<"*********************************************************************\n\n"<<endl ;cout<<" 功能表\n\n "<<endl;cout<<" 1.输出多项式 a 2.输出多项式 b "<<endl;cout<<" 3.输出a+b 4.输出a-b "<<endl;cout<<" 5.输出a的导数 6.计算多项式a在x处的值"<<endl;cout<<" 7.计算多项式b在x处的值0.返回主菜单\n\n"<<endl;cout<<"*********************************************************************\n\n\n\n\n\n\ n";while(q!=0){cout<<"请输入命令"<<endl;cin>>q;switch(q){case 1:printlinklist(pa);break;case 2:printlinklist(pb);break;case 3:addlinklist(pa,pb);break;case 4:sublinklist(pa,pb);break;case 5:dlinklist(pa);break;case 6:cout<<"输入x"<<endl;cin>>x;calclinklista(pa,x);break;case 7:cout<<"输入x"<<endl;cin>>x;calclinklista(pb,x);break;case 0:q=0;break;default:cout<<"输入错误，请重新输入"<<endl;}}}三、调试分析在这个程序写完后的调试过程中，出现了以下问题：1、printlinklist函数刚开是测试会出现首项系数为正，带加号的情况，加了个选择后解决此问题。
一元多项式计算器设计与实现
一元稀疏多项式简单计算器一、设计课题设计一元稀疏多项式简单计算器。
二、需求分析2.1 输入的形式和输入值的范围：输入是从键盘输入的，输入的内容为多项式的系数和指数，数为任意的整数，指数为大于等于0的整数2.2 输出的形式从屏幕输出，显示用户输入的多项式，并显示多项式加减以后的多项式的值。
2.3 程序所能达到的功能a：输入并建立多项式；b：输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,……,cn,en,其中n是多项式的项数，ci和ei 分别是第i项的系数和指数，序列按指数降序排列；c：多项式a和b相加，建立多项式a+b；d：多项式a和b相减，建立多项式a-b；2.4 测试数据（1）(2x+5x^8-3.1x^11)+(7-5x^8+11x^9) = (-3.1x^11+11X^9+2X+7)（2）(X+X^3)+(-X-X^3)=0（3）(X+X^2+X^3)+0= X+X^2+X^3三、概要设计3.1 设计思路A：数据结构的选用为了实现任意多项式的加法、减法，因此选择单链表的结构体，它有一个系数，指数，下一个指针3个元属；单链表抽象结构类型定义见附录2。
B：多项式的输入采用头节点插法的方式，输入多项式中一个项的系数和指数，就产生一个新的节点，建立起它的右指针，并用头节点指向它；为了判断一个多项式是否输入结束，定义一个结束标志，当输入非00时就继续，当输入00时，就结束一个多项式的输入；C：2个多项式的加法它从2个多项式的头部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相加；相加的和不为0的话，用头插法建立一个新的节点。
p的系数小于q的系数的话，就应该复制q接点到多项式中。
p的系数大于q的系数的话，就应该复制p接点到多项式中。
当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生。
当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生D：2个多项式的减法它从2个多项式的头部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相减；相加的和不为0的话，用头插法建立一个新的节点。
设计一元稀疏多项式的简单计数器
#include<stdio.h>#include<malloc.h>#include<iostream.h>typedef struct Polynode{float coef; //系数int exp; //指数struct Polynode *next;}*Poly,Polynode; //Poly为结点指针类型void Insert(Poly p,Poly head){if(p->coef==0) //系数为0时释放结点free(p);else{Poly q1,q2;q1=head;q2=head->next;while(q2&&p->exp<q2->exp){ //后移查找插入位置q1=q2;q2=q2->next;}if(q2&&p->exp==q2->exp){ //将指数相同的相合并q2->coef+=p->coef;free(p);if(!q2->coef) //系数为0时释放结点{q1->next=q2->next;free(q2);}}else{p->next=q2;q1->next=p;}}} //InsertPoly CreateList(Poly head,int m){ //建立一个头指针为head、项数为m 的一元多项式int i;Poly p;Polynode *q;p=head=(Poly)malloc(sizeof(struct Polynode));head->next=NULL;for(i=0;i<m;i++){p=(Poly)malloc(sizeof(struct Polynode)); //建立新结点以接收数据printf("请输入第%d项的系数和指数:", i+1);scanf("%f %d",&p->coef,&p->exp);Insert(p,head); //调用Insert函数插入结点}q=head->next;while(q!=NULL){q=q->next;}return head;} //CreatePolyvoid DestroyList(Poly p){ //销毁多项式pPoly q1,q2;if(p->next!=NULL){q1=p->next;q2=q1->next;while(q1->next){free(q1);q1=q2; //指针后移q2=q2->next;}}}int OutputList(Poly P){ //输出多项式Poly q=P->next;int flag=1; //项数计数器if(!q){ //若多项式为空，输出0 printf("0");return(0);}while (q){if(q->coef>0&&flag!=1) //系数大于0且不是第一项printf("+");if(q->coef!=1&&q->coef!=-1) //系数非1或-1的普通情况{printf("%.f",q->coef);if(q->exp==1)printf("X");else if(q->exp)printf("X^%d",q->exp);}else{if(q->coef==1){if(!q->exp)printf("1");else if(q->exp==1)printf("X");else if(q->exp)printf("X^%d",q->exp);}if(q->coef==-1){if(!q->exp)printf("-1");else if(q->exp==1)printf("-X");else printf("-X^%d",q->exp);}}q=q->next;flag++;} //while printf("\n");return(0);}//OutputPolyint compare(Poly a,Poly b){if(a&&b){if(!b||a->exp>b->exp) return 1;else if(!a||a->exp<b->exp) return -1;else return 0;}else if(!a&&b) return -1; //a多项式已空，但b多项式非空else return 1; //b多项式已空，但a多项式非空}//comparePoly AddPoly(Poly pa,Poly pb){ //求解并建立和多项式a+b，返回其头指针Poly qa=pa->next;Poly qb=pb->next;Poly headc,hc,qc;hc=(Poly)malloc(sizeof(struct Polynode)); //建立头结点hc->next=NULL;headc=hc;while(qa||qb){qc=(Poly)malloc(sizeof(struct Polynode));switch(compare(qa,qb)){case 1:{qc->coef=qa->coef;qc->exp=qa->exp;qa=qa->next;break;}case 0:{qc->coef=qa->coef+qb->coef;qc->exp=qa->exp;qa=qa->next;qb=qb->next;break;}case -1:{qc->coef=qb->coef;qc->exp=qb->exp;qb=qb->next;break;}}//switchif(qc->coef!=0){qc->next=hc->next;hc->next=qc;hc=qc;}else free(qc); //当相加系数为0时，释放该结点}//whilereturn headc;}//AddPolyPoly SubtractPoly(Poly pa,Poly pb){ //求解并建立和多项式a-b，返回其头指针Poly qa=pa->next;Poly qb=pb->next;Poly headc,hc,qc;hc=(Poly)malloc(sizeof(struct Polynode)); //建立头结点hc->next=NULL;headc=hc;while(qa||qb){qc=(Poly)malloc(sizeof(struct Polynode));switch(compare(qa,qb)){case 1:{qc->coef=qa->coef;qc->exp=qa->exp;qa=qa->next;break;}case 0:{qc->coef=qa->coef-qb->coef;qc->exp=qa->exp;qa=qa->next;qb=qb->next;break;}case -1:{qc->coef=-qb->coef;qc->exp=qb->exp;qb=qb->next;break;}} //switchif(qc->coef!=0){qc->next=hc->next;hc->next=qc;hc=qc;}else free(qc); //当相减系数为0时，释放该结点} //whilereturn headc;} //AddPolyint main(){int m,n,flag=0;Poly pa=0,pb=0,pc,pd;//输出菜单printf("************************************************************************* *\n");printf(" 1.输入多项式2.输出多项式a和b 3.建立多项式a+b 4.建立多项式a-b 5.退出程序\n");printf("************************************************************************* *\n");for(;;flag=0){printf("执行操作为:") ;scanf("%d",&flag);if(flag==1){//定义各式的头指针，pa与pb在使用前付初值NULLprintf("请输入a的项数:") ;scanf("%d",&m);pa=CreateList(pa,m); //建立多项式aprintf("请输入b的项数:" );scanf("%d",&n);pb=CreateList(pb,n); //建立多项式b }if(flag==2){printf("多项式a为:");OutputList(pa);printf("多项式b为:");OutputList(pb);continue;}if(flag==3){pc=AddPoly(pa,pb);printf("多项式a+b为：");OutputList(pc);DestroyList(pc);continue;}if(flag==4){pd=SubtractPoly(pa,pb);printf("多项式a-b为：");OutputList(pd);DestroyList(pd);continue;}if(flag==5)break;if(flag<1||flag>5)printf("输入错误!!!请重新选择!!\n");continue;}DestroyList(pa);DestroyList(pb);return 0;}。
数据结构课程设计1 (1)
1.一元稀疏多项式计算器(不选)[问题描述]设计一个一元稀疏多项式简单计算器。
[基本要求]输入并建立多项式；输出多项式，输出形式为整数序列：n, c1, e1, c2, e2,……, cn, en ，其中n是多项式的项数，ci, ei分别是第i项的系数和指数，序列按指数降序排序；多项式a和b相加，建立多项式a+b;多项式a和b相减，建立多项式a-b;[测试数据](2x+5x8-3.1x11)+(7-5x8+11x9)=(-3.1x11+11x9+2x+7)(6x-3-x+4.4x2-1.2x9)-(-6x-3+5.4x2-x2+7.8x15)=(-7.8x15-1.2x9-x+12x-3)(1+x+x2+x3+x4+x5)+(-x3-x4)=(x5+x2+x+1)(x+x3)+(-x-x3)=0(x+x2+x3)+0=(x3+x2+x)[实现提示]用带头结点的单链表存储多项式，多项式的项数存放在头结点中。
2.背包问题的求解（一人）[问题描述]假设有一个能装入总体积为T的背包和n件体积分别为w1, w2, …,wn的物品，能否从n件物品中挑选若干件恰好装满背包，即使w1+w2+…+wn=T，要求找出所有满足上述条件的解。
例如：当T=10，各件物品的体积为{1，8，4，3，5，2}时，可找到下列4组解：（1，4，3，2）、（1，4，5）、（8，2）、（3，5，2）[实现提示]可利用回溯法的设计思想来解决背包问题。
首先，将物品排成一列，然后顺序选取物品转入背包，假设已选取了前i件物品之后背包还没有装满，则继续选取第i+1件物品，若该件物品“太大”不能装入，则弃之而继续选取下一件，直至背包装满为止。
但如果在剩余的物品中找不到合适的物品以填满背包，则说明“刚刚”装入背包的那件物品“不合适”，应将它取出“弃之一边”，继续再从“它之后”的物品中选取，如此重复，直至求得满足条件的解，或者无解。
由于回溯求解的规则是“后进先出”因此自然要用到栈。
一元稀疏多项式简单计算器数据结构
一元稀疏多项式简单计算器数据结构
一元稀疏多项式简单计算器需要输入并建立两个多项式，然后对其进行相加和相减操作，最终输出结果。
为了实现这个功能，可以使用带头结点的单链表来存储多项式，其中每个节点存储一个项的系数和指数。
如果多项式 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．一元稀疏多项式简单的计算器（实验类型：综合型）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);}实验心得：无。