您的位置：360文档中心› 一元多项式的计算数据结构课程设计

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

合集下载

一元多项式的计算问题-数据结构与算法课程设计报告

一元多项式的计算问题-数据结构与算法课程设计报告

合肥学院计算机科学与技术系课程设计报告2009 ～2010 学年第 2 学期课程数据结构与算法课程设计名称一元多项式的计算问题学生姓名周维学号**********专业班级08计科(2)指导教师王昆仑教授2010年6月题目：（一元多项式的计算问题）要求能够按照指数降序排列建立并输出一元多项式；能够完成两个一元多项式的相加、相减，并将结果输入。

一、问题分析和任务定义1.问题分析本程序关键点是如何将输入的两个多项式相加、相减操作。

①如何将输入的一元多项式按指数的降序排列②如何确定要输入的多项式的项数；③如何将输入的两个一元多项式显示出来。

④如何将输入的两个一元多项式进行相加操作。

⑤如何将输入的两个一元多项式进行相减操作。

本程序是通过链表实现一元多项式的相加减操作。

2、任务定义此程序需要完成如下的要求：将多项式按照指数降序排列建立并输出，将两个一元多项式进行相加、相减操作，并将结果输入。

a：输入多项式的项数并建立多项式；b：输出多项式，输出形式分别为浮点和整数序列，序列按指数升序排列；c：多项式a和b相加，建立多项式a+b；d：多项式a和b相减，建立多项式a-b。

e：多项式的输出。

二、数据结构的选择和概要设计：（1）数据结构的选用A:基于链表中的节点可以动态生成的特点，以及链表可以灵活的添加或删除节点的数据结构，为了实现任意多项式的加法，减法，因此选择单链表的结构体，它有一个系数，指数，下一个指针3个元属；例如，图1中的两个线性链表分别表示一元多项式和一元多项式。

从图中可见，每个结点表示多项式中的一项。

图1 多项式表的单链存储结构B：本设计使用了以下数据结构：t ypedef struct {float coef; //系数int expn; //指数} ElemType；typedef struct LNode{ElemType data;struct LNode *next;}LNode;C：设计本程序需用到九个模块，用到以下九个子函数如下：1、void Menu()//建立菜单2、LNode *InitList() // 创建链表3、void ChaLNode(LNode *L,ElemType x)//插入链表4、LNode *AddPolyn(LNode *A,LNode *B)//多项式相加5、void Invert(LNode *L)//逆序输出链表6、void Print(LNode *L)//输出多项式7、main()//主程序模块调用链一元多项式的各种基本操作模块。

数据结构课程设计-一元多项式的加法、减法、乘法的实现

数据结构课程设计-一元多项式的加法、减法、乘法的实现

数据结构课程设计-一元多项式的加法、减法、乘法的实现一、设计题目一元多项式的加法、减法、乘法的实现。

二、主要内容设有一元多项式A m(x)和B n(x).A m(x)=A0+A1x1+A2x2+A3x3+… +A m x mB n(x)=B0+B1x1+B2x2+B3x3+… +B n x n请实现求M(x)= A m(x)+B n(x)、M(x)= A m(x)-B n(x)和M(x)=A m(x)×B n(x)。

要求：1) 首先判定多项式是否稀疏2) 采用动态存储结构实现；3) 结果M(x)中无重复阶项和无零系数项；4) 要求输出结果的升幂和降幂两种排列情况三、具体要求及应提交的材料1．每个同学以自己的学号和姓名建一个文件夹，如：“312009*********张三”。

里面应包括：学生按照课程设计的具体要求所开发的所有源程序（应该放到一个文件夹中）、任务书和课程设计说明书的电子文档。

2．打印的课程设计说明书（注意：在封面后夹入打印的“任务书”以后再装订）。

四、主要技术路线提示为把多个小功能结合成一个完整的小软件，需使用“菜单设计”技术（可以是控制台方式下的命令行形式，若能做成图形方式则更好）。

五、进度安排共计两周时间，建议进度安排如下：选题，应该在上机实验之前完成需求分析、概要设计可分配4学时完成详细设计可分配4学时调试和分析可分配10学时。

2学时的机动，可用于答辩及按教师要求修改课程设计说明书。

注：只用课内上机时间一般不能完成设计任务，所以需要学生自行安排时间做补充。

