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

合集下载

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

一、设计题目一元多项式的加法、减法、乘法的实现。

二、主要内容设有一元多项式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、输入输出（1）功能：将要进行运算的多项式输入输出。

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

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

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

（5）测试要点：输入的多项式是否正确，若输入错误则重新输入开始申请结点空间输入多项式各项的系数 x, 指数 y输出已输入的多项式合并同类项结束否是是否输入正确图表 12、多项式的加法（1）功能：将两多项式相加。

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

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

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

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

图表 2开始定义存储结果的空链 r是否输出存储多项式的和的链r结束是否同指数项系数相加后存入r 直接把p 中各项存入r直接把q 中各项存入r存储多项式2的空链Q 是否为空存储多项式1的空链P 是否为空合并同类项3、多项式的减法（1）功能：将两多项式相减。

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

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

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

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

开始定义存储结果的空链是否合并同类项结束是否同指数项系数相加后存入r把p 中各项系数改变符号后存入直接把q 中各项存入r存储多项式2的空链Q 是否为空存储多项式1的空链P 是否为空输出存储多项式图表 3三、详细设计#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct Polynomial{float coef;int expn;struct Polynomial *next;}*Polyn,Polynomial;/**************合并同类项********************/ void Insert(Polyn p,Polyn h){if(p->coef==0) //系数为0的话释放结点free(p);else //如果系数不为0{Polyn q1,q2;q1=h;q2=h->next;while(q2&&p->expn<q2->expn)//查找插入位置{q1=q2;q2=q2->next;}if(q2&&p->expn==q2->expn)//将指数相同相合并{q2->coef+=p->coef;free(p);if(!q2->coef) //系数为0的话释放结点{q1->next=q2->next;free(q2);}}else{ //指数为新时将结点插入p->next=q2;q1->next=p;}}}/*****************合并同类项，并按升幂排序*****************/ Polyn HeBing(Polyn &L){Polyn p1,p2,p3,p4,p5,p6;float t1;int t2;p1=L->next;while(p1!=NULL) //非递减顺序排列{p2=p1->next;while(p2!=NULL){if(p1->expn>p2->expn){t1=p1->coef;t2=p1->expn;p1->coef=p2->coef;p1->expn=p2->expn;p2->coef=t1;p2->expn=t2;}p2=p2->next;}p1=p1->next;}p3=L->next;while(p3!=NULL) //合并同类项{p4=p3->next;while(p4!=NULL){if(p3->expn==p4->expn){p3->coef=p3->coef+p4->coef;p3->next=p4->next;free(p4);p4=p3->next;}elsep4=p4->next;}p3=p3->next;}p5=L;while(p5->next!=NULL) //删除零项{p6=p5->next;if(p6->coef==0){p5->next=p6->next;free(p6);}p5=p5->next;}return L;}/*****************建立一个多项式****************/ Polyn CreatPolyn(Polyn &p){Polyn h,s;p=(Polyn)malloc(sizeof(struct Polynomial));if(!p)exit(1);p->coef=0;p->expn=-1;p->next=NULL;h=p;scanf("%f%d",&p->coef,&p->expn);while(p->coef!=0||p->expn!=0)//输入数据{s=(Polyn)malloc(sizeof(struct Polynomial));if(!s)exit(1);s->coef=p->coef;s->expn=p->expn;h->next=s;h=s;scanf("%f%d",&p->coef,&p->expn);}h->next=NULL;HeBing(p);return p;}/******************多项式的销毁***************/ void DestroyPolyn(Polyn p){Polyn q1,q2;q1=p->next;q2=q1->next;while(q1->next){free(q1);q1=q2;q2=q2->next;}}/*************输出多项式**************/void PrintPolyn(Polyn P){Polyn q=P->next;int flag=1;if(!q){putchar('0');printf("\n");return;} //若多项式为空，输出0while (q){if(q->coef>0&&flag!=1) putchar('+'); //系数大于0且不是第一项if(q->coef!=1&&q->coef!=-1)//系数非1或-1的普通情况{printf("%g",q->coef);if(q->expn==1) putchar('X');else if(q->expn) printf("X^%d",q->expn);}else{if(q->coef==1){if(!q->expn) putchar('1');elseif(q->expn==1) putchar('X');else printf("X^%d",q->expn);}if(q->coef==-1){if(!q->expn) printf("-1");elseif(q->expn==1) printf("-X");else printf("-X^%d",q->expn);}}q=q->next;flag++;}printf("\n");}/************辅助乘法和加法运算*************/int compare(Polyn a,Polyn b){if(a&&b){if(!b||a->expn>b->expn)return 1;elseif(!a||a->expn<b->expn)return -1;elsereturn 0;}elseif(!a&&b)return -1;//a多项式已空，但b多项式非空elsereturn 1;//b多项式已空，但a多项式非空}/*************多项式的加法*********************/ Polyn AddPolyn(Polyn pa,Polyn pb){Polyn qa=pa->next;Polyn qb=pb->next;Polyn headc,hc,qc;hc=(Polyn)malloc(sizeof(struct Polynomial));hc->next=NULL;headc=hc;while(qa||qb){qc=(Polyn)malloc(sizeof(struct Polynomial));switch(compare(qa,qb)){case 1:{qc->coef=qa->coef;qc->expn=qa->expn;qa=qa->next;break;}case 0:{qc->coef=qa->coef+qb->coef;qc->expn=qa->expn;qa=qa->next;qb=qb->next;break;}case -1:{qc->coef=qb->coef;qc->expn=qb->expn;qb=qb->next;break;}}if(qc->coef!=0){qc->next=hc->next;hc->next=qc;hc=qc;}else free(qc);//当相加系数为0时，释放该结点}HeBing(headc);return headc;}/************多项式的减法*****************/Polyn SubstractPolyn(Polyn pa,Polyn pb){Polyn h=pb;Polyn p=pb->next;Polyn pd;while(p) //将pb的系数取反{p->coef*=-1;p=p->next;}pd=AddPolyn(pa,h);for(p=h->next;p;p=p->next) //恢复pb的系数p->coef*=-1;HeBing(pd);return pd;}/*****************多项式的乘法*********************/Polyn MultiplyPolyn(Polyn pa,Polyn pb){Polyn hf,pf;Polyn qa=pa->next;Polyn qb=pb->next;hf=(Polyn)malloc(sizeof(struct Polynomial));hf->next=NULL;for(;qa;qa=qa->next){for(qb=pb->next;qb;qb=qb->next){pf=(Polyn)malloc(sizeof(struct Polynomial));pf->coef=qa->coef*qb->coef;pf->expn=qa->expn+qb->expn;Insert(pf,hf);//调用Insert函数以合并指数相同的项}}HeBing(hf);return hf;}/*******************主函数*******************/void main(){Polyn p1, p2, p3, p4, p5;CreatPolyn(p1);CreatPolyn(p2);PrintPolyn(p1);PrintPolyn(p2);p3=AddPolyn(p1, p2);PrintPolyn(p3);p4=SubstractPolyn(p1, p2);PrintPolyn(p4);p5=MultiplyPolyn(p1, p2);PrintPolyn(p5);DestroyPolyn(p1);DestroyPolyn(p2);DestroyPolyn(p3);DestroyPolyn(p4);DestroyPolyn(p5);}四、调试结果1.测试的数据及结果2.算法的时间复杂度及改进算法的时间复杂度：一元多项式的加法运算的时间复杂度为O(m+n）,减法运算的时间复杂度为O(m-n)，其中m，n分别表示二个一元多项式的项数。

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

