一元多项式计算问题课程设计

合肥学院计算机科学与技术系课程设计报告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环境中调试运行。

合肥学院计算机科学与技术系课程设计报告2008～2009学年第二学期课程程序设计语言Ⅱ课程设计课程设计名称多项式的计算学生姓名王建敏学号0804013029专业班级计算机科学与技术（3）班指导教师张贯虹汪彩梅2009年6月一、课程设计题目：多项式（单项链表的应用）二、分析与设计1．程序的基本功能（1）建立多项式（2）输出多项式（3）删除多项式以释放空间（4）删除多项式中的某一项（5）将多项式合并同类项（6）拷贝多项式（7）将多项式按指数升序排列（8）判断两多项式是否相等（9）两个多项式相加，建立并输出和多项式（10）两个多项式相减，建立并输出差多项式（11）两个多项式相乘，建立并输出积多项式（12）两个多项式相除，建立并输出商多项式2．算法设计本程序主要应用了链表，结构体和类模板。

用结构体来定义多项式的结点（即每一项），它包含三个域，分别存放该项的系数、指数以及指向下一项结点的指针；用链表来存储多项式，为了节省空间，只存储多项式中系数非0 的项，用多项式链表类来实现设定的程序的基本功能。

涉及的主要算法有：（1）使用尾插法创建多项式，即从一个空表开始,重复读入数据,生成新结点,将读入数据存放在新结点的数据域中,然后将新结点插入到当前链表的表尾上,直到读入结束标志（某一项的系数为零）为止。

（2）输出一个非空的多项式链表，不要输出最后一项，即输入系数为零的结束项，用if……else语句判断。

（3）删除整个多项式是一项一项的删，使用链表删除其结点的方法，使用free（）函数释放存储空间。

在删除非空的多项式的某一项时，定义k来找到要删除的那一项的位置，再使用delete 将其删除。

（4）在对多项式合并同类项时，主要有两点，一是看两项指数是否相等，若相等则合并成一项，二是看两项系数和是否为零，若为零则去掉这两项。

在对多项式排序时，先合并同类项，再按指数值从小到大排序。

（5）在拷贝多项式时使用重载函数，将系数和指数都拷贝给新的多项式。

课程设计报告一元多项式计算订票系统系别专业年级学生姓名学号任课教师二○一二年三月一、题目内容实验二一元多项式计算**1．任务：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减、相乘，并将结果输出；2.在上交资料中请写明：存储结构、多项式相加的基本过程的算法（可以使用程序流程图）、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法；实验三订票系统1．任务：通过此系统可以实现如下功能：1）录入：可以录入航班情况（数据可以存储在一个数据文件中，数据结构、具体数据自定）2）查询：可以查询某个航线的情况（如，输入航班号，查询起降时间，起飞抵达城市，航班票价，票价折扣，确定航班是否满仓）；可以输入起飞抵达城市，查询飞机航班情况；3）订票：（订票情况可以存在一个数据文件中，结构自己设定）可以订票，如果该航班已经无票，可以提供相关可选择航班；4）退票：可退票，退票后修改相关数据文件；客户资料有姓名，证件号，订票数量及航班情况，订单要有编号。

5）修改航班信息：当航班信息改变可以修改航班数据文件。

2．要求：根据以上功能说明，设计航班信息，订票信息的存储结构，设计程序完成功能。

二、解题分析（一）、一元多项式计算分析：①能够按照多项式变量的指数降序创建一个多项式；②能够对已创建的多项式进行显示；③能够对已创建的多项式之间的加法运算；④能够对已创建的多项式之间的减法运算；⑤能够对已创建的多项式之间的乘法运算；⑥能够实现计算器退出操作。

（二）、订票系统：①能够按照规定输入航班的各个信息；②能够对已输入的航班信息进行显示；③能够对已创建的信息按照要求进行排序；④能够对已创建的信息进行查找；⑤能够完成订票，退票操作；⑥能够实现系统退出操作。

