数据结构课程设计《一元多项式的四则运算》

合集下载

课程设计说明书一元多项式的代数运算.(DOC)

《数据结构》课程设计说明书题目一元多项式的代数运算学号1376807331姓名武飞指导教师康懿日期2015/6/27内蒙古科技大学课程设计任务书课程名称数据结构课程设计设计题目一元多项式的代数运算指导教师康懿时间2015 年春学期第 17 周至第 19 周一、教课要求1.掌握数据结构与算法的设计方法，具备初步的独立剖析和设计能力2.初步掌握软件开发过程的问题剖析、系统设计、程序编码、测试等基本方法和技术3.提升综合运用所学的理论知识和方法独立剖析和解决问题的能力4.训练用系统的看法和软件开发一般规范进行软件开发，培育软件工作者所应具备的科学的工作方法和作风二、设计资料及参数每个学生在教师供给的课程设计题目中随意选择一题，独立达成，题目选定后不行改换。

一元多项式的代数运算以链表储存一元多项式，在此基础上达成对多项式的操作。

要求设计类（或类模板）来描绘一元多项式，包含必需的结构函数和析构函数，以及实现以下要求：输入多项式、输出多项式多项式加法（重载运算符“+”）、多项式乘法（重载运算符“* ”）多项式中无重复阶项和无零系数项要求输出结果的升幂和降幂两种摆列状况并设计主函数测试该类。

三、设计要求及成就1.剖析课程设计题目的要求2.写出详细设计说明3.编写程序代码，调试程序使其能正确运转4.设计达成的软件要便于操作和使用5.设计达成后提交课程设计报告四、进度安排资料查阅与议论（ 1 天）系统剖析（ 2 天）系统的开发与测试（ 5 天）编写课程设计说明书和查收（ 2 天）五、评分标准1.依据平常上机考勤、表现和进度，教师将每日点名和检查2.依据课程设计达成状况，一定有可运转的软件。

3.依据课程设计报告的质量，若有相同，则全部相同的全部人均判为不及格。

4.依据辩论的状况，应能够以清楚的思路和正确、精练的语言表达自己的设计和回答教师的发问六、建议参照资料1．《数据结构（C 语言版）》严蔚敏、吴伟民主编清华大学第一版社 2004.11 2．《数据结构课程设计事例精编（用C/C++描绘）》，李建学等编著，清华大学第一版社2007.2目录第 1 章需求剖析 (3)第 2 章整体设计 (4)2.1 多项式双链循环链表的生成函数 (4)2.2 实现两个一元多项式的加法函数 (5)2.3 实现两个一元多项式的乘法函数 (7)2.4 将结果按幂的升序办理函数 (8)2.5 输出函数 (9)第 3 章详细设计 (12)3.1 主程序流程图 (12)3.2 主要算法的流程图 (13)第 4 章测试 (17)第 5 章总结 (20)参照文件 (20)附录：程序代码 (21)第 1章需求剖析两个一元多项式加法与乘法的实现，顾名思义，本程序的主要功能就是对两个一元多项式进行代数上的加法与乘法运算。

一元多项式计算(数据结构课程设计)

一元多项式计算(数据结构课程设计)一、系统设计1、算法思想根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应指数相加（减），若其和（差）不为零，则构成“和（差）多项式”中的一项；对于两个一元多项式中所有指数不相同的项，则分别写到“和（差）多项式”中去。

因为多项式指数最高项以及项数是不确定的，因此采用线性链表的存储结构便于实现一元多项式的运算。

为了节省空间，我采用两个链表分别存放多项式a 和多项式b，对于最后计算所得的多项式则利用多项式a进行存储。

主要用到了单链表的插入和删除操作。

(1)一元多项式加法运算它从两个多项式的头部开始，两个多项式的某一项都不为空时，如果指数相等的话，系数就应该相加；相加的和不为零的话，用头插法建立一个新的节点。

P 的指数小于q的指数的话就应该复制q的节点到多项式中。

P的指数大于q的指数的话，就应该复制p节点到多项式中。

当第二个多项式空，第一个多项式不为空时，将第一个多项式用新节点产生。

当第一个多项式空，第二个多项式不为空时，将第二个多项式用新节点产生。

(2)一元多项式的减法运算它从两个多项式的头部开始，两个多项式的某一项都不为空时，如果指数相等的话，系数就相减；相加的和不为零的话，用头插法建立一个新的节点。

p的指数小于q的指数的话，就应该复制q的节点到多项式中。