合肥学院计算机科学与技术系课程设计报告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()//主程序模块调用链一元多项式的各种基本操作模块。

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

一元多项式计算(数据结构课程设计)一、系统设计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环境中调试运行。

课程设计报告--一元多项式计算

课程设计报告一元多项式计算订票系统系别专业年级学生姓名学号任课教师二○一二年三月一、题目内容实验二一元多项式计算**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。

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

一元多项式计算摘要一元多项式计算是用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项的系数和指数，序列按指数的降序序列排列；其三，多项式排序，多项式按指数的降序序列排列；其四，多项式相加，指数相同系数相加，指数不同则把此项加进去；其五，多项式相减，指数相同系数相加，指数不同则把此项取反再加进去；其六，返回多项式的项数。

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

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 -2 功能描述.................................................... - 2 -2.1课题要求 (2)2.2软件格式规定 (2)3 设计........................................................ - 2 -3.1相关函数介绍说明 (2)3.2主程序的流程基函数调用说明 (3)4 程序设计.................................................... -5 -4.1多项式存储的实现 (5)4.2加减乘除算法 (5)4.2.1加法运算的实现................................................... - 5 - 4.2.2减法运算的实现................................................... - 6 - 4.2.3乘法运算的实现................................................... - 7 - 4.2.4除法运算的实现................................................... - 7 - 4.3函数调用关系图 (8)5 运行测试.................................................... - 9 -6 设计小结................................................... - 12 -参考文献..................................................... - 12 -谢辞....................................................... - 13 -附录：程序清单............................................... - 14 -1 问题描述1.1首先是确定结构化程序设计的流程图，利用已学过的数据结构来构造二个存储多项式的结构，接着把输入，加，减，乘，除运算分成四个主要的模块：实现多项式输入模块、实现加法的模块、实现减法的模块、实现乘法的模块、实现除法的模块，然后各个模块里面还要分成若干种情况来考虑并通过函数的嵌套调用来实现其功能。

