一元多项式计算器设计与实现

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 LinkL‎i st{数据对象：D＝{ ai | ai∈ElemS‎e t, i=1,2,...,n, n≥0 }数据关系：R1＝{ <ai-1, ai>|ai-1, ai∈D, i=2,...,n }基本操作：InitL‎i st(&L)操作结果：构造一个空‎的线性表L‎。

Destr‎o yLis‎t(&L)初始条件：线性表L已‎存在。

操作结果：销毁线性表‎L。

数据结构课程设计设计题目：一元稀疏多项式计算器专业______________________ 班级______________________ 学号______________________ 姓名______________________ 指导教师___________________2010 年12 月20 H目录一、课程题目 (1)二、需求分析 (1)三、测试数据 (2)四、概要设计 (2)五、调用关系图 (3)六、程序代码 (3)七、测试结果 (11)八、心得体会及总结 (12)数据结构课程设计一、课程题冃一元稀诡多项式计算器二、需求分析1、一元稀疏多项式简单计算器的功能是：1.1输入并建立多项式；1.2输出多项式,输出形式为整数序列:n, cl,el,c2,e2, ......................... c n, en,其中ii是多项式的项数,ci和ei分别是第i项的系数和指数，序列按指数降序排列；1.3求多项式a、b的导函数;1.4计算多项式在x处的值;1.5多项式"和b和加，建立多项认a+b；1.6多项式a和b相减,建立多项式a-b。

2、设计思路：2.1定义线性表的动态分配顺序存储结构;2.2建立多项式存储结构，定义指针*next2.3利用链表实现队列的构造.毎次输入一项的系数和指数，町以输出构造的一元多项式2.4演示程用以用户和计舜机的对话方式执行，即在计舜机终站上显示“提示信息” Z后，由川户化键盘丄输入演示程序小规运的运行•命令；报后根据相应的输入数据〔滤去输入中的4法字符）建立的多项式以及多项式相加的运行结果在屏幕上显示。

多项式显示的格式为:clx*el+c2x*e2+ — +cnx"en3、设计思路分析要解决多项式相加，必须要冇多项式，所以必须首先建立两个多项式，在这电采用链表的方式存储琏表，所以我将结点结构体定义为运川尾插法建立两条单链表，以巾•链表polyn p和polyn h分别表示两个一元多项式a和b, a+b的求和运算等同于单链表的插入问题（将单链表polyn P 中的结点插入到单链表polyn h中），因此“和多项式”中的结点无须另生成。

//设计一个一元稀疏多项式简单计算器#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");}。

数据结构实验报告——一元稀疏多项式计算器安子烨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("未找到该项。

题目：编制一个一元多项式基本运算的程序姓名: 学号:PB110130一、需求分析1．在通常的应用中，多项式的次数可能很高且变化很大，使得顺序存储结构的最大长度很难确定。

由稀疏多项式的特点，故采用链式存储结构，可以不会带来浪费存储空间。

2．程序中单链表存储，根据链表的指数域，对链表进行升序排序，可给运算带来方便。

3．程序设计是在VC6.0环境下设计的的。

4．程序执行的命令为（程序主界面）：二、概要设计抽象数据类型一元多项式的定义如下：1.LNode *MakeNode（double coef, int exp) 通过传入指数和系数创建一个节点,返回该节点的地址。

2.void InitList（LinkList &L）初始化,带头节点3.void PrintPolyn （LinkList L) 传入链表的指针，打印该链表4.LinkList CreatPolyn（void)//输入m项的系数和指数，建立表示一元多项式的有序链表L5.double SumPolyn(LinkList L,double x) 传入链表的指针及x值，求多项式的值。