P的指数大于q的指数的话就应该复制p的节点到多项式中，并且建立的节点的系数为原来的相反数；当第二个多项式空，第一个多项式不为空时，将第一个多项式用新节点产生。

当第一个多项式空，第二个多项式不为空时，将第二个多项式用新节点产生，并且建立的节点的系数为原来的相反数。

2、概要设计(1)主函数流程图：（注：a代表第一个一元二次方程，b代表第二个一元二次方程）(2)一元多项式计算算法用类C语言表示：Typedef struct00{ //项的表示，多项式的项作为LinkList的数据元素Float coef；//细数Int expn；//指数}term，ElemType；//两个类型名：term用于本ADT，ElemType为LinkList的数据对象名Typedef LinkList polynomial：//用带表头的节点的有序链表表示多项式//基本操作的函数原型说明Void CreatePolyn（polynomail&P）；//输入n的系数和指数，建立表示一元多项式的有序链表P 销毁一元多项式P Void DestroyPolyn（polynomailP）；销毁一元多项式PvoidPrintPoly（polynomail P）；//打印输入一元多项式PIntPolynLength（polynnomail P);//返回一元多项式P中的项数void CreatPolyn（polynomail&Pa.polunomail&Pb);//完成多项式相加运算，即:Pa=Pa+Pb,并贤惠一元多项式Pb voidSubtractPolyn（polunomail&Papolunomail&Pb）；//完成多项式相减运算，即：Pa=Pa-Pb，并销毁一元多项式Pb//基本操作的算法描述Int cmp(tem a，temp b）；//依a的指数值<（或=）（或>b的住数值，分别返回-1、0和+1Void CreatePolyn（polynomail&P,int m){//输入m项的系数和指数，建立表示一元多项式的有序链表PInitList（P）；h=GetHead（P）；E.coef=0.0； e.expn=-1；S erCurElem（h，e）；//设置头结点的数据元素For （i=1；i<=m；++i）{ //依次输入m个非零项Scanf（e.coef，e.epn）；If（！LocateElem（P，e，q，（*cmp）（）））{//当前链表中不存在该指数项If(MakeNode（s，e））InsFirst（q，s）；//生成节点并插入链表}}}//CreatPolun二、详细设计1、算法实现(1)输入一元多项式函数：void shuchu(pnode *head){pnode *p;int one_time=1;p=head;while(p!=NULL) /*如果不为空*/{if(one_time==1){if(p->zhishu==0) /*如果指数为0的话，直接输出系数*/printf("%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/else if(p->xishu==1||p->xishu==-1)printf("X^%d",p->zhishu); /*如果系数是1的话就直接输出+x*//*如果系数是-1的话就直接输出-x号*/else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);one_time=0;}else{if(p->zhishu==0) /*如果指数为0的话，直接输出系数*/{if(p->xishu>0)printf("+%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/}else if(p->xishu==1) /*如果系数是1的话就直接输出+x号*/printf("+X^%d",p->zhishu);else if(p->xishu==-1) /*如果系数是-1的话就直接输出-x号*/printf("X^%d",p->zhishu);else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("+%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/printf("%5.2fX^%d",p->xishu,p->zhishu);}p=p->next; /*指向下一个指针*/}printf("\n");}(2)加法函数/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针，r,s为临时指针，p指向第1个多项式并向右移动，q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话，就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话，就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}(3)减法函数/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针，r,s为临时指针，p指向第1个多项式并向右移动，q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话，就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话，就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}2、程序代码/*一元多项式计算*//*程序功能：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减，并将结果输出；*//*提示：输入完一元多项式之后，输入“0 0”结束本一元多项式的输入*//*注意：系数只精确到百分位，最大系数只能为999.99,指数为整数.如果需要输入更大的系数，可以对程序中5.2%f进行相应的修改*/#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<conio.h>/*建立结构体*/typedef struct pnode{float xishu; /*系数*/int zhishu; /*指数*/struct pnode *next; /*下一个指针*/}pnode;/*用头插法生成一个多项式，系数和指数输入0时退出输入*/pnode * creat()int m;float n;pnode *head,*rear,*s; /*head为头指针，rear和s为临时指针*/ head=(pnode *)malloc(sizeof(pnode));rear=head; /*指向头*/scanf("%f",&n); /*系数*/scanf("%d",&m); /*输入指数*/while(n!=0) /*输入0退出*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=n;s->zhishu=m;s->next=NULL;rear->next=s; /*头插法*/rear=s;scanf("%f",&n); /*输入系数*/scanf("%d",&m); /*输入指数*/}head=head->next; /*第一个头没有用到*/return head;}/*调整多项式*/void tiaozhen(pnode *head){pnode *p,*q,*t;float temp;p=head;while(p!=NULL){q=p;t=q->next;while(t!=NULL){if(t->zhishu>q->zhishu)q=t;t=t->next;}temp=p->xishu;p->xishu=q->xishu;q->xishu=temp;temp=p->zhishu;p->zhishu=q->zhishu;q->zhishu=temp;p=p->next;}/*显示一个多项式*/void shuchu(pnode *head){pnode *p;int one_time=1;p=head;while(p!=NULL) /*如果不为空*/{if(one_time==1){if(p->zhishu==0) /*如果指数为0的话，直接输出系数*/printf("%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/else if(p->xishu==1||p->xishu==-1)printf("X^%d",p->zhishu); /*如果系数是1的话就直接输出+x*//*如果系数是-1的话就直接输出-x号*/else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);one_time=0;}else{if(p->zhishu==0) /*如果指数为0的话，直接输出系数*/{if(p->xishu>0)printf("+%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/}else if(p->xishu==1) /*如果系数是1的话就直接输出+x号*/printf("+X^%d",p->zhishu);else if(p->xishu==-1) /*如果系数是-1的话就直接输出-x号*/printf("X^%d",p->zhishu);else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("+%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);}p=p->next; /*指向下一个指针*/}printf("\n");/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针，r,s为临时指针，p指向第1个多项式并向右移动，q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话，就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话，就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}/*两个多项式的减法运算*/pnode * sub(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r;float x; /*x为系数相减*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*两个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu-q->xishu; /*系数相减*/if(x!=0) /*相减的差不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=-q->xishu; /*建立的节点的系数为原来的相反数*/s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}else{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}while(p!=NULL) /*当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}while(q!=NULL) /*当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=-q->xishu; /*建立的节点的系数为原来的相反数*/ s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}void add_main(){pnode * a,*b,*c;printf("\n输入第一个一元多项式:\n系数指数\n");a=creat();tiaozhen(a);printf("\n输入第二个一元多项式:\n系数指数\n");b=creat();tiaozhen(b);c=add(a,b);printf("第一个一元多项式如下:");shuchu(a);printf("第二个一元多项式如下:");shuchu(b);printf("两式相加如下:");shuchu(c);}void sub_main(){pnode * a,*b,*c;printf("\n输入第一个一元多项式:\n系数指数\n");a=creat();tiaozhen(a);printf("\n输入第二个一元多项式:\n系数指数\n");b=creat();tiaozhen(b);c=sub(a,b);printf("第一个一元多项式如下:");shuchu(a);printf("第二个一元多项式如下:");shuchu(b);printf("两式相减如下:");shuchu(c);}void open(){printf("\n****************************************************\n");printf(" 功能项: * 1 两个一元多项式相加;2 两个一元多项式相减;0 退出*\n");printf("****************************************************\n\n请选择操作: ");}void main(){int choose;open();while(choose!=0){scanf("%d",&choose);getchar();switch(choose){case 0:return;case 1:printf("\n 两个一元多项式相加\n");add_main();choose=-1;open();break;case 2:printf("\n 两个一元多项式相减\n");sub_main();choose=-1;open();break;default:printf("没有该选项!请重新选择操作!\n\n");open();}}}三、测试方案及结果1、测试方案在Visual C++ 6.0环境中调试运行。

一元多项式数据结构课程设计报告

一元多项式计算摘要一元多项式计算是用C语言设计一个一元多项式简单计算器。

它能够实现按指数降序排列建立并输出多项式，并且能够完成两个多项式的相加，想减的运算和将其结果输入的功能。

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

关键词：C语言；一元多项式；链式存存储结构；指数降序排列；目录1. 引言--------------------------------------------32.需求分析----------------------------------------33.概要设计----------------------------------------3 3.1功能模块图-------------------------------33.2流程图------------------------------------44.详细设计----------------------------------------54.1一元多项式的建立---------------------------54.2显示一元多项式---------------------------------------64.3一元多项式的加法运算--------------------------------7 4.4一元多项式的减法运算----------------------94.5 帮助------------------------------------12 5测试结果----------------------------------------126.调试分析-----------------------------------------137.设计体会-----------------------------------------138.结束语--------------------------------------------149.参考文献-----------------------------------------1510.附录---------------------------------------------151.引言此程序的数据结构是选择用带头结点的单链表存储多项式。

数据结构课程设计——《一元多项式的表达及其运算_集合的表达与运算》

目录1. 一元多项式的表示及其运算 (1)1.1 问题描述 (1)1.2 设计方案与概要设计 (1)1.3 详细设计 (2)1.4 程序运行说明与结果 (11)2. 集合的表示与运算 (12)2.1 问题描述 (12)2.2 设计方案与概要设计 (12)2.3 详细设计 (13)2.4 程序运行说明与结果 (18)3.总结与分析 (19)1. 一元多项式的表示及其运算1.1 问题描述（1）输入并建立一元多项式（2）输出一元多项式（3）多项式实现相加、相减及相乘（4）输入多项式中的未知数，计算多项式的结果（5）退出程序1.2 设计方案与概要设计程序以用户和计算机的对话方式执行，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运算命令；相应的输入数据和运算结果显示在其后。

程序执行的命令包括：（1）多项式的项作为LinkList的数据元素，coef为系数，浮点型，expn 为指数，整型（2）构造一个表示一元多项式链表La，存储多项式的项数、系数和指数等数据（3）利用两个多项式的结点构成"和多项式"，AddPolyn(&Pa,&Pb),一元多项式Pa和Pb已存在，完成多项式相加运算，即：Pa = Pa+Pb,并销毁一元多项式Pb。

（4）利用两个多项式的结点构成"差多项式"，利用两个多项式的结点构成"和多项式"，SubtractPolyn(&Pa,&Pb),一元多项式Pa和Pb已存在，完成多项式相减运算，即：Pa = Pa-Pb,并销毁一元多项式Pb。

（5）利用两个多项式的结点构成"积多项式"，利用两个多项式的结点构成"和多项式"，MultiplyPolyn(&Pa,&Pb),一元多项式Pa和Pb已存在，完成多项式相乘运算，即：Pa = Pa×Pb,并销毁一元多项式Pb（6）制作标题栏（7）使用switch语句实行多分支选择操作，当case中的常量表达式的值都没有与表达式的值匹配的，就执行default后面的语句，输出提示用户出错，并重新输入1.3 详细设计#include<stdlib.h>#include<stdio.h>#include<ctype.h>typedef struct LNode {float coef;int expn;struct LNode *next;}LNode;LNode* InitPolyn(LNode *La,int n) {if(n <= 0) return NULL;LNode *h = La = (LNode*)malloc(sizeof(LNode)), *Lb;La->coef = 0.0;int i;printf("依次输入%d个非零项（每项前一个为系数，后一个为指数）\n",n); for (i = 1; i <= n; ++i) {scanf("%f%d",&La->coef,&La->expn);if(La->coef)Lb = La;La = La->next = (LNode*)malloc(sizeof(LNode));}Lb->next = NULL;free(La);return h;}LNode* selsort(LNode *h) {LNode *g, *La, *Lb;if(!h) return NULL;float f;int i, fini = 1;for(g = h;g->next&&fini;g = g->next) {fini = 0;for(La = h,Lb = h->next;Lb;La = La->next,Lb = Lb->next) if (La->expn < Lb->expn) {f = La->coef;i = La->expn;La->coef = Lb->coef;La->expn = Lb->expn;Lb->coef = f;Lb->expn = i;fini = 1;}}for(g = h,La = g->next;La;)if(g->expn==La->expn) {g->coef += La->coef;g->next = La->next;Lb = La;La = La->next;free(Lb);}else if(g->next) {g = g->next;La = La->next;}return h;}void PrintfPoly(LNode *La) {LNode *Lb = La;if(!Lb) {putchar('0');return;}if(Lb->coef!=1) {printf("%g",Lb->coef);if(Lb->expn==1) putchar('X');else if(Lb->expn) printf("X^%d",Lb->expn); }else if(!Lb->expn) putchar('1');else if(Lb->expn==1) putchar('X');else printf("X^%d",Lb->expn);Lb = Lb->next;while (Lb) {if(Lb->coef > 0) putchar('+');if(Lb->coef!=1) {printf("%g",Lb->coef);if(Lb->expn==1) putchar('X');else if(Lb->expn) printf("X^%d",Lb->expn); }else if(!Lb->expn) putchar('1');else if(Lb->expn==1) putchar('X');else printf("X^%d",Lb->expn);Lb = Lb->next;}}Compare(LNode *a, LNode *b) {if (a->expn < b->expn) return -1;if (a->expn > b->expn) return 1;return 0;}LNode* AddPolyn(LNode *Pa, LNode *Pb) { LNode *h, *qa = Pa, *qb = Pb, *La, *Lb; float sum;h = La = (LNode*)malloc(sizeof(LNode)); La->next = NULL;while (qa && qb) {switch (Compare(qa,qb)) {case -1:La->next = qb;La = qb;qb = qb->next;break;case 0:sum = qa->coef + qb->coef;if (sum != 0.0) {La->next = qa;qa->coef = sum;La = qa;qa = qa->next;}else {Lb = qa;qa = qa->next;free(Lb);}Lb = qb;qb = qb->next;free(Lb);break;case 1:La->next = qa;La = qa;qa = qa->next;break;}}if (Pa) La->next = qa;if (Pb) La->next = qb;Lb = h;h = h->next;free(Lb);return h;}LNode* Add(LNode *Pa, LNode *Pb) { int n;puts("再输入1个一元多项式的项数"); scanf("%d",&n);Pb = InitPolyn(Pb,n);PrintfPoly(Pa);if(Pb && Pb->coef>0) printf(" + ");PrintfPoly(Pb);Pa = AddPolyn(Pa,Pb);printf(" = ");Pa = selsort(Pa);PrintfPoly(Pa);return Pa;}LNode* SubtractPolyn(LNode *Pa, LNode *Pb) { LNode *La = Pb;while(La) {La->coef *= -1;La = La->next;}return AddPolyn(Pa,Pb);}LNode* Subtract(LNode *Pa, LNode *Pb) {int n;puts("\n再输入1个一元多项式的项数"); scanf("%d",&n);Pb = InitPolyn(Pb,n);Pb = selsort(Pb);PrintfPoly(Pa);printf(" - ");putchar('(');PrintfPoly(Pb);putchar(')');Pa = SubtractPolyn(Pa,Pb);printf(" = ");PrintfPoly(Pa);return Pa;}LNode* MultiplyPolyn(LNode *Pa, LNode *Pb) { if(!Pb) return NULL;LNode *pa = Pa, *p, *q, *r, *s, *t;r = p = (LNode*)malloc(sizeof(LNode));while(pa) {p->coef = pa->coef;p->expn = pa->expn;q = p;p = p->next = (LNode*)malloc(sizeof(LNode)); pa = pa->next;}q->next = NULL;free(p);pa = Pa;t = s = (LNode*)malloc(sizeof(LNode));while(pa) {q = s;s = s->next = (LNode*)malloc(sizeof(LNode)); pa = pa->next;}q->next = NULL;free(s);pa = Pa;while(pa) {pa->coef *= Pb->coef;pa->expn += Pb->expn;}Pb = Pb->next;while(Pb) {p = r;s = t;while(p) {s->coef = p->coef * Pb->coef;s->expn = p->expn + Pb->expn;p = p->next;s = s->next;}Pa = AddPolyn(Pa,t);Pb = Pb->next;}return Pa;}LNode* Multiply(LNode *Pa, LNode *Pb) { int n;puts("\n再输入1个一元多项式的项数"); scanf("%d",&n);Pb = InitPolyn(Pb,n);Pb = selsort(Pb);putchar('(');PrintfPoly(Pa);putchar(')'); printf("×");putchar('(');PrintfPoly(Pb);putchar(')'); printf(" = ");Pa = MultiplyPolyn(Pa,Pb);Pa = selsort(Pa);PrintfPoly(Pa);return Pa;}void main() {LNode *A,*B;char s[2];int i,n;printf("\t\t\t------------------------------\n");printf("\t\t\t 一元多项式的表达与运算\n "); printf("\t\t\t------------------------------\n");printf("\t\t\t ****Made by Huangruiting****\n"); puts("\n输入1个一元多项式的项数");scanf("%d",&n);A = InitPolyn(A,n);A = selsort(A);PrintfPoly(A);p: puts("\n1:加\n2:减\n3:乘\n4:退出");getchar();q: gets(s);if(s[1]!='\0' || !isdigit(*s)) {puts("Error，请重新输入！");goto q;}i = *s-48;switch(i) {case 1:A = Add(A,B);goto p;;case 2:A = Subtract(A,B);goto p;;case 3:A = Multiply(A,B);goto p;case 4:break;default:puts("Error,请重新输入!");goto q;}}1.4 程序运行说明与结果例：x2 +3x（1）按照需要操作的多项式输入第1个多项式的项数例中多项式项数为2，输入2，回车；（2）依次输入两个非零项，两个项之间用空格间开即可，每项输入，前一个为系数，后一个为指数，例中多项式第一项系数为1，输入1，空格，指数为2，输入2，空格，第二项系数为3，输入3，空格，指数为1，输入1，回车；即显示x^2+3x(x^2表示x的2次方)。

数据结构课程设计--一元多项式计算问题(C语言)

长沙学院课程设计说明书题目一元多项式计算问题系(部)计算机科学与技术系专业(班级)12软件4班姓名谢仲蛟学号2012022411指导教师邱建雄起止日期2013.12.9～2013.12.20课程设计任务书课程名称：数据结构与算法设计题目：一元多项式计算问题已知技术参数和设计要求：问题描述：设计一个稀疏多项式简单计算器基本要求：(1)输入并分别建立多项式A和B(2)输入输出多项式，输出形式为整数序列：n,c1,e1,c2,e2……，其中n是多项式的项数，ci和ei 是第i项的系数和指数，序列按指数降序排列(3)完成两个多项式的相加、相减，并将结果输出；测试数据：(1) A+B A= 3x14-8x8+6x2+2 B=2x10+4x8+-6x2(2) A-B A=11x14+3x10+2x8+10x6+5 B=2x14+3x8+5x6+7(3) A+B A=x3+x1 B=-x3-x1(4) A+B A=0 B=x7+x5+x3+x1(5) A-B A=100x100+50x50+20x20+x B=10x100+10x50+10x20+x选作内容：（1）.多项式在x=1时的运算结果（2）求多项式A和B的乘积设计工作量：40课时工作计划：指导教师签名：日期：教研室主任签名：日期：系主任签名：日期：长沙学院课程设计鉴定表摘要本次课程设计是在《数据结构》基础上设计以C语言来实现的，它的目的是帮助同学更深入的了解《数据结构》这门课程并熟练运用C语言，使同学达到熟练掌握的程度。

课程设计一个稀疏多项式简单计算器。

其基本要求有六：其一，输入建立两个多项式；其二,输出多项式，输出形式为整数序列：n，c1,e1,c2,e2……,其中n是多项式的项数，ci和ei是第i项的系数和指数，序列按指数的降序序列排列；其三，多项式排序，多项式按指数的降序序列排列；其四，多项式相加，指数相同系数相加，指数不同则把此项加进去；其五，多项式相减，指数相同系数相加，指数不同则把此项取反再加进去；其六，返回多项式的项数。

数据结构课程设计之一元多项式加减乘

##大学数据结构课程设计报告题目：顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现院（系）：计算机工程学院学生姓名:班级：学号:起迄日期: 2011.06.20-06.30指导教师:2010—2011年度第 2 学期一、需求分析1、顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现。

可以分为几个模块：输入模块、输出模块（升幂降幂）、数据处理模块（多项式的加减乘）、主程序模块。

2、在程序过程中加入汉字提示符，让读者清楚明白的操作该程序。

运行程序时看起来简洁有序，操作简单明了3、程序执行时的命令：①选择创建两个一元多项式②输入第一个一元多项式的项数③依次输入一元多项式的系数和指数④以相同方式输入第二个一元多项式⑤选择操作方式⑥选择降幂或升幂排序⑦输出结果⑧是否退出。

4、测试数据。

输入的一元多项式系数指数分别为7 0,3 1,9 8,5 17和8 1,22 7，-9 8。

加法结果为；升幂降幂减法结果为：升幂降幂乘法结果为：升幂降幂二、概要设计1、设计思路：在该程序中分别分为顺序存储和链式存储结构。

2、数据结构设计：一元多项式抽象数据类型的定义：ADT Polynomial{数据对象：D={ai|ai∈TermSet,i=1,2…,m,m>=0TermSet中的每一个元素包含一个表示系数的实数和表示指数的整数}数据关系:R1={<ai-1,ai>|ai-1,ai∈D, 且ai-1中的指数值<ai中的指数值，i=2,…,n} 基本操作：CreatPolyn(&P,m)操作结果：输入m项的系数和指数，建立一元多项式P.DesteoyPolyn(&P)初始条件：一元多项式P已存在。

操作结果：销毁一元多项式P。

PrintfPolyn(P)初始条件：一元多项式P已存在。

操作结果：打印输出一元多项式P。

PolynLength(P)初始条件：一元多项式P已存在。

数据结构课程设计报告一元多项式加减乘除精

数据结构课程设计报告一元多项式加减乘除精多项式想加减与乘与升降序学院计算机科学与技术专业信息安全学号 12070学生姓名陶宝中辅导教师姓名12月 22 日一、设计目的与内容了解数据结构的与算法的设计方法，独立分析和设计一元多项式加减与乘除的程序编码，经过程序编写掌握软件开发过程的问题分析，系统设计，程序编码，测试等基本方法和技能，提高综合运用所学理论知识和方法独立分析和解决问题的能力，经过这次实践将实验问题中的所涉及的对象在计算机中表示出来并对她们进行处理，掌握线除。

任务与分析本课题主要的目的是分别采用顺序和动态存储结构实现一元多项式的加法、减法和乘法。

并将操作结果分别按升序和降序输出程序的主要功能一元多项式创立建立一元多项式的顺序表和链式表，按程序提示输入每个项数据结束创立。

借助元素在存储器中的相对位置来表示数据元素之间的关系，顺序表中第i个位置表示一元多项式的第i项的系数为第i个位置存放的内容，指数为i-1。

创立一个一元多项式顺序表，对一元多项式的运算中会出现的各种情况进行分析，实现一元多项式的相加、相减、相乘操作。

用链表来表示只存储多项式中系数非零的项。

链表中的每一个结点存放多项式的一个term项结构和指向下一个节点的指针域，term又包括系数和指数两个域分别存放该项的系数、。

创立一元多项式链表，对一元多项式的运算中会出现的各种可能情况进行分析，实现一元多项式的相加、相减、相乘操作。

一元多项式的加法对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项；对于两个一元多项式中所有指数不相同的项，则分别复抄到和多项式中去。

一元多项式的减法对于两个一元多项式中所有指数相同的项，对应系数相减，若其差不为零，则构成“和多项式”中的一项；对于两个一元多项式中所有指数不相同的项，将其按减法规则复抄到差多项式中去。

一元多项式的乘法将乘法运算分解为一系列的加法运算利用两个一元多项式相加的算法实现。

数据结构课程设计(一元多项式)

cout<<" ~~~~~~~~~~~~~~~~0.退出~~~~~~~~~~~~~~~\n";
cout<<" ********1.两个一元多项式相加*********\n";
cout<<" ********2.两个一元多项式相乘*********\n";
cout<<" ********3.两个一元多项式相减*********\n";
cout<<p->coef;//其余情况都得打印
if(p->expn!=0) printf("x^%d",p->expn);//如果指数为"0"不打印指数项
else if((p->coef==1)||(p->coef==-1))
cout<<"1";
if(p->next==NULL)
flag=1;//如果现在的链节没有下一个就结束
（6）NODE *multi(NODE *pa,NODE *pb)，函数功能是实现多项式的相乘。创建新链表，生成新结点，第一个式子中的每一项都与第二个式子中每一项系数相乘指数相加，直到两个式子中的结点都运算完毕，返回新链表；
（7）void output(NODE *f)，函数功能是输出多项式。把运算完毕的新的多项式按结点依次输出，其中，若结点系数为正数则用+连接前后两个结点，若为负数则用-连接，系数为0则不输出指数；
{
if(q->next==NULL)
{
q->next=pb;
flag=1;
}
else
{

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

一元多项式的四则运算
学生姓名：XX 指导老师：XX
摘要本课程设计主要解决一元多项式的运算问题，通过链表的使用，实现对一元多项式的构建、录入、存储、打印、以及之间的运算。

在本课程设计中，程序设计语言为C++语言，程序运行平台为Windows/98/2000/XP，程序采用了链表存储方法以及结构化和模块化的设计方法，通过调试运行，可以进行多项式的加、减、乘运算，勉强实现了设计目标，并且经过适当完善后，将可应用到实际中解决某些问题。

关键词程序设计；C++ ；一元多项式；运算
1 引言
一般来说，我们只知道数学上的一元多项式的运算，这一般都是用笔来进行运算的，然而此课程设计将一元多项式的运算用电脑来进行，只需要将多项式输入，然后就可以出结果，速度快，省去了认为计算的环节，在现实中带来不少方便。

1.1 课题背景
一元多项式的运算，虽然无法直接在除数学外的其他领域作出贡献，但是在数学上，它可以为人们解决一些自己动笔动手很难解决的问题，比如说那些很长很长的多项式，用笔算可能要算半天，但是用该程序，只需短短的几秒钟，所以它给人们带来了不少方便，同时相信它也能间接地为其他领域做出贡献。

1.2 课程设计目的
个人觉得，该数据结构课程设计一方面可以让自己更加熟悉那些些常用的数据结构，掌握数据结构内在的逻辑关系，以及它们在计算机中的存储表示，和对它们实行的各种运算；另一方面，可以让自己对于整体和局部，以及结构化和模块化编程有一个更深层次的了解。

作为网络工程的学生，虽然之前有过一次Ｃ语言课程设计，但是深知自己编程能力尚为欠缺，所以这一次数据结构课程设计是对我的编程能力和组织能力的又一次考验。

1.3课程设计内容
本课程设计是用链表实现一元多项式的存储及运算，其中包括多项式系数及指数的录入（即一元多项式的录入），以及储存、一元多项式的显示、一元多项式之间的加、减、乘法运算。

2 设计思路与方案
2.1设计思路
该系统使用Ｃ++语言进行开发和实现，程序中的各个功能分别由不同的的函数实现，然后在main 函数中调用实现。

其设计思路基于结构化的程序设计和链表的存储等，应用了高级语言程序设计中的基本控制结构，如循环和选择等。

2.2设计方案
先定义链表类型结点和一元多项式，然后申明个功能函数并分别编写这些功能函数的算法，然后定义一个菜单函数Menu()，最后在main()函数中分别调用这些函数，其中输入的数据则由链表进行储存。

其系统结构图如图2-1所示：
图2-1 一元多项式的四则运算
一元多项式相乘
一元多项式输出
一元多项式销
毁
退出
一元多项式创建
一元多项式相加
一元多项式的四则运算
一元多项式相减
3 详细实现
3.1一元多项式创建
操作流程图如下图所示：
N
Y
图3-1 一元多项式的创建流程图
开始
创建一个含n 个链表类型结点的项
分别输入各项的系数和指数判断是否系数不为0且指数
大于0
重新输入
一元多项式创建
成功
先判断多项式的系数与项数之间大小关系，流程图如下所示： Y
N
Y
N Y
N
N
N
图3-2一元多项式相加流程图
开始
运算时系数想加
删除该项
判断所输入的多项式系数是否为0
判断输入的两个多项式指数是否相等
输入的第1个多项式为B
判断输入的多项式1,2
指数是否e1>e2
输入的第2个多项式为B
进行运算
相减即取第二个的相反数，然后进行加法运算，操作流程图如下图所示：
开始
将多项式B进行复制
取多项式B的相反数
调用多项式加法函数进行运算
图3-3一元多项式相减流程图
3.4一元多项式相乘
操作流程图如下图所示：
开始
给出运算的两个多项式
按系数相乘指数相加进行运算
将运算的结果相加并输出
图3-4一元多项式相乘流程图
先判断录入的两个多项式是否有空项，如果两个多项式都不是空的，那么顺序输出多项式A 和多项式B ，否则多项式创建不成功，提示重新输入。

操作流程图如下图所示：
Y N
图3-5一元多项式输出流程图
3.6一元多项式销毁
先判断存储多项式的链表类型结点是否都不为空结点，若有空结点，则提示重新选择，否则，按顺序销毁多项式A,B 。

操作流程图如下图所示：
N
Y
图3-6一元多项式销毁流程图
输出多项式B
输出多项式A
开始
判断所输入的两个多项式是否有空的
多项式创建有误，重新输入
销毁存储多项式B 的结点销毁存储多项式A 的结点
开始
判断存储多项式的
链表类型结点是否
都不为空多项式不存在，重新选择
3.7退出
本过程较为简单，用exit(0)强制终止程序，返回状态码0表示正常结束。

其操作流程图如下图所示：
开始
强制终止程序
提示退出
图3-6一元多项式退出流程图
4 运行环境与结果
4.1运行环境
在本课程设计中，系统开发平台为WindowsXP,程序设计语言为C++，程序的运行环境为Visual C++ 6.0。

4.2运行结果
（1）在程序开始运行时，会出现一个编号1-7的菜单并提示选择，如下图所示：
图4-1 最初运行界面
（2）选择1，创建两个一元多项式，按顺序操作，录入两个一元多项式，结果如下图所示：
图4-2 一元多项式创建
（3）选择2，将两个一元多项式相加，操作后结果如下图所示：
图4-3一元多项式相加。