数据结构课程设计一元多项式的加减法运算

武汉理工大学华夏学院课程设计报告书课程名称：数据结构与算法分析题目：用C语言实现一元多项式的加减法运算系名：信息工程系专业班级：物联网工程1122班姓名：隋明超学号： 10213312201 指导教师:司晓梅2014年 1 月 3 日武汉理工大学华夏学院信息工程系课程设计任务书课程名称：数据结构与算法分析指导教师：司晓梅班级名称：物联网1121-2 开课系、教研室：信息系计算机一、课程设计目的与任务《数据结构》课程设计是为训练学生的数据组织能力和提高程序设计能力而设置的增强实践能力的课程。

目的：学习数据结构课程，旨在使学生学会分析研究数据对象的特性，学会数据的组织方法，以便选择合适的数据的逻辑结构和存储结构以及相应操作，把现实世界中的问题转换为计算机内部的表示和处理，这就是一个良好的程序设计技能训练的过程。

提高学生的程序设计能力、掌握基本知识、基本技能，提高算法设计质量与程序设计素质的培养就是本门课程的课程设计的目的。

任务：根据题目要求，完成算法设计与程序实现，并按规定写出课程设计报告。

二、课程设计的内容与基本要求设计题目：用C语言实现一元多项式的加减法计算〔问题描述〕输入并建立两个多项式并输出多项式设计一个程序：对两个多项式进行加、减法运算，建立一个新多项式并输出。

〔实现提示〕：选择单链表存储多项式具体要完成的任务是：A. 编制完成上述问题的C语言程序、进行程序调试并能得出正确的运行结果。

B. 写出规范的课程设计报告书；三、课程设计步骤及时间进度和场地安排时间：本课程设计安排在第18周地点：现代教育中心具体时间安排如下：第一天：布置题目，确定任务、查找相关资料第二天～第四天：功能分析，编写程序，调试程序、运行系统；第五天上午：撰写设计报告；第五天下午：程序验收、答辩。

四、课程设计考核及评分标准课程设计考核将综合考虑学生的系统设计方案、运行结果、课程设计报告书的质量、态度、考勤、答辩情况等各因素。

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

数据结构课程设计——一元多项式计算一、课程设计题目及要求二、设计思路和方法三、程序流程图四、程序代码及注释五、测试结果及分析六、结论七、参考文献本次课程设计的题目为“一元多项式计算”，要求设计一个程序，能够实现一元多项式的加、减、乘、求导和求值等操作。

在设计思路和方法上，我们采用了链表的数据结构来存储多项式，同时设计了相应的函数来实现各种操作。

程序的流程图如下所示：插入流程图）程序的代码及注释如下所示：插入代码及注释）在测试结果及分析方面，我们对程序进行了多组测试，并对其进行了详细的分析和比较。

结果表明，我们的程序能够正确地实现各种操作，并且具有较高的效率和稳定性。

综上所述，本次课程设计的目标已经得到了圆满地实现，我们对于所取得的成果感到非常满意。

同时，我们也希望能够通过这次课程设计，加深对于数据结构及其应用的理解和掌握，为今后的研究和工作打下坚实的基础。

设计目标：本课程设计旨在结合理论与实际应用，提高学生组织数据及编写大型程序的能力。

通过掌握数据组织、算法设计和算法性能分析的方法，培养学生良好的程序设计能力。

具体实现是利用单链表表示一元多项式，实现多项式的输入、建立、输出、相加、相减和相乘。

总体设计：2.1 数据结构描述与定义：一元多项式定义系数和指数结构如下：coef，expn和next。

定义多项式的结构为线性链表的存储结构，每个结点包含三个元素：系数coef，指数expn和指向下一个结点的指针*next。