6.void DestroyPolyn (LinkList &L) 销毁多项式，去掉头节点7.void ClearPolyn (LinkList ＆L) 清空多项式,保留节点实验报告8.void CopyPolyn (LinkList La，LinkList ＆Lb) 将La位置的多项式复制到Lb位置9.void AddPolyn（LinkList L,LinkList J ,LinkList ＆K) 将a和b多项式相加存到c10.void MultiplyPolyn（LinkList L，LinkList J，LinkList ＆K）将a和b相减存到c11. void MultiplyPolyn(LinkList L，LinkList J,LinkList ＆K）将a和b多项式相乘存到c12。

1、课程设计目的1.1、本次课程设计的主要目的是设计一个一元多项式简单计算器，体会链式存存储结构和顺序存储结构各自的优缺点和适用性；1.2、了解并掌握数据结构与算法的设计方法，具备初步的独立分析和设计能力；1.3、初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技1.4、提高综合运用所学的理论知识和方法独立分析和解决问题的能力；1.5、加深对常用数据结构的理解，强化学生的逻辑思维能力和动手能力，巩固良好的编程习惯，掌握工程软件设计的基本方法，为后续课程的学习打下坚实基础。

2、课程设计的准备和功能要求2.1、需求环境本课程设计需要的设备为硬件要求和软件配置要求具体要求如下：①硬件要求：一台计算机。

②软件配置：windows XP或windows 7、VC++6.0。

2.2、目标程序的功能要求集合链式存储结构和顺序存储结构实现一元多项式计算器的设计，并使该计算器具有以下功能：①能够按照多项式变量的指数降序创建一个多项式；②能够对已创建的多项式进行显示；③能够对已创建的多项式之间的加法运算；④能够对已创建的多项式之间的减法运算；⑤能够对已创建的多项式进行删除；⑥能够实现计算器退出操作；2.3、系统总框图3、课程设计过程3.1、菜单界面设计考虑到计算器的操作应具备简易性，我们采取用户和计算机的对话方式执行，即程序运行时，在计算机终端上显示该计算器的功能 菜单栏，其中包括对应的选项共用户选择输入；当用户根据选项中的“提示信息”在键盘上输入多项式的项数及各项的系数和指数，然后 进行显示、相加运算、相减运算、多项式删除以及计算器退出操作。

如下所示：用户菜单多项式的显示多项式的相加多项式的相减多项式的删除退出 菜单多项式的建立3.2、菜单选项的实现对于计算器菜单中各选项的设计处理，我们采用了switch (menu) 语句并将各选项前的数字定义为字符型。

然后根据所输入的不同的memu列出对应的6种case分支情况。

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);}实验心得：无。

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功能模块图为实现上述程序功能,用带表头结点的单链表存储多项式。

课程设计(论文)任务书一、课程设计(论文)题目一元多项式计算器二、课程设计(论文)工作自2011 年 12 月 26 日起至 2011 年 12 月 30 日止三、课程设计(论文) 地点: 创新大楼机房四、课程设计(论文)内容要求：1．本课程设计的目的⑴训练学生灵活应用所学数据结构知识，独立完成问题分析，结合数据结构理论知识，编写程序求解指定问题；⑵初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能；⑶提高综合运用所学的理论知识和方法独立分析和解决问题的能力，巩固、深化学生的理论知识，提升编程水平。

2．课程设计的任务及要求1）基本要求：⑴要求从分析题目的需求入手，按设计抽象数据类型、构思算法、通过设计实现抽象数据类型、编写上机程序和上机调试等若干步骤完成题目，最终写出完整的报告；⑵在程序设计阶段应尽量利用已有的标准函数，加大代码的重用率；⑶程序设计语言推荐使用C/C++，程序书写规范，源程序需加必要的注释；⑷每位同学需提交可独立运行的程序和规范的课程设计报告。

2）课程设计论文编写要求⑴理论设计部分以课程设计论文的形式提交，格式必须按照课程设计论文标准格式进行书写和装订；⑵课程设计报告（论文）包括中文目录、设计任务、需求分析、概要设计、详细设计、编码实现、调试分析、课设总结、谢辞、参考文献、附录等；⑶设计部分应包含系统功能模块图，调试分析应包括运行截图等。

3）课程设计评分标准：⑴学习态度：10分；⑵系统设计：20分；⑶编程调试：20分；⑷回答问题：20分；⑸论文撰写：30分。

4）参考文献：⑴严蔚敏,吴伟民. 数据结构(C语言版)[M]. 清华大学出版社. 2010.3⑵严蔚敏,吴伟民. 数据结构题集(C语言版)[M]. 清华大学出版社. 1999.2⑶何钦铭,冯燕等. 数据结构课程设计[M]. 浙江大学出版社. 2007.85）课程设计进度安排⑴准备阶段（4学时）：选择设计题目、了解设计目的要求、查阅相关资料；⑵程序模块设计分析阶段（4学时）：程序概要设计、详细设计；⑶代码编写调试阶段（8学时）：程序模块代码编写、调试、测试；⑷撰写论文阶段（4学时）：总结课程设计任务和设计内容，撰写课程设计论文。

实习1、一元稀疏多项式计算器一、需求分析1. 问题描述设计一个一元稀疏多项式简单计算器。