三、所用数据结构的描述（用伪代码）（一）、一元多项式计算：1、定义节点类型：typedef struct node{float coef;int expn;struct node * next; }PLOY;2、查找位置插入新链节程序:void insert(PLOY *head,PLOY *inpt){PLOY *pre,*now;int signal=0;pre=head;/*pre定义为现在的前一个链节*/if(pre->next==NULL)pre->next=inpt;else {now=pre->next;while(signal==0) {if(inpt->expn<now->expn) { /*当新链节小于现在的连接时向后移一个链节*/if(now->next==NULL) {now->next=inpt;signal=1; }else {pre=now;now=pre->next; }}else if(inpt->expn>now->expn){ /*如果发现比现在的链节大了就插入到这个连接的前面*/inpt->next=now;pre->next=inpt;signal=1; }else {now->coef=now->coef+inpt->coef;signal=1;free(inpt);/*与当前链节相等指数*/if(now->coef==0) {pre->next=now->next;free(now); }}}}}3、输入多项式：PLOY *creat(char ch) {PLOY *head,*inpt;float x;int y;head=(PLOY *)malloc(sizeof(PLOY));/*创建链表头*/head->next=NULL;printf("请输入一元多项式%c:(格式是：系数指数；以0 0 结束！)\n",ch);scanf("%f %d",&x,&y);while(x!=0) {inpt=(PLOY *)malloc(sizeof(PLOY));/*创建新链节*/inpt->coef=x;inpt->expn=y;inpt->next=NULL;insert(head,inpt);/*不然就查找位置并且插入新链节*/printf("请输入一元多项式%c的下一项:(以0 0 结束！)\n",ch);scanf("%f %d",&x,&y); }return head; }4、输出多项式：void print(PLOY *fun) {PLOY *printing;int flag=0;printing=fun->next;/*正在被打印的链节*/if(fun->next==NULL) { /*如果函数为空打印0*/printf("0\n");return; }while(flag==0) {if(printing->coef>0&&fun->next!=printing)printf("+");/*为正数时打印"+"号*/if(printing->coef==1);/*如果为"1"就不用打印系数了*/else if(printing->coef==-1)printf("-");/*如果为"-1"就打印"-"号就行了*/elseprintf("%f",printing->coef);/*其余情况都得打印*/if(printing->expn!=0) printf("x^%d",printing->expn);/*如果指数为"0"不打印指数项*/else if((printing->coef==1)||(printing->coef==-1))printf("1");if(printing->next==NULL)flag=1;/*如果现在的链节没有下一个就结束*/elseprinting=printing->next; }printf("\n"); }（二）、订票系统：1、定义结构体：typedef struct plane{char ID[10]; /*航班代号*/char BePlace[10];/*飞机起飞地点*/char EnPlace[10];/*飞机降落终点*/char data[15];/*飞机起飞时间*/int max;/*飞机最大乘客人数*/int price;/*飞机票价*/int num;/*飞机已售票数*/}PLANE;PLANE ti[N];2、输入信息：void input(int i){printf("请输入航班代号：\n");scanf("%s",ti[i].ID);printf("请输入起飞地点：\n");scanf("%s",ti[i].BePlace);printf("请输入降落地点：\n");scanf("%s",ti[i].EnPlace);printf("请输入起飞时间：\n");scanf("%s",ti[i].data);printf("请输入航班的最大载客人数：\n");scanf("%d",&ti[i].max);printf("请输入航班的票价：\n");scanf("%d",&ti[i].price);ti[i].num=0;}3、订票功能：void book(){int i;system( "cls" );printf("欢迎进入售票窗口!\n");i=search();if(i!=-1){if(ti[i].num>=ti[i].max)printf("\n该趟航班票已售完！");else{ti[i].num++;printf("\n订票成功!\n");}}elseprintf("该航班不存在!\n");getchar();getchar(); /*按任意健*/menu();}四、部分算法的描述（用伪代码）（一）、一元多项式计算：1、加法：PLOY *addPLOY(PLOY *head,PLOY *pre){ /*多项式相加*/PLOY *inpt;int flag=0;while(flag==0) {if(pre->next==NULL)flag=1;/*当现在指向空时跳出循环*/else {pre=pre->next;inpt=(PLOY *)malloc(sizeof(PLOY));/*创建新链节*/inpt->coef=pre->coef;inpt->expn=pre->expn;inpt->next=NULL;insert(head,inpt); }/*否则把当前"g(x)"的链节插入到"y(x)"中*/ }return head; }2、减法：PLOY *minusPLOY(PLOY *head,PLOY *pre){ /*多项式相减*/PLOY *inpt;int flag=0;while(flag==0) {if(pre->next==NULL)flag=1;/*当现在指向空时跳出循环*/else {pre=pre->next;inpt=(PLOY *)malloc(sizeof(PLOY));/*创建新链节*/inpt->coef=0-pre->coef;inpt->expn=pre->expn;inpt->next=NULL;insert(head,inpt); }/*否则把当前"g(x)"的链节插入到"y(x)"中*/ }return head; }3、乘法：PLOY *byPLOY(PLOY *head1,PLOY *head2) { /*多项式相乘*/PLOY *inpt,*res,*pre;int flag=0;res=(PLOY *)malloc(sizeof(PLOY));/*创建链表头*/res->next=NULL;head1=head1->next;pre=head2;while(flag==0) {if(pre->next==NULL) {pre=head2;/*当现在指向空时跳出循环*/head1=head1->next;continue; }if(head1==NULL) {flag=1;/*当现在指向空时跳出循环*/continue; }pre=pre->next;inpt=(PLOY *)malloc(sizeof(PLOY));/*创建新链节*/inpt->coef=pre->coef*head1->coef;inpt->expn=pre->expn+head1->expn;inpt->next=NULL;insert(res,inpt);/*把当前"g(x)"的链节插入到"y(x)"中*/ } return res; }（二）、订票系统：1、排序：void order() {/*排序模块(按平均成绩)*/int i,j;struct plane s;system( "cls" );for(i=0;i<n;i++) {/*冒泡法排序*/for(j=i+1;j<n;j++)if(strcmp(ti[i].data,ti[j].data)>0){s=ti[i];ti[i]=ti[j];ti[j]=s;}}browse();}2、查找：int search() { /*查找模块*/int i,k;struct plane s;k=-1;system( "cls" );printf("\n\n请输入要订票的起飞地点:");scanf("%s",s.BePlace); /*输入要到达的地方*/printf("\n\n请输入要订票的降落地点:");scanf("%s",s.EnPlace);printf("\n\n请输入要订票的起飞时间:");scanf("%s",s.data); /*输入出发的时间*/for(i=0;i<n;i++) {/*查找要修改的数据*/if(strcmp(s.BePlace,ti[i].BePlace)==0&&strcmp(s.EnPlace,ti[i].EnPlace)==0&&strcmp(s.data,ti[i].data)==0){k=i; /*找到要修改的记录*/printf_one(k);break; } /*调用显示一个记录的函数*/}if(k==-1){printf("\n\nNO exist!");return -1;}elsereturn k;}3、保存：void save(){int w=1;FILE *fp;int i;system( "cls" );if((fp=fopen("\\ticket.txt","wt"))==NULL) {/*以输出打开方式,在此前的记录被覆盖*/printf("\nCannot open file\n");return ;}for(i=0;i<n;i++)if(fwrite(&ti[i],sizeof(struct plane),1,fp)!=1){printf("file write error\n");w=0;}if(w==1)printf("file save ok!\n");fclose(fp);getchar();getchar();menu();}4、载入void load(){FILE*fp;int i,w;w=1;system( "cls" );if((fp=fopen("\\ticket.txt","rt"))==NULL){printf("\nCannotopen file\n");w=0;return ;}n=0;for(i=0;!feof(fp);i++){fread(&ti[i],sizeof( struct plane),1,fp);n++;}n=n-1; fclose(fp);if(w==1)printf("Load file ok!");getchar();getchar();menu();}五、算法复杂度的简单分析（一）、一元多项式计算：1、加法：O(n)2、减法：O(n)3、乘法：O(n)（二）、订票系统：1、排序：O(n^2)2、查找：O(n)3、保存：O(n)4、载入：O(n)六、程序测试数据（一）、一元多项式计算：1．F(x)=f(x)+g(x)=(2x^7+3x^5+2x^4+3x^1)+(2x^6+3x^2+43x^1)=(2x^7+2x^6+ 3x^5+2x^4+3x^2+46)2．F(x)=f(x)-g(x)=(3x^5+8x^2)-(54x^3+2x^2+5x^1)=(162x^8+6x^7+15x^6+43 2x^5+16x^4)3．F(x)=f(x)*g(x)=(3x^4+5x^3+3x^2)*(2x^4+2x^2+3x^1)=(6x^8+10x^7+12x^6 +19x^5+21x^4+9x^3)（二）、订票系统：部分截图：1.菜单2排序3.查询4.订票5退票七、程序清单#include <stdio.h>#include <string.h>#include <stdlib.h>#include<malloc.h>#define N 1000typedef struct node{/*定义节点类型*/float coef;int expn;struct node * next; }PLOY;typedef struct plane{char ID[10]; /*航班代号*/char BePlace[10];/*飞机起飞地点*/char EnPlace[10];/*飞机降落终点*/char data[15];/*飞机起飞时间*/int max;/*飞机最大乘客人数*/int price;/*飞机票价*/int num;/*飞机已售票数*/}PLANE;PLANE ti[N];int n;/*当前的航班数目*/void menu();void menu1();void start()/{ /*用户选择界面*printf("************************************\n");printf(" 欢迎进入一元多项式计算系统 \n");printf("************************************\n");printf("请选择操作:\n");printf("0.退出\n");printf("1.两个一元多项式相加\n");printf("2.两个一元多项式相乘\n");printf("3.两个一元多项式相减\n"); }void insert(PLOY *head,PLOY *inpt){ /*查找位置插入新链节程序*/ PLOY *pre,*now;int signal=0;pre=head;/*pre定义为现在的前一个链节*/if(pre->next==NULL)pre->next=inpt;else {now=pre->next;while(signal==0) {if(inpt->expn<now->expn) / { /*当新链节小于现在的连接时向后移一个链节*if(now->next==NULL) {now->next=inpt;signal=1; }else {pre=now;now=pre->next; }}else if(inpt->expn>now->expn){ /*如果发现比现在的链节大了就插入到这个连接的前面*/inpt->next=now;pre->next=inpt;signal=1; }else {now->coef=now->coef+inpt->coef;signal=1;free(inpt);/*与当前链节相等指数*/if(now->coef==0) {pre->next=now->next;free(now); }}}}}PLOY *creat(char ch) { /*输入多项式*/PLOY *head,*inpt;float x;int y;head=(PLOY *)malloc(sizeof(PLOY));/*创建链表头*/head->next=NULL;printf("请输入一元多项式%c:(格式是：系数指数；以0 0 结束！)\n",ch);scanf("%f %d",&x,&y);while(x!=0) {inpt=(PLOY *)malloc(sizeof(PLOY));/*创建新链节*/inpt->coef=x;inpt->expn=y;inpt->next=NULL;insert(head,inpt);/*不然就查找位置并且插入新链节*/printf("请输入一元多项式%c的下一项:(以0 0 结束！)\n",ch);scanf("%f %d",&x,&y); }return head; }PLOY *addPLOY(PLOY *head,PLOY *pre){ /*多项式相加*/PLOY *inpt;int flag=0;while(flag==0) {if(pre->next==NULL)flag=1;/*当现在指向空时跳出循环*/else {pre=pre->next;inpt=(PLOY *)malloc(sizeof(PLOY));/*创建新链节*/inpt->coef=pre->coef;inpt->expn=pre->expn;inpt->next=NULL;insert(head,inpt); }/*否则把当前"g(x)"的链节插入到"y(x)"中*/ }return head; }PLOY *minusPLOY(PLOY *head,PLOY *pre){ /*多项式相减*/PLOY *inpt;int flag=0;while(flag==0) {if(pre->next==NULL)flag=1;/*当现在指向空时跳出循环*/else {pre=pre->next;inpt=(PLOY *)malloc(sizeof(PLOY));/*创建新链节*/inpt->coef=0-pre->coef;inpt->expn=pre->expn;inpt->next=NULL;insert(head,inpt); }/*否则把当前"g(x)"的链节插入到"y(x)"中*/ }return head; }PLOY *byPLOY(PLOY *head1,PLOY *head2) { /*多项式相乘*/PLOY *inpt,*res,*pre;int flag=0;res=(PLOY *)malloc(sizeof(PLOY));/*创建链表头*/res->next=NULL;head1=head1->next;pre=head2;while(flag==0) {if(pre->next==NULL) {pre=head2;/*当现在指向空时跳出循环*/head1=head1->next;continue; }if(head1==NULL) {flag=1;/*当现在指向空时跳出循环*/continue; }pre=pre->next;inpt=(PLOY *)malloc(sizeof(PLOY));/*创建新链节*/inpt->coef=pre->coef*head1->coef;inpt->expn=pre->expn+head1->expn;inpt->next=NULL;insert(res,inpt); } /*把当前"g(x)"的链节插入到"y(x)"中*/return res; }void print(PLOY *fun) { /*输出多项式*/PLOY *printing;int flag=0;printing=fun->next;/*正在被打印的链节*/if(fun->next==NULL) { /*如果函数为空打印0*/printf("0\n");return; }while(flag==0) {if(printing->coef>0&&fun->next!=printing)printf("+");/*为正数时打印"+"号*/if(printing->coef==1);/*如果为"1"就不用打印系数了*/else if(printing->coef==-1)printf("-");/*如果为"-1"就打印"-"号就行了*/elseprintf("%f",printing->coef);/*其余情况都得打印*/if(printing->expn!=0) printf("x^%d",printing->expn);/*如果指数为"0"不打印指数项*/else if((printing->coef==1)||(printing->coef==-1))printf("1");if(printing->next==NULL)flag=1;/*如果现在的链节没有下一个就结束*/elseprinting=printing->next; }printf("\n"); }int Polynomial_solve() {PLOY *f,*g;int sign=-1;/*设置标志*/start();while(sign!=0) {scanf("%d",&sign);switch(sign) {case 0:exit(0);break;/*退出*/printf("你选择的操作是多项式相加:\n");f=creat('f');/*输入多项式f(x)*/printf("f(x)=");print(f);g=creat('g');/*输入多项式g(x)*/printf("g(x)=");print(g);printf("F(x)=f(x)+g(x)=");f=addPLOY(f,g);/*两个多项式相加*/print(f);sign=-1;/*复位标志*/start();/*回复用户选择界面*/break; }case 2: {printf("你选择的操作是多项式相乘:\n");f=creat('f');/*输入多项式f(x)*/printf("f(x)=");print(f);g=creat('g');/*输入多项式g(x)*/printf("g(x)=");print(g);printf("F(x)=f(x)*g(x)=");f=byPLOY(f,g);/*两个多项式相加*/print(f);sign=-1;/*复位标志*/start();/*回复用户选择界面*/break; }case 3: {printf("你选择的操作是多项式相减:\n");f=creat('f');/*输入多项式f(x)*/printf("f(x)=");print(f);g=creat('g');/*输入多项式g(x)*/printf("g(x)=");print(g);printf("F(x)=f(x)-g(x)=");f=byPLOY(f,g);/*两个多项式相加*/print(f);sign=-1;/*复位标志*/start();/*回复用户选择界面*/break; }default: {printf("输入有误!请重新选择操作!\n");/*选择错误,返回选择界面*/break; }}}}void input(int i){printf("请输入航班代号：\n");scanf("%s",ti[i].ID);printf("请输入起飞地点：\n");scanf("%s",ti[i].BePlace);printf("请输入降落地点：\n");scanf("%s",ti[i].EnPlace);printf("请输入起飞时间：\n");scanf("%s",ti[i].data);printf("请输入航班的最大载客人数：\n");scanf("%d",&ti[i].max);printf("请输入航班的票价：\n");scanf("%d",&ti[i].price);ti[i].num=0;}void enter(){int i;system( "cls" );printf("请输入航班的数目(0-%d)?:",N);scanf("%d",&n); /*要输入的记录个数*/printf("\n请输入数据\n\n");for(i=0;i<n;i++){printf("\n请输入第 %d 航班记录.\n",i+1);input(i); }/*调用输入函数*/getchar();menu();}void printf_one(int i) { /*显示一个记录的函数*/printf("%11s %6s %10s %6s %6d %6d %6d",ti[i].ID,ti[i].BePlace,ti[i].EnP lace,ti[i].data,ti[i].price,ti[i].max,ti[i].num);}void browse(){int i;system( "cls" );puts("\n--------------------------------------------------------------------"); printf("\n\t航班代号起飞地点降落地点起飞时间票价最大乘客已售票数\n"); for(i=0;i<n;i++){printf_one(i);printf("\n");}getchar();getchar();void order(){/*排序模块(按平均成绩)*/int i,j;struct plane s;system( "cls" );for(i=0;i<n;i++){/*冒泡法排序*/for(j=i+1;j<n;j++)if(strcmp(ti[i].data,ti[j].data)>0){s=ti[i];ti[i]=ti[j];ti[j]=s;}}browse();}void search_time(){int i,m=0;struct plane s;system( "cls" );printf("\n\nEnter the time:");scanf("%s",s.data); /*输入出发的时间*/puts("\n--------------------------------------------------------------------"); printf("\n\t航班代号起飞地点降落地点起飞时间票价最大乘客已售票数\n"); for(i=0;i<n;i++){if(strcmp(s.data,ti[i].data)==0){m++;if((m!=0)&&(m%10==0)) {/*目的是分屏显示*/printf("\n\nPress any key to contiune . . .");getchar();puts("\n\n");}printf_one(i);printf("\n");}/*调用显示一个记录的函数*/}puts("\n--------------------------------------------------------------------"); getchar(); /*按任意健*/getchar();menu1();}void serch_end(){int i,m=0;struct plane s;system( "cls" );printf("\n\nEnter the end Place:");scanf("%s",s.EnPlace); /*输入要到达的地方*/puts("\n--------------------------------------------------------------------"); printf("\n\t航班代号起飞地点降落地点起飞时间票价最大乘客已售票数\n"); for(i=0;i<n;i++){if(strcmp(ti[i].EnPlace,s.EnPlace)==0){m++;if((m!=0)&&(m%10==0)) {/*目的是分屏显示*/printf("\n\nPress any key to contiune . . .");getchar();puts("\n\n");}printf_one(i);printf("\n");}/*调用显示一个记录的函数*/}puts("\n--------------------------------------------------------------------"); getchar(); /*按任意健*/getchar();menu1();}void menu1(){int n,w1;do{system( "cls" ); /*清屏*/puts("\t\t\t\t 飞机售票操作!\n\n");puts("\t\t*********************MENU*********************\n\n");puts("\t\t\t\t1.按照时间排序");puts("\t\t\t\t2.按照时间查找航班");puts("\t\t\t\t3.按照地点查找航班");puts("\t\t\t\t4.返回主菜单");puts("\n\n\t\t**********************************************\n");printf("Choice your number(1-4): [ ]\b\b");scanf("%d",&n);if(n<1||n>4){/*对选择的数字作判断*/w1=1;printf("your choice is not between 1 and 4,Please input again:");getchar();getchar();}else w1=0;} while(w1==1);switch(n){/*选择功能* /case 1:order();break;case 2:search_time();break;case 3:serch_end();break;case 4:menu();break; }}int search(){ /*查找模块*/int i,k;struct plane s;k=-1;system( "cls" );printf("\n\n请输入要订票的起飞地点:");scanf("%s",s.BePlace); /*输入要到达的地方*/printf("\n\n请输入要订票的降落地点:");scanf("%s",s.EnPlace);printf("\n\n请输入要订票的起飞时间:");scanf("%s",s.data); /*输入出发的时间*/for(i=0;i<n;i++){ /*查找要修改的数据*/if(strcmp(s.BePlace,ti[i].BePlace)==0&&strcmp(s.EnPlace,ti[i].EnPlace)==0&&strc mp(s.data,ti[i].data)==0){k=i; /*找到要修改的记录*/printf_one(k);break; }/*调用显示一个记录的函数*/}if(k==-1){printf("\n\nNO exist!");return -1;}elsereturn k;}void book(){int i;system( "cls" );printf("欢迎进入售票窗口!\n");i=search();if(i!=-1){if(ti[i].num>=ti[i].max)printf("\n该趟航班票已售完！");else{ti[i].num++;printf("\n订票成功!\n");}}elseprintf("该航班不存在!\n");getchar();getchar(); /*按任意健*/menu();}void back(){int i,k=-1;struct plane s;system( "cls" );printf("欢迎进入退票窗口!\n");printf("\n\n输入航班代号:");scanf("%s",s.ID); /*输入要到达的地方*/for(i=0;i<n;i++){/*查找要修改的数据*/if(strcmp(s.ID,ti[i].ID)==0){k=i; /*找到要修改的记录*/printf_one(k);break; }/*调用显示一个记录的函数*/}if(k==-1)printf("\n\nNO exist!");else{ti[i].num--;printf("\n退票成功!\n");}getchar(); /*按任意健*/getchar(); /*按任意健*/menu();}void save(){int w=1;FILE *fp;int i;system( "cls" );if((fp=fopen("\\ticket.txt","wt"))==NULL) { /*以输出打开方式,在此前的记录被覆盖*/printf("\nCannot open file\n");return ;}for(i=0;i<n;i++)if(fwrite(&ti[i],sizeof(struct plane),1,fp)!=1){printf("file write error\n");w=0;}if(w==1)printf("file save ok!\n");fclose(fp);getchar();getchar();menu();}void load(){FILE*fp;int i,w;w=1;system( "cls" );if((fp=fopen("\\ticket.txt","rt"))==NULL){printf("\nCannotopen file\n");w=0;return ;}n=0;for(i=0;!feof(fp);i++){fread(&ti[i],sizeof( struct plane),1,fp);n++;}n=n-1;fclose(fp);if(w==1)printf("Load file ok!");getchar();getchar();menu();}void menu(){int n,w1;do{system( "cls" ); /*清屏*/ /*清屏*/puts("\t\t\t\t 飞机售票管理系统!\n\n");puts("\t\t*********************MENU*********************\n\n");puts("\t\t\t\t1.输入新航班");puts("\t\t\t\t2.浏览 ");puts("\t\t\t\t3.航班操作");puts("\t\t\t\t4.订票");puts("\t\t\t\t5.退票");puts("\t\t\t\t6.保存");puts("\t\t\t\t7.载入");puts("\t\t\t\t8.退出");puts("\n\n\t\t**********************************************\n");printf("Choice your number(1-8): [ ]\b\b");scanf("%d",&n);if(n<1||n>8) { /*对选择的数字作判断*/w1=1;printf("your choice is not between 1 and 8,Please input enter to choice again:");getchar();getchar();}else w1=0;} while(w1==1);switch(n){ /*选择功能*/case 1:enter();break; /*输入模块*/case 2:browse();break; /*浏览模块*/case 3:menu1();break; /*查找模块*/case 4:book();break; /*订票模块*/case 5:back();break; /*退票模块*/case 6:save();break; /*保存模块*/case 7:load();break; /*加载模块*/case 8:exit(0);}}int Ticket_system(){menu();}int main(){char ucflag;hchar ucchar[2];do{printf("**********欢迎进入系统!**********\n"); printf("* 1:一元多项式求解. *\n"); printf("* 2:飞机售票操作. *\n"); printf("* 0:退出. *\n"); printf("*********************************\n"); printf("请选择:\n");scanf(" %c",&ucflag);gets(ucchar);if(strlen(ucchar))ucflag='3';switch(ucflag-'0'){case 0:printf("谢谢使用!\n");break;case 1:Polynomial_solve();break;case 2:Ticket_system();break;default:printf("输入错误!请重新输入!\n");break;}}while(ucflag!='0');return 0;}欢迎下载，资料仅供参考!!!资料仅供参考!!!h。

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)⒈设计内容与要求设计内容：设计一个稀疏多项式简单计算器，能够进行简单的基本运算。