多个单项式通过指针连接起来，形成一个多项式。

2.2 模块设计：从实现多项式运算过程的角度来分析，至少需要以下子功能模块：多项式创建、销毁、输出、相加、相减和相乘。

定义并调用的函数有：Insert、CreatePolyn、DestroyPolyn、PrintPolyn、AddPolyn、SubtractPolyn、XXX和main函数。

注：该文章中没有明显的格式错误和需要删除的段落，因此没有进行小幅度改写。

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

《数据结构》课程设计多项式计算班级：学号：姓名：指导老师：多项式计算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开始，一一比较指数大小，直到大于或等于当前指向的数据或遍历完所有数据时停止，然后开始链表中数值的插入，如果相等则直接将指数相加，如果大于就将新数据插入到当前指向的前面，否则将新数据插入到最后。

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

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

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

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

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

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

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

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

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

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

湖南工学院课程设计一元多项式计算班级：信息本1002 学号：09 姓名：班级：信息本1002 学号：26 姓名：班级：信息本1002 学号：34 姓名：班级：信息本1002 学号：41 姓名：目录一、课题任务 (1)二、概要设计 (1)三、详细设计 (2)四、调试分析 (6)五、测试结果 (6)六、课程设计总结 (9)七、参考文献 (9)八、附录 (10)一、课题任务功能： 1）．能够按照指数降序排列建立并输出多项式；2）．能够完成两个多项式的相加，并将结果输出；3）．能根据输入的多项式及变量的值，能进行计算。

并输出计算结果。

4）．能对多个输入的表达式按照指数大小排序输出。