六、推荐参考资料(不少于3篇)［1］苏仕华等编著，数据结构课程设计，机械工业出版社，2007［2］严蔚敏等编著，数据结构（C语言版），清华大学出版社，2003［3］严蔚敏等编著，数据结构题集（C语言版），清华大学出版社，2003指导教师签名日期年月日系主任审核日期年月日摘要分析了matlab，mathmatic，maple等数学软件对一元多项式的计算过程，步骤后。

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

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

一元多项式计算(数据结构课程设计)一、系统设计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++一元多项式计算问题-课程设计说明书

XX学院课程设计说明书题目一元多项式计算问题系(部) 计算机科学与技术系专业(班级) 计算机科学与技术专业姓名学号指导教师起止日期课程设计任务书课程名称：数据结构与算法设计题目：一元多项式计算问题已知技术参数和设计要求：问题描述：设计一个稀疏多项式简单计算器基本要求：(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+x1B=-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++语言，利用Microsoft Visual C++ 6.0开发工具，还有数据结构课中学到的链式存储结构，存储一元稀疏多项式，从而实现程序的基本功能。

在程序中定义了各种类型的运算的模块，通过主程序的调用来完成它们之间的配合，进而使得一元稀疏多项式计算器的顺利运行。

关键词：数据结构；一元稀疏多项式；链表；C++语言目录1 设计内容与要求 (1)2.设计说明 (1)2.1 问题描述与功能设计 (1)2.2 数据结构与算法 (1)2.3 函数定义 (3)2.4 界面设计 (4)2.5 编码 (5)2.6 测试 (10)3 总结 (14)参考文献 (15)附录A 源代码 (16)⒈设计内容与要求设计内容：设计一个稀疏多项式简单计算器，能够进行简单的基本运算。

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

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

一元多项式计算摘要一元多项式计算是用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语言)