1.一元多项式加法、减法、乘法运算的完成 1)设计内容〔1〕使用顺序存储结构完成多项式加、减、乘运算。

例如：10321058)(2456+-+-+=x x x x x x f ,x x x x x x g +--+=23451020107)( 求和结果：102220128)()(2356++-+=+x x x x x g x f 〔2〕使用链式存储结构完成多项式加、减、乘运算，10305100)(1050100+-+=x x x x f ，x x x x x x g 320405150)(10205090+++-= 求和结果：1031040150100)()(102090100++-++=+x x x x x x g x f 2〕设计要求〔1〕用C 语言编程完成上述实验内容中的结构定义和算法。

〔2〕要有main()函数，并且在main()函数中使用检测数据调用上述算法。

〔3〕用switch 语句设计如下选择式菜单。

***************数据结构综合性实验**************** *******一、多项式的加法、减法、乘法运算********** ******* 1.多项式创立 ********** ******* 2.多项式相加 ********** ******* 3.多项式相减 ***************** 4.多项式相乘 ********** ******* 5.清空多项式 ********** ******* 0.退出系统 ********** ******* 请选择〔0—5〕 ********** ************************************************* *请选择〔0-5〕:根据下面给出的存储结构定义：#define MAXSIZE 20 //定义线性表最大容量 //定义多项式项数据类型 typedef struct{float coef; //系数int expn; //指数}term,elemType;typedef struct{term terms[MAXSIZE]; //线性表中数组元素int last; //指向线性表中最后一个元素位置}SeqList;typedef SeqList polynomial;根本操作函数说明polynomial*Init_Polynomial();//初始化空的多项式int PloynStatus(polynomial*p)//推断多项式的状态int Location_Element(polynomial*p,term x)在多项式p中查找与x项指数相同的项是否存在int Insert_ElementByOrder(polynomial*p,term x)//在多项式p中插入一个指数项xint CreatePolyn(polynomial*P,int m)//输入m项系数和指数，建立表示一元多项式的有序表pchar compare(term term1,term term2)//比拟指数项term1和指数项term2polynomial*addPloyn(polynomial*p1,polynomial*p2)//将多项式p1和多项式p2相加，生成一个新的多项式polynomial*subStractPloyn(polynomial*p1,polynomial*p2)//多项式p1和多项式p2相减，生成一个新的多项式polynomial*mulitPloyn(polynomial*p1,polynomial*p2)//多项式p1和多项式p2相乘，生成一个新的多项式void printPloyn(polynomial*p) //输出在顺序存储结构的多项式p#include<stdlib.h>#include<stdio.h>#include<iostream.h>#define NULL 0#define MAXSIZE 20typedef struct{float coef;int expn;}term,elemType;typedef struct{term terms[MAXSIZE];int last;}SeqList;typedef SeqList polynomial; void printPloyn(polynomial*p); int PloynStatus(polynomial*p) {if(p==NULL){return -1;}else if(p->last==-1){return 0;}else{return 1;}}polynomial*Init_Polynomial() {polynomial*P;P=new polynomial;if(P!=NULL){P->last=-1;return P;}else{return NULL;}}void Reset_Polynomial(polynomial*p){if(PloynStatus(p)==1){p->last=-1;}}int Location_Element(polynomial*p,term x){int i=0;if(PloynStatus(p)==-1)return 0;while(i<=p->last && p->terms[i].expn!=x.expn) {i++;}if(i>p->last){return 0;}else{return 1;}}int Insert_ElementByOrder(polynomial*p,term x) {int j;if(PloynStatus(p)==-1)return 0;if(p->last==MAXSIZE-1){cout<<"The polym is full!"<<endl;return 0;}j=p->last;while(p->terms[j].expn<x.expn && j>=0){p->terms[j+1]=p->terms[j];j--;}p->terms[j+1]=x;p->last++;return 1;}int CreatePolyn(polynomial*P,int m){float coef;int expn;term x;if(PloynStatus(P)==-1)return 0;if(m>MAXSIZE){printf("顺序表溢出\n");return 0;}else{printf("请依次输入%d对系数和指数...\n",m);for(int i=0;i<m;i++){scanf("%f%d",&coef,&expn);x.coef=coef;x.expn=expn;if(!Location_Element(P,x)){Insert_ElementByOrder(P,x);}}}return 1;}char compare(term term1,term term2){if(term1.expn>term2.expn){return'>';}else if(term1.expn<term2.expn){return'<';}else{return'=';}}polynomial*addPloyn(polynomial*p1,polynomial*p2){int i,j,k;i=0;j=0;k=0;if((PloynStatus(p1)==-1)||(PloynStatus(p2)==-1)){return NULL;}polynomial*p3=Init_Polynomial();while(i<=p1->last && j<=p2->last){switch(compare(p1->terms[i],p2->terms[j])){case'>':p3->terms[k++]=p1->terms[i++];p3->last++;break;case'<':p3->terms[k++]=p2->terms[j++];p3->last++;break;case'=':if(p1->terms[i].coef+p2->terms[j].coef!=0){p3->terms[k].coef=p1->terms[i].coef+p2->terms[j].coef;p3->terms[k].expn=p1->terms[i].expn;k++;p3->last++;}i++;j++;}}while(i<=p1->last){p3->terms[k++]=p1->terms[i++];p3->last++;}return p3;}polynomial*subStractPloyn(polynomial*p1,polynomial*p2){int i;i=0;if((PloynStatus(p1)!=1)||(PloynStatus(p2)!=1)){return NULL;}polynomial*p3=Init_Polynomial();p3->last=p2->last;for(i=0;i<=p2->last;i++){p3->terms[i].coef=-p2->terms[i].coef;p3->terms[i].expn=p2->terms[i].expn;}p3=addPloyn(p1,p3);return p3;}polynomial*mulitPloyn(polynomial*p1,polynomial*p2){int i;int j;int k;i=0;if((PloynStatus(p1)!=1)||(PloynStatus(p2)!=1)){return NULL;}polynomial*p3=Init_Polynomial();polynomial**p=new polynomial*[p2->last+1];for(i=0;i<=p2->last;i++){for(k=0;k<=p2->last;k++){p[k]=Init_Polynomial();p[k]->last=p1->last;for(j=0;j<=p1->last;j++){p[k]->terms[j].coef=p1->terms[j].coef*p2->terms[k].coef;p[k]->terms[j].expn=p1->terms[j].expn+p2->terms[k].expn;}p3=addPloyn(p3,p[k]);}}return p3;}void printPloyn(polynomial*p){int i;for(i=0;i<=p->last;i++){if(p->terms[i].coef>0 && i>0)cout<<"+"<<p->terms[i].coef;elsecout<<p->terms[i].coef;cout<<"x^"<<p->terms[i].expn;}cout<<endl;}void menu(){cout<<"\t\t*******数据结构综合性实验*********"<<endl;cout<<"\t\t***一、多项式的加、减、乘法运算***"<<endl;cout<<"\t\t******* 1.多项式创立 *********"<<endl;cout<<"\t\t******* 2.多项式相加 *********"<<endl;cout<<"\t\t******* 3.多项式相减 *********"<<endl;cout<<"\t\t******* 4.多项式相乘 *********"<<endl;cout<<"\t\t******* 5.清空多项式 *********"<<endl;cout<<"\t\t******* 0.退出系统 *********"<<endl;cout<<"\t\t****** 请选择(0-5) ********"<<endl;cout<<"\t\t***********************************"<<endl; }void main(){int sel;polynomial*p1=NULL;polynomial*p2=NULL;polynomial*p3=NULL;while(1){menu();cout<<"\t\t*请选择(0-5):";cin>>sel;switch(sel){case 1:p1=Init_Polynomial();p2=Init_Polynomial();int m;printf("请输入第一个多项式的项数:\n");scanf("%d",&m);CreatePolyn(p1,m);printf("第一个多项式的表达式为p1=");printPloyn(p1);printf("请输入第二个多项式的项数:\n");scanf("%d",&m);CreatePolyn(p2,m);printf("第二个多项式的表达式为p2=");printPloyn(p2);break;case 2:printf("p1+p2=");if((p3=subStractPloyn(p1,p2))!=NULL)printPloyn(p3);break;case 3:printf("\np1-p2=");if((p3=subStractPloyn(p1,p2))!=NULL)printPloyn(p3);break;case 4:printf("\np1*p2=");if((p3=mulitPloyn(p1,p2))!=NULL)printPloyn(p3);case 5:Reset_Polynomial(p1);Reset_Polynomial(p2);Reset_Polynomial(p3);break;case 0:return;}}return;}1〕设计内容以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。

##大学数据结构课程设计报告题目：顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现院（系）：计算机工程学院学生姓名:班级：学号:起迄日期: 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已存在。

数据结构课程设计题目：一元多项式计算器学生姓名：刘胜寒学号：1006403005系别：计算机科学与技术专业：计算机科学与技术指导教师：马竹根讲师起止日期： 2012.3.29——2012.4.52012年 4月 9 日目录一元多项式操作的设计与开发 (I)摘要 (I)关键词 (I)1 前言 (1)2 需求分析 (2)2.1 范围 (2)2.1.1 标识 (2)2.1.2 系统概述 (2)2.2 需求概述 (3)2.2.1 系统目标 (3)2.2.2 运行环境 (3)2.2.3 实验环境 (3)Windows 2000 以上，C-Free任意版本。

(3)2.2.4 用户的特点 (3)2.3功能需求 (3)3 概要设计 (3)3.1 范围 (4)3.1.1 标识 (4)3.1.2 系统概述 (4)3.2 系统结构 (4)4 系统详细设计 (5)4.1 范围 (5)4.1.1 标识 (5)4.1.2 系统概述 (5)4.2 详细设计说明 (5)4.2.2 字符串处理算法 (6)4.2.2 提取多项式各个参数算法设计 (7)4.2.3 加减算法设计 (9)4.2.4 乘法算法设计 (11)4.2.5 化简算法设计 (12)5 测试说明 (14)5.1 范围 (14)5.1.1 标识 (14)5.1.2 系统概述 (14)5.2 测试计划及预期结果 (15)5.3 具体测试情况 (15)６总结 (16)致谢 (17)附录 (18)一元多项式操作的设计与开发摘要系统本次试验依据2012年怀化学院10级数据结构实验要求，较完善的对题目进行了分析，理解和编程，程序思路清晰，考虑全面。

对于此题，可以使用线性表和链式表存储结构存储多项式信息。

并根据C 语言算法进行编程。

同时本书在后面附带了一部分程序源码和对程序同步的解释。

在用C语言编程的时候，要用到的语句主要有函数调用语句，判断语句，输出和输入语句。

关键词一元多项式线性表系数指数1 前言本次课程设计的的目的：是对数据结构所学的额内容进一步理解与巩固，是将计算机课程与实际问题联结起来的关键步骤。

数据结构课程设计题目：一元多项式简单计算一、实验题目：一元多项式简单计算二、实验目的熟悉掌握一元多项式在链式存储结构上的实现，能够按照指数降序排列建立并输出多项式。

能够完成两个多项式的相加、相减，并将结果输出。

体会链式存储结构的优缺点和适用性。

三、实验内容1、需求分析建立一元多项式并按照指数降序排列输出多项式，将一元多项式输入并存储在内存中，能够完成两个多项式的加减运算并输出结果2、概要设计存储结构：一元多项式的表示在计算机内可以用链表来表示，为了节省存储空间，只存储多项式中系数非零的项。

链表中的每一个结点存放多项式的一个系数非零项，它包含三个域，分别存放该项的系数、指数以及指向下一个多项式项结点的指针。

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

基本算法：1、输入输出（1）功能：将要进行运算的多项式输入输出。

（2）数据流入：要输入的多项式的系数与指数。

（3）数据流出：合并同类项后的多项式。

（4）程序流程图：多项式输入流程图如图1所示。

（5）测试要点：输入的多项式是否正确，若输入错误则重新输入2、多项式的加法（1）功能：将两多项式相加。

（2）数据流入：输入函数。

（3）数据流出：多项式相加后的结果。

（4）程序流程图：多项式的加法流程图如图2所示。

（5）测试要点：两多项式是否为空，为空则提示重新输入，否则，进行运算。

3、详细设计#include <stdio.h>#include <malloc.h>typedef struct polynode {int coef;int expn;struct polynode *next;} *pnode;pnode createpoly(){int a,n,i=1;pnode head,s,p;printf("输入多元一项式（以0,0标志结束）\n");printf("要求：1、按幂从大到小次序输入各结点\n"); printf(" 2、没有两个结点具有相同的幂:\n"); head=(pnode)malloc(sizeof(struct polynode));head->next=NULL;p=head;do{printf("第%d次->系数,幂:",i++);scanf("%d,%d",&a,&n);if (a!=0 || n!=0){s=(pnode)malloc(sizeof(struct polynode));s->coef=a;s->expn=n;s->next=NULL;p->next=s;p=s;}} while (a!=0 || n!=0);printf("\n");return(head);}void printpoly(pnode head){int first=1;head=head->next;while (head!=NULL){if (first){if (head->expn==1)printf("%dx",head->coef);else if (head->expn==0)printf("%d",head->coef);elseprintf("%dx^%d",head->coef,head->expn);first=0;}else{if (head->expn==1)printf("%+dx",head->coef);else if (head->expn==0)printf("%+d",head->coef);elseprintf("%+dx^%d",head->coef,head->expn);}head=head->next;}printf("\n");}pnode addpoly(pnode pa,pnode pb){int n;pnode pc,s,p;pa=pa->next;pb=pb->next;pc=(pnode)malloc(sizeof(struct polynode));pc->next=NULL;p=pc;while (pa!=NULL && pb!=NULL){if (pa->expn>pb->expn){s=(pnode)malloc(sizeof(struct polynode));s->coef=pa->coef;s->expn=pa->expn;s->next=NULL;p->next=s;p=s;pa=pa->next;}else if (pa->expn<pb->expn){s=(pnode)malloc(sizeof(struct polynode));s->coef=pb->coef;s->expn=pb->expn;s->next=NULL;p->next=s;p=s;pb=pb->next;}else{n=pa->coef+pb->coef;if (n!=0){s=(pnode)malloc(sizeof(struct polynode));s->coef=n;s->expn=pb->expn;s->next=NULL;p->next=s;p=s;}pa=pa->next;pb=pb->next;}}while (pa!=NULL){s=(pnode)malloc(sizeof(struct polynode)); s->coef=pa->coef;s->expn=pa->expn;s->next=NULL;p->next=s;p=s;pa=pa->next;}while (pb!=NULL){s=(pnode)malloc(sizeof(struct polynode)); s->coef=pb->coef;s->expn=pb->expn;s->next=NULL;p->next=s;p=s;pb=pb->next;}return(pc);}main(){ printf(“题目：一元多项式简单运算\n”);printf(“姓名：何琴\n”);printf(“学号：1041011109\n”);pnode poly1,poly2,poly3;printf("建立第一个一元多项式=>\n");poly1=createpoly();printf("建立第二个多元多项式=>\n");poly2=createpoly();poly3=addpoly(poly1,poly2);printf("第一个一元多项式为:");printpoly(poly1);printf("第二个一元多项式为:");printpoly(poly2);printf("相加后一元多项式为:");printpoly(poly3);}4、运行结果四、实验体会通过这一周的课程设计，我感觉到要真正做出一个程序并不很容易,但只要用心去做，总会有收获,特别是当我遇到问题,问老师，问同学，想尽办法去解决,最后终于找到方法时,心里的那份喜悦之情真是难以形容.编写程序中遇到问题再所难免,应耐心探究其中的原因,从出现问题的地方起,并联系前后程序,仔细推敲,逐个排查.直到最终搞清为止。

《数据结构》课程设计多项式计算班级：学号：姓名：指导老师：多项式计算1、问题描述能够按照指数降序排列建立多项式；能够完成两个多项式的相加、相减和相乘，并将结果输出。

2、设计思路这个程序的关键是多项式的创建和排列，以及相乘时系数相乘和指数相加、相加时相同指数的系数相加、相减时相同指数的系数相减。

由于多项式拥有指数和系数（假设基数已定），所以可以定义一个包含指数系数的结构体，用单链表存储多项式的数据，所以结构体包含next指针。

数据插入时比较两数的指数，按照降序排序，从表头的next开始，直至找到合适的位置，然后开始链表中数值的插入，如果相等则直接将指数相加，如果大于就将新数据插入到当前指向的前面，否则将新数据插入到最后。

输入完数据后选择计算方式（相乘、相加、相减），多项式运算时要循环遍历整个多项式，多项式的每一组数据都要和另一个多项式整组数据相运算（每一个运算值都存储到新建的“多项式”链表中），直到两个多项式都遍历完结束。

3、数据结构设计在模拟多项式对象时，为了简化处理，只取最核心的两个数据：多项式的系数和指数。

前面提到，要用单链表操作，所以要加上个next指针，再由该结构体定义一个结点类型和指针类型。

具体数据结构定义如下：typedef struct node{int xs; /*系数*/int zs; /*指数*/struct node * next; /*next指针*/}Dnode,* Dnodelist;4、功能函数设计（1）链表初始化函数Creat_node()带有头结点的头指针指向空（NULL）。

（2）多项式数据的创建函数Creat_Dmeth()当链表初始化成功后，开始创建多项式。

分别循环输入两个多项式的系数和指数，其中要用到插入函数。

（3）数据的插入函数Insert_node()当创建多项式时，要用到此函数，即利用插入的方式将多项式的数据连接起来。

再输入一组数据后，程序自动调用此函数，插入时也进行着排序，从表头的next开始，一一比较指数大小，直到大于或等于当前指向的数据或遍历完所有数据时停止，然后开始链表中数值的插入，如果相等则直接将指数相加，如果大于就将新数据插入到当前指向的前面，否则将新数据插入到最后。

数学与计算机学院课程设计说明书课程名称: 数据结构课程设计课程代码: 8404181题目:一元多项式运算的实现年级/专业/班: 2009-计科-3学生姓名:学号: 312009*********开始时间:2011 年06 月13日完成时间:2011 年06月21 日课程设计成绩：学习态度及平时成绩（30）技术水平与实际能力（20）创新（5）说明书撰写质量（45）总分（100）指导教师签名：年月日目录1 引言 (1)1.1问题的提出 (1)1.2国内外研究的现状 (1)1.3任务与分析 (1)2程序的主要功能 (2)2.1一元多项式创建 (2)2.2一元多项式的加法 (2)2.3一元多项式的减法 (2)2.4一元多项式的乘法 (2)2.5一元多项式项的指数比较 (2)2.6一元多项式运算结果升降排序 (2)2.7一元多项式的输出 (3)2.8一元多项式的销毁 (3)3 程序运行平台 (4)4 总体设计 (5)5 程序类的说明 (6)6 模块分析 (7)6.1创建模块 (8)6.2一元多项式的加法 (10)6.3一元多项式相减 (12)6.4一元多项式相乘 (15)6.5一元多项式输出结果按项的指数排序 (17)6.6一元多项式运算系统实现 (21)7系统测试 (32)8 结论 (38)摘要随着计算机的普及，对数学中一元多项式的研究也逐渐普及，计算机程序员通过对其结构的分析，针对其特殊的结构，利用不同的计算机设计语言编程利用计算机系统实现了对一元多项式的一系列操作。

本课程设计中主要利用C、C++语言编写程序实现了稀疏一元多项式的简单运算系统，该系统具有一元多项式顺序和动态两种存储结构，实现了一元多项式的加法、减法、乘法运算等功能。

关键词：计算机; 一元多项式; C；C++;顺序存储；动态存储1 引言1.1 问题的提出随着计算机的不断发展，计算机的线性表的应用越来越广泛，如今线性表在计算器程序上的应用已达非常成熟的阶段。

一元多项式计算课程设计一、课程目标知识目标：1. 理解一元多项式的概念，掌握其标准形式和各项系数的含义。

2. 学会使用合适的方法进行一元多项式的加、减、乘运算，并能够准确写出结果。

3. 掌握一元多项式的除法法则，能对给定的一元多项式进行长除法运算。

技能目标：1. 能够运用所学知识解决实际问题中涉及一元多项式的计算问题。

2. 培养学生运用代数运算解决复杂问题的能力，提高逻辑思维和运算准确性。

3. 通过一元多项式的运算，提升学生的数学表达和推理能力。

情感态度价值观目标：1. 培养学生对数学学习的兴趣，激发学生主动探索一元多项式运算规律的积极性。

2. 培养学生团队合作意识，通过小组讨论与合作，共同解决一元多项式运算中的问题。

3. 引导学生认识到数学知识在实际生活中的应用，体会数学学习的实用价值。

课程性质：本课程为初中数学课程，旨在帮助学生掌握一元多项式的运算方法，提高数学思维和解决问题的能力。

学生特点：初中年级的学生已经具备一定的代数基础，但运算技巧和逻辑思维能力有待提高。

教学要求：注重理论与实践相结合，通过具体例题和练习，使学生熟练掌握一元多项式的计算方法，并能应用于实际问题。

在教学过程中，关注学生的个体差异，提供个性化指导，确保每个学生都能达到课程目标。

二、教学内容本课程依据课程目标，结合教材内容，组织以下教学重点：1. 一元多项式的定义与表示：介绍一元多项式的概念，包括常数项、一次项、二次项等，并学习其标准形式。

2. 一元多项式的加减法：讲解同类项合并原则，通过实例演示和练习，使学生掌握一元多项式的加减运算。

3. 一元多项式的乘法：教授多项式乘法法则，运用分配律进行展开，并通过典型例题强化学生乘法运算技巧。

4. 一元多项式的除法：详细讲解长除法运算步骤，以及商和余数的概念，通过实际操作和练习，提高学生除法运算能力。

教学内容安排如下：第一课时：一元多项式的定义与表示，同类项的合并。

第二课时：一元多项式的加法和减法运算。

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

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

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

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

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

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

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

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

学号：201040410113课程设计题目一元多项式的运算教学院计算机学院专业计算机科学与技术班级一班姓名王建国指导教师邓丹君2011 年12 月30 日课程设计任务书2011 ～2012 学年第 1 学期学生姓名：王建国专业班级： 10级计科1班指导教师：邓丹君工作部门：计算机学院一、课程设计题目一元多项式的运算二、课程设计内容1．一元多项式的存储2．一元多项式的加法与减法3．一元多项式的乘法三、进度安排1、2011年12月19日，设计动员，布置任务2、2011年12月20日到21日，查阅资料，分析、讨论与设计3、2011年12月22日到27日，编写程序，进行调试4、2011年12月28日到29日完成模块联调，进行测试5、2011年12月30日，成果验收，完成设计报告四、基本要求1．用C语言实现一元多项式的运算.2．利用链表实现一元多项式运算的存储.3．该程序具有加法、减法、乘法基本运算功能.4. 程序的各个功能模块要求用函数的形式实现.5. 完成设计任务并书写课程设计报告。

目录一概述 (3)二总体方案设计 (4)三详细设计 (6)四程序的调试与运行结果说明 (12)五课程设计总结 (16)参考文献 (17)附录：程序源代码 (18)一概述1.课程设计的目的1．理解和掌握该课程中的有关基本概念，程序设计思想和方法。

2．培养综合运用所学知识独立完成课题的能力。

3．培养勇于探索、严谨推理、实事求是、有错必改，用实践来检验理论，全方位考虑问题等科学技术人员应具有的素质。

4．掌握从资料文献、科学实验中获得知识的能力，提高学生从别人经验中找到解决问题的新途径的悟性，初步培养工程意识和创新能力。

2.课程设计的要求1．用C语言实现一元多项式的运算.2．利用链表实现一元多项式运算的存储.3．该程序具有加法、减法、乘法基本运算功能.4. 程序的各个功能模块要求用函数的形式实现.5. 完成设计任务并书写课程设计报告。

一元多项式的计算数据结构专业课程设计一元多项式的计算—加，减摘要(题目)一元多项式计算任务：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减，并将结果输入；目录一:引言:通过C语言使用链式存储结构实现一元多项式加法、减法和乘法的运算。

按指数降序排列。

二：需求分析建立一元多项式并按照指数降序排列输出多项式，将一元多项式输入并存储在内存中，能够完成两个多项式的加减运算并输出结果三：概要设计存储结构：一元多项式的表示在计算机内可以用链表来表示，为了节省存储空间，只存储多项式中系数非零的项。

链表中的每一个结点存放多项式的一个系数非零项，它包含三个域，分别存放该项的系数、指数以及指向下一个多项式项结点的指针。

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

1．单连表的抽象数据类型定义：ADT List{ 数据对象：D={ai|ai∈ElemSet,i=1,2,…,n,n≥0} 数据关系：R1={<ai-1,ai>| ai-1, ai∈D,i=2,…,n}基本操作：InitList（＆L）//操作结果：构造一个空的线性表CreatPolyn(&L)//操作结果：构造一个以单连表存储的多项试DispPolyn(L)//操作结果：显示多项试Polyn(&pa,&pb)//操作结果：显示两个多项试相加，相减的结果} ADT List2．本程序包含模块： typedef struct LNode //定义单链表{}LNode,*LinkList;void InitList(LinkList &L) //定义一个空表{ }void CreatPolyn(LinkList &L) //用单链表定义一个多项式{ }void DispPolyn(LinkList L) //显示输入的多项式{ }void Polyn(LinkList &pa,LinkList &pb){}void main(){//定义一个单连表；cout<<endl<<" *****************欢迎来到一元多项式计算程序 *************** "<<endl;LNode *L1,*L2;Polyn(L1,L2); }加，减操作模块——实现加减操作各模块之间的调用关系如下：主程序模块加法操作模块 减法操作模块基本算法：1、输入输出（1）功能：将要进行运算的多项式输入输出。

信息科学与技术学院 《数据结构》课程设计报告完成日期：2012-12题目名称： 一元多项式运算 专业班级： 计算机科学与技术学生姓名： 11 学生学号： 11111111 指导教师： 11111111目录1 课程设计的目的 (4)1.1 课程设计的目的 (4)1.2 课程设计的题目 (4)1.3 题目要求 (4)2 概要设计 (5)2.1 存储结构 (5)2.2 基本操作 (5)3 详细设计 (6)3.1总体流程图 (6)3.2主模块 (7)3.3、查找位置插入链接模块 (7)3.3.1函数功能： (7)3.3.2函数入口： (8)3.3.3函数流程图： (8)3.4、创建多项式模块 (9)3.4.1函数功能： (9)3.4.2函数入口： (9)3.4.3函数流程图： (9)3.5、多项式相加模块 (10)3.5.1函数功能： (10)3.5.2函数入口： (10)3.5.3函数流程图 (10)3.6多项式相乘模块 (10)3.6.1函数功能： (10)3.6.2函数入口： (11)3.6.3函数流程图： (11)3.7多项式求导模块 (11)3.7.1函数功能： (11)3.7.2函数入口： (12)3.7.3函数流程图： (12)3.8输出多项式模块 (12)3.8.1函数功能： (12)3.8.2函数入口： (12)3.8.3函数流程图： (13)4 测试 (14)4. 1用户选择界面 (14)4. 2,两个一元多项式相加功能 (15)4.3两个一元多项式相乘功能 (16)4.4对一个一元多项式求导功能: (16)4.5帮助功能: (17)5 课程设计总结 (17)6参考书目： (27)1 课程设计的目的1.1 课程设计的目的本课程设计主要解决一元多项式的运算问题，通过链表的使用，实现对一元多项式的构建、录入、存储、打印、以及之间的运算。

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

课程设计报告一元多项式系别：专业年级：学生姓名：学号 :任课教师：二○一一年三月一题目内容：一元多项式用C语言编写一段程序，该程序的功能相当于一个一元多项式计算器。

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

二解题分析2.1数据结构设计此程序的数据结构是选择用带头接待你的单链表存储多项式。

虽然一元多项式可以用顺序和链式两种存储结构表示，但是顺序结构的最大长度很难确定。

比如当多项式的系数比较大时，此时就会浪费了巨大的存储空间，所以应该选择用链式存储结构来存储一元多项式。

单链表的结构体可以用来存储多项式的系数和指数，下一个指针3个元素，这样便于实现任意多项式的加法，减法运算。

2.2 功能模块思路及设计（1）一元多项式的建立输入多项式采用采用头插法的方法，输入多项式汇总一个项的系数和指数，就产生一个新的节点，建立起来它的右指针并用头结点只想它；为了判断一个多项式是否舒服结束，定义一个结束标志，当输入为0时就结束一个多项式的输入。

（2）显示一元多项式如果系数是大于0的话就输出+系数x指数的形式；如果系数是小于0的话就输出系数X指数的形式；如果指数是0的话直接输出系数；如果系数是1的话就直接输出+X；如果系数是-1的话就直接输出-X。

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

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

P的指数大于Q的指数的话，就应该复制P节点到多项式，当第二个多项式为空，第一个多项式不为空时，将第二个多项式用新节点产生。

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

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