二、概要设计一元多项式计算系统降序排列建立并输出多项式多项式的相加减并输出结果输入的多项式及变量的值计算多个表达式按照指数大小排序输出按指数排序建立多项式相减建立多项式相加计算多项式建立多个多项式输出多式项或计算值排序后输出多个多项式排序三、详细设计一元多项式定义系数和指数结构如下：coef expn nextcoef域--存放结点的系数值expn域--存放结点的指数值next域--存放结点的直接后继的地址（位置）的指针域（链域）一元多项式单链表存储结构：typedef struct term{ float coef; //系数int expn; //指数struct term *next;}term;有了链表特定的数据类型term，接下来就需要建立这个链表。

这里我们自定义一个构造函数CreatePoly（）来构造链表。

首先定义一个term型的指针变量h=p作为头结点，存储多项式的信息（项数），为h分配存储空间建立一个头结点并为其数据域赋值，分配存储空间用malloc()函数来实现；这时输入多项式的项数m，先给p的coef赋值为0，此时利用一个for循环将p链表的coef与expn值从键盘输入，用m来控制循环的次数，若该从键盘输入的coef值不为0，则将该数值插入链表新建链表q，用malloc（）分配给p空间，p=p->next 继续从键盘输入coef与expn的值，直到满足p->next=null,输入完成，返回链表q即为多项式的系数与指数，创建多项式完成。

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

一元多项式的计算数据结构专业课程设计一元多项式的计算—加，减摘要(题目)一元多项式计算任务：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减，并将结果输入；目录一:引言:通过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）功能：将要进行运算的多项式输入输出。

数据结构链式表实现一元多项式加减乘运算课程方案实验报告

数据结构课程设计设计题目：基于链式表实现一元多项式的加减乘运算目录问题分析11.1 问题描述设计一个n元多项式程序，并完成多项式的乘法运算。

从实际的角度出发，这里设计的程序是基于一元n次多项式的数学模型。

1.2 问题的数学模型在数学上，一个一元多项式Pn(x>可按升幂写成：Pn(x>=a 0+a1 x+a2 x^2 +…+a n x^n-1.它由n+1个系数惟一确定，因此，在计算机里，它可用一个线性表P来表示：Pn=(a0,a1,a2,…,an>每一项的指数i隐含在其系数ai的序号里。

多项式的乘法规则：多次运用单项式与多项式相乘的法则得到的．计算时(a+b>(m+n>，先把(m+n>看成一个单项式，(a+b>是一个多项式，运用单项式与多项式相乘的法则，得到(a+b>(m+n>=a(m+n>+b(m+n>,然后再次运用单项式与多项式相乘的法则。

1.3 构造数据结构通过分析多项式的特征，不难看出多项式是由单项式构成的，而每个单项式都具有系数和指数，当系数为0时，该项就失去了意义，在计算机内要表示一个多项式，至少以下数据信息：系数信息、指数信息和指向下一个单项式的指针。

通过指针，我们就可以把多个单项式连接起来，形式一个多项式，需要说明的是从广义的角度讲，单项式也是一个多项式。

基于以上的分析，我们定义多项式的数据结构为如下结构体形式：typedef struct Polynomial{float coef。

//系数int expn。

//指数struct Polynomial *next。

//指向下一个结点}*Polyn,Polynomial。

//Polyn为结点指针类型2 系统分析2.1 可行性研究该程序主要从技术的角度来分析可行性。

技术上的可行性研究主要分析技术条件能否顺利完成开发工作，硬、软件能否满足开发者的需要等。

该系统采用了Windows XP操作系统结合Visual C++ 6.0,TC 2.0等软件开发平台已成熟可行。

数据结构实系数一元多项式运算实验报告

实系数一元多项式问题实验报告2010级计算机科学与技术（非师范）鲁静2011年10月14日星期五1、需求分析实现实系数一元多项式的创建，打印以及两个一元多项式的加、减、乘运算。

（1）程序所能达到的功能：a．实现一元多项式的输入；b．实现一元多项式的输出；c．计算两个一元多项式的和并输出结果；d．计算两个一元多项式的差并输出结果；e．计算两个一元多项式的积并输出结果；（2）输入的形式和输入值的范围：输入要求：分行输入，每行输入一项，先输入多项式的指数，再输入多项式的系数，以0 0为结束标志，结束一个多项式的输入。

输入形式：2 3-1 23 01 20 0-2 1-3 3-1 -10 0输入值的范围：系数为int型，指数为float型。

（3）输出的形式：要求：第一行输出多项式1；第二行输出多项式2；第三行输出多项式1与多项式2相加的结果多项式；第四行输出多项式1与多项式2相减的结果多项式；第五行输出多项式1与多项式2相乘的结果多项式注：多项式的每一项形如：2.0x^3,注意指数应保留一位小数；多项式按照升幂次序排列；系数为1的非零次项应略去系数，系数为0的项不能出现在结果中；指数为0的项应只输出系数；多项式的第一项系数符号为正时，不要输出“+”，其他项要输出“+”，“-”符号。

输出形式：3.0+2.0x^3-x^-1-2.0x-3.0x^3-x^-1+3.0-2.0x-x^3x^-1+3.0+2.0x+5.0x^3-3.0x^-1-6.0x-2.0x^2-9.0x^3-4.0x^4-6.0x^62、概要设计抽象数据类型一元多项式的定义如下：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}基本操作：sort(Polyn & h); //对多项式进行排序print(Polyn h); //输出多项式delZeroCoef(Polyn & h); //判断系数为零的情况merge(Polyn & h); //合并指数相同的项createList(); //创建多项式addPoly(Polyn h1,Polyn h2); //多项式相加subPoly(Polyn h1,Polyn h2); //多项式相减multPoly(Polyn h1,Polyn h2); //多项式相乘} ADT Polynomial多项式的抽象数据类型的定义：typedef struct Polynomial //结点类型{float coef; //系数int exp; //指数struct Polynomial * next;}PolyNode,*Polyn;主程序的流程图：3、详细设计伪码算法：主函数：int main(){Polyn h1=createList();//创建多项式1Polyn h2=createList();//创建多项式2print(h1); //输出多项式1print(h2); //输出多项式2addPoly(h1,h2); //实现多项式1和2的相加，并输出 subPoly(h1,h2); //实现多项式1和2的相减，并输出 multPoly(h1,h2); //实现多项式1和2的相乘，并输出 return 0;}分支函数：void sort(Polyn & h); //排序void print(Polyn h); //输出多项式void delZeroCoef(Polyn & h);//判断处理系数为0的情况void merge(Polyn & h); //合并多项式Polyn createList(); //创建多项式void addPoly(Polyn h1,Polyn h2);//两个多项式相加并输出 void subPoly(Polyn h1,Polyn h2);//两个多项式相减并输出void multPoly(Polyn h1,Polyn h2);//两个多项式相乘并输出函数的调用关系：4、调试分析a．调试过程中遇到的问题是如何解决的以及对设计与实现的回顾讨论和分析:在输入诸如“0,3”，“2,0”时，程序无法正常运行或总是出错.解决：对指数或系数为0的情况应单独讨论。