2. 基本要求一元稀疏多项式简单计算器的基本功能是：(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 。

3. 测试数据(1) (2x+5x8-3.1x11)+(7-5x8+11x9)=(-3.1x11+11x9+2x+7)(2) (6x-3-x+4.4x2-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)(7) 互换测试数据的前后两个多项式。

4. 实现提示用带表头结点的单链表存储多项式。

二、概要设计为实现上述程序功能，应用带头结点的单链表存储多项式。

为此需要一个抽象数据类型：一元多项式。

1.抽象数据类型一元多项式定义为：ATD Ploynomial{数据对象：D={ai|ai∈Termset, i=1,2,3···，m,m≥0 Termset中的每个元素包含一个表示系数的实数和表示指数的整数}数据关系：R1={<ai-1,ai>ai-1,ai∈D,且ai-1中的指数<ai中的指数的值，i=1,2,3···n} 基本操作：Insert(p,h)初始条件：h已存在。

1、课程设计目的1.1、本次课程设计的主要目的是设计一个一元多项式简单计算器，体会链式存存储结构和顺序存储结构各自的优缺点和适用性；1.2、了解并掌握数据结构与算法的设计方法，具备初步的独立分析和设计能力；1.3、初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技1.4、提高综合运用所学的理论知识和方法独立分析和解决问题的能力；1.5、加深对常用数据结构的理解，强化学生的逻辑思维能力和动手能力，巩固良好的编程习惯，掌握工程软件设计的基本方法，为后续课程的学习打下坚实基础。

2、课程设计的准备和功能要求2.1、需求环境本课程设计需要的设备为硬件要求和软件配置要求具体要求如下：①硬件要求：一台计算机。

②软件配置：windows XP或windows 7、VC++6.0。

2.2、目标程序的功能要求集合链式存储结构和顺序存储结构实现一元多项式计算器的设计，并使该计算器具有以下功能：①能够按照多项式变量的指数降序创建一个多项式；②能够对已创建的多项式进行显示；③能够对已创建的多项式之间的加法运算；④能够对已创建的多项式之间的减法运算；⑤能够对已创建的多项式进行删除；⑥能够实现计算器退出操作；2.3、系统总框图3、课程设计过程3.1、菜单界面设计考虑到计算器的操作应具备简易性，我们采取用户和计算机的对话方式执行，即程序运行时，在计算机终端上显示该计算器的功能 菜单栏，其中包括对应的选项共用户选择输入；当用户根据选项中的“提示信息”在键盘上输入多项式的项数及各项的系数和指数，然后 进行显示、相加运算、相减运算、多项式删除以及计算器退出操作。

如下所示：用户菜单多项式的显示多项式的相加多项式的相减多项式的删除退出 菜单多项式的建立3.2、菜单选项的实现对于计算器菜单中各选项的设计处理，我们采用了switch (menu) 语句并将各选项前的数字定义为字符型。

然后根据所输入的不同的memu列出对应的6种case分支情况。

一元稀疏多项式计算器实验报告级班年月日学号_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表示指向下一个多项式结点的指针）。

//c实现一元多项式运算器#include <stdio.h>#include <stdlib.h>#include <math.h>#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedef struct Polynode{int coef;int exp;struct Polynode *next;}Polynode, *Polylist;void polycreate(Polylist head){Polynode *rear, *n;int c,e;rear=head; // rear 始终指向单链表的尾，便于尾插法建表scanf("%d,%d",&c,&e); //输入多项式的系数和指数项while(c!=0) //若c=0，则代表多项式的输入结束{n=(Polynode*)malloc(sizeof(Polynode)); //申请新的结点n->coef=c;n->exp=e;rear->next=n; //在当前表尾做插入rear=n;scanf("%d,%d",&c,&e);}rear->next=NULL; //将表的最后一个结点的next置NULL，以示表结束}void show(Polylist head){if(head->next==NULL)printf("0");else{printf("%d",head->next->coef);printf("X^%d",head->next->exp);head=head->next->next;while(head!=NULL){if(head->coef>0) printf("+%d",head->coef);else printf("%d",head->coef);printf("X^%d",head->exp);head=head->next;}}printf("\n\n");}void polyadd(Polylist polya, Polylist polyb){Polynode *p, *q, *temp;int sum;Polylist r;p=polya->next; //令 p和q分别指向polya和polyb多项式链表的第一个结点q=polyb->next;r=polya; // r指向和多项式的尾结点r->next=NULL;temp=r;while (p!=NULL && q!=NULL) //当两个多项式均未扫描结束时{if(p->exp < q->exp) //若p的指数小于q的指数，将p加入到和多项式中{r->next=p;r=p;p=p->next;}else if ( p->exp == q->exp) //若指数相等，则相应的系数相加{sum=p->coef + q->coef;if (sum != 0){p->coef=sum;r->next=p;r=p;p=p->next;temp=q;q=q->next;free(temp);}else{temp=p;p=p->next;free(temp); //若系数和为零，则删除p与q，并指向下一结点temp=q;q=q->next;free(temp);}}else{r->next=q;r=q; //将q结点加入到和多项式中q = q->next;}}if(p!=NULL) //多项式A中还有剩余，则将剩余的结点加入到和多项式中r->next=p;else //否则，将B中的结点加入到和多项式中r->next=q;}void caculate(Polylist head){float x,sum=0;printf("请输入X的值:");scanf("%f",&x);while(head->next!=NULL){sum=sum+head->next->coef*pow(x,head->next->exp);head=head->next;}printf("\n多项式结果为:%f\n",sum);}int main(){Polylist polya,polyb;int flag;Polynode *p;printf("请输入数据建立多项式A:(以0,0结束!)\n");polya=(Polynode *)malloc(sizeof(Polynode));polycreate(polya);printf("\n输入的多项式A为:");show(polya);printf("请输入数据建立多项式B:(以0,0结束!)\n");polyb=(Polynode *)malloc(sizeof(Polynode));polycreate(polyb);printf("\n输入的多项式B为:");show(polyb);printf("\t1:代数式相加\n");printf("\t2:代数式相减\n\n");printf("请选择运算类型:");scanf("%d",&flag);if(flag==1) //加法计算{polyadd(polya,polyb);printf("\n相加后的多项式为:");}else //要计算减法，将多项式B的各项系数置为相反数后求和{p = polyb;while(p->next!=NULL){p->next->coef=-p->next->coef;p=p->next;}polyadd(polya,polyb);printf("\n相减后的多项式为:");}show(polya);caculate(polya);return 0;}。

一元稀疏多项式计算器c语言一、背景。

在计算机领域中，一元稀疏多项式是一种较为重要的数据类型，它广泛应用于科学计算、图像处理等领域。

由于传统计算方法需要大量时间和计算资源，因此研究一种高效的一元稀疏多项式计算器显得十分重要。

二、需求分析。

基于以上背景，我们需要完成以下需求：1.实现一元稀疏多项式的基本运算，如加、减、乘、除法等。

2.实现一元稀疏多项式的系数排序，可以按照任意顺序排列。

3.实现一元稀疏多项式的表示方式，可供用户输入和输出。

三、设计方案。

为了满足以上需求，我们可以采用以下设计方案：1.多项式基本结构。

为了处理一元稀疏多项式的各种运算，我们需要为多项式定义一个基本的数据结构。

这个结构需要包含多项式的各项系数、指数、项数等信息。

我们可以采用数组或链表等方式实现这个数据结构。

2.多项式运算。

为了完成多项式的加、减、乘、除法等运算，我们需要实现相应的算法。

这些算法包括基于快速傅里叶变换的多项式乘法、除法等。

3.系数排序。

为了满足用户不同的需求，我们需要实现多项式系数的排序功能。

由于用户可以选择任意的顺序，我们需要保证排序算法的稳定性和高效性。

4.多项式表示。

为了方便用户输入和输出多项式，我们需要设计一个简洁易用的多项式表示方式。

用户可以根据需要选择带有系数和指数的输入方式，也可以选择只输入系数或指数。

四、实现细节。

为了优化计算效率和减少内存占用，我们可以在实现多项式运算时采用以下方法：1.采用链表存储多项式的数据结构，可以有效减少内存占用和复制开销。

2.对于多项式的加、减、乘、除法等运算，我们可以根据具体情况选择合适的运算算法。

如多项式加减可以直接遍历链表进行计算；多项式乘法可以使用快速傅里叶变换等算法。

3.为了提高排序效率，我们可以采用基于快速排序、归并排序等的排序算法。

对于多项式系数相同时，可以使用指数作为比较因素。

五、总结。

通过以上设计方案和实现细节，我们可以实现一个高效的一元稀疏多项式计算器。

(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、程序比较复杂，算法思想也很难理清，需要多加锻炼。

一元多项式计算器目录摘要 (1)1绪论 (1)2系统分析 (1)2.1功能需求 (1)2.2数据需求 (1)2.3性能需求 (1)3总体设计 (1)3.1系统设计方案 (1)3.2功能模块设计 (2)4详细设计 (3)4.1建立多项式 (3)4.2多项式相加 (4)4.3多项式相减 (4)4.4多项式相乘 (5)4.5计算器主函数 (6)5调试与测试 (7)5.1调试 (7)5.2测试 (8)6结论 (9)结束语 (9)参考文献 (9)附录1－用户手册 (10)附录2－源程序 (12)摘要随着生活水平的提高，现代科技也日益发达。

日常生活中多位计算再所难免，因此设计一个简单计算器可解决许多不必要的麻烦。

开发这样一个程序主要运用了C的结点，链表等方面知识。

系统主要实现了多项式的建立，多项式的输入输出，以及多项式加减乘等运算。

报告主要从计算器的程序段，对输入输出数据的要求，计算器的性能，以及总体的设计来介绍此计算器程序的实现过程。

关键词：多项式；链表；结点1绪论随着日益发达的科技，计算器已应用于各行各业。

设计一个计算器需要运用C中多方面知识，更是以多项式的建立，输入输出，以及结点，链表为主。

（扩充）任务书。

2系统分析2.1 功能需求多项式的建立多项式输入输出多项式加减乘等运算2.2数据需求在输入过程中，首先要确定输入的数据，数据不能是字母，只能是数字。

不能连续输入数据，必须按要求配以空格输入要计算的数据。

(1) 链节节点数字(2) 数字2.3 性能需求系统必须安全可靠，不会出现无故死机状态，速度不宜过慢。

3总体设计3.1系统设计方案采用菜单设计，选择你需要的功能，用单链表储存你输入的数据。

(1) 菜单菜单包括计算器加减乘等功能的选择(2) 文件保存方式运用带头节点的单链表储存多项式(3) 抽象数据类型定义主要定义多项式的系数和指数。

系数项用浮点类型定义，指数项用整型定义(4) 存储结构采用链式结构，建立链表储存输入的多项式(5) 算法设计运用链表知识，建立链表，给链表分配一定量的存储空间，查找链表，插入链表和链表的连接3.2功能模块设计图1功能模块图(1)建立多项式模块该模块分为①建立多项式②输入多项式(2)多项式相加模块该模块是将输入的多项式实现相加功能。

一元多项式加法一、实验目的通过实现多项式加法，对链表有更深入的了解二、实验内容问题描述：设计一个一元稀疏多项式简单的加法计算器实现要求：一元稀疏多项式简单计算器的基本功能是：（1）输入并建立多项式：1785937)(x x x x A +++=；879228)(x x x x B -+=（2）输出多项式（3）多项式A 和B 相加，建立多项式C ＝A ＋B ，并输出相加的结果多项式C（4）选作：多项式A 和B 相减，建立多项式C ＝A －B ，并输出相减的结果多项式D 方法说明：（1）多项式的输入与存储用带表头结点的单链表存储多项式，链表中的每个节点分别存储多项式各项的系数和指数，即每从键盘输入多项式的一对数（系数，指数），可对应建立链表的一个结点。

每个节点的结构为：建立两个链表，其中pa 和pb 分别为它们的头指针：pb结果链表Pa(或者是Pc)Pc（2）多项式数据类型的定义struct tagNode{float coef;int exp;struct tagNode *next;typedef struct tagNode Node;typedef struct tagNode* pNode;（3）主要算法①创建两个链表，分别存放多项式1和多项式2，这两个链表中的节点是按指数降序或者升序排列的②多项式相加，下面给出多项式相加的部分实现/*下面的函数实现两个多项式的相加，要相加的链表分别由pa和pb指向（其中，pa，pb都是分配了空间的头结点）。

相加的结果直接由pa指向的链表保存，即是在pa链表中添加或删除（当系数因为相加为0的情况下）一些结点，构成结果。

相加的链表中指数按从小到大的顺序排列好的，是升序链表。

*/void add_poly(Node *pa,Node *pb){Node *p=pa->pNext;//链表1，将来的结果也放在此Node *q=pb->pNext;//链表2Node *pre=pa;Node *u;//临时用float x;while (p!=NULL && q!=NULL)//当两个链表都不为空{if (p->exp<q->exp)//比较链表1跟链表2当前节点的指数大小，链表1也是存放结果的地方{pre=p;p=p->pNext;//p指向要比较的下一个结点。

一元稀疏多项式简单计算器一、设计课题设计一元稀疏多项式简单计算器。

二、需求分析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的话，用头插法建立一个新的节点。