数据结构课程设计--一元多项式计算问题(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已存在。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
图表2
3、多项式的减法
（1）功能：将两多项式相减。
（2）数据流入：调用输入函数。
（3）数据流出：多项式相减后的结果。
（4）程序流程图：多项式的减法流程图如图3所示。
（5）测试要点：两多项式是否为空，为空则提示重新输入，否则，进行运算。
四．详细设计
1. 根据题目要求采用单连表存储结构
typedef struct LNode //定义单链表
六：调试结果
1.测试的数据及结果
2.算法的时间复杂度及改进
算法的时间复杂度：一元多项式的加法运算的时间复杂度为O(m+n）,减法运算的时间复杂度为O(m-n)，其中m，n分别表示二个一元多项式的项数。
问题和改进思想：在设计该算法时，出现了一些问题，例如在建立链表时头指针的设立导致了之后运用到相关的指针时没能很好的移动指针出现了数据重复输出或是输出系统缺省值，不能实现算法。实现加法时该链表并没有向通常那样通过建立第三个链表来存放运算结果，而是再度利用了链表之一来进行节点的比较插入删除等操作。为了使输入数据按指数降序排列，可在数据的输入后先做一个节点的排序函数，通过对链表排序后再进行之后加减运算。
1． 单连表的抽象数据类型定义：
ADT List{ 数据对象：D={ai|ai∈ElemSet,i=1,2,…,n,n≥0} 数据关系：R1i=2,…,n}
基本操作：
InitList（＆L）
//操作结果：构造一个空的线性表
CreatPolyn(&L)
//操作结果：构造一个以单连表存储的多项试
能够完成两个多项式的相加、相减，并将结果输出；
结束语：
时间过的很快，在不知不觉中，课程设计也接近了尾声.说起课程设计，我认为最重要的就是做好设计的预习，并且认真的去复习以前的知识和查各种资料同时认真的研究老师给的题目，老师对题目的讲解要一丝不苟的去听去想，因为只有都明白了，做起设计来才会有底，有信心。课程设计是一门培养学生综合运用所学知识,发现,提出,分析和解决实际问题的学科,它能充分锻炼我们的动手能力，时我们实践能力的重要环节,是对学生实际工作能力的具体训练和考察过程。我想这次不只是一次简单的课程设计，更体现了数据结构算法和生活的紧密联系。生活中也存在许多与数据结构有关联的事情，它让人不得不深思，这一个学期的学习，这两年来的大学学习生涯，自己究竟学会了什么，掌握了多少，我也不清楚，我以前也疯狂的玩过，现在才知道自己时多么的缺乏知识，大多数问题自己不能解决，感觉将来自己是否能胜任以后作编译人员的职位。我想大家都心里都有很多的感触。对于自己，我想我已经认识到了自己的不足，在今后的学习过程中，我一定以最好的心态去对待，以最好的面貌来迎接大三的软件专业课程，并且经常上机调试，坚持理论与实践相结合。相信自己将会有很大的进步。
一元多项式的计算—加，减
摘要(题目)一元多项式计算
任务：能够按照指数降序排列建立并输出多项式；
能够完成两个多项式的相加、相减，并将结果输入；
1.引言
2.需求分析
3.概要设计
4.详细设计
5.测试结果
6.调试分析
7.设计体会
8.结束语
一:引言:
通过C语言使用链式存储结构实现一元多项式加法、减法和乘法的运算。按指数降序排列。
{
}LNode,*LinkList;
void InitList(LinkList &L) //定义一个空表
{ }
void CreatPolyn(LinkList &L) //用单链表定义一个多项式
{ }
void DispPolyn(LinkList L) //显示输入的多项式
{ }
void Polyn(LinkList &pa,LinkList &pb)
（3）数据流出：合并同类项后的多项式。
（4）程序流程图：多项式输入流程图如图1所示。
（5）测试要点：输入的多项式是否正确，若输入错误则重新输入
2、多项式的加法
（1）功能：将两多项式相加。
（2）数据流入：输入函数。
（3）数据流出：多项式相加后的结果。
（4）程序流程图：多项式的加法流程图如图2所示。
（5）测试要点：两多项式是否为空，为空则提示重新输入，否则，进行运算。
DispPolyn(L)
//操作结果：显示多项试
Polyn(&pa,&pb)
//操作结果：显示两个多项试相加，相减的结果
} ADT List
2． 本程序包含模块： typedef struct LNode //定义单链表
{
}LNode,*LinkList;
void InitList(LinkList &L) //定义一个空表
二：需求分析
建立一元多项式并按照指数降序排列输出多项式，将一元多项式输入并存储在内存中，能够完成两个多项式的加减运算并输出结果
三：概要设计
存储结构：一元多项式的表示在计算机内可以用链表来表示，为了节省存储空间，只存储多项式中系数非零的项。链表中的每一个结点存放多项式的一个系数非零项，它包含三个域，分别存放该项的系数、指数以及指向下一个多项式项结点的指针。创建一元多项式链表，对一元多项式的运算中会出现的各种可能情况进行分析，实现一元多项式的相加、相减操作。
*************** "<<endl;
LNode *L1,*L2;
Polyn(L1,L2); }
2.1 加，减操作模块——实现加减操作
各模块之间的调用关系如下：
主程序模块
加法操作模块 减法操作模块
基本算法：
1、输入输出
（1）功能：将要进行运算的多项式输入输出。
（2）数据流入：要输入的多项式的系数与指数。
七. 心得体会：一元多项式计算是一个的单链表的运用， 通过这个程序可以测我们以前的学习情 况，看看我们是否对单链表真正的理解。
一元多项式计算器的基本功能定为：
(1) 建立多项式
(2) 输出多项式
(3) 两个多项式相加，建立并输出和多项式
(4) 两 个多项式相减，建立并输出差多项式能够按照指数降序排列建立并输出多项式；
{ }
void CreatPolyn(LinkList &L) //用单链表定义一个多项式
{ }
void DispPolyn(LinkList L) //显示输入的多项式
{ }
void Polyn(LinkList &pa,LinkList &pb)
{}
void main()
{
//定义一个单连表；
cout<<endl<<" *****************欢迎来到一元多项式计算程序
{}
2．主函数 main
void main()
{
LNode *L1,*L2;
Polyn(L1,L2);
}
2. 函数的调用关系层次结构
多项式 Polyn 用单链表定义多项式 CreatPolyn 定义一个空表 InitList 显示输入的多项式 DispPolyn
}
五. 调试分析
采用单连表形式按照指数降序排列建立并输出多项式；在相加，相减的过程 中如果指数相同就执行系数相加，相减，否则就把大的项直接写入。完成两个多 项式的相加、相减;将从新得到的单连表结果输出；该算法的时间复杂度为两个 多项式的项式之和
相关文档
最新文档