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

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

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

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

基本算法： 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分别表示二个一元多项式的项数。

课程设计报告--一元多项式计算VS迷宫求解课程设计报告一元多项式计算VS迷宫求解系别：专业年级：学生姓名：学号：任课老师：二○一二年三月一、题目内容描述（一）、实验二一元多项式计算**1、任务：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减、相乘，并将结果输出；2、在上交资料中请写明：存储结构、多项式相加的基本过程的算法（可以使用程序流程图）、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法；（二）、实验四迷宫求解1、任务：可以输入一个任意大小的迷宫数据，用非递归的方法求出一条走出迷宫的路径，并将路径输出；2、要求：在上交资料中请写明：存储结构、基本算法（可以使用程序流程图）、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法。

二、解题分析（一）、一元多项式计算分析：1、一元稀疏多项式简单计算器的功能是：1.1 输入并建立多项式；1.2 输出多项式，输出形式为整数序列：n，c1,e1,c2,e2,………cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列；1.3 求多项式a、b的导函数；1.4 计算多项式在x处的值；1.5多项式a和b相加，建立多项式a+b；1.6 多项式a和b相减，建立多项式a-b。

2、设计思路:2.1 定义线性表的动态分配顺序存储结构；2.2 建立多项式存储结构，定义指针*next2.3利用链表实现队列的构造。

每次输入一项的系数和指数，可以输出构造的一元多项式2.4演示程序以用户和计算机的对话方式执行，即在计算机终站上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运行命令；最后根据相应的输入数据（滤去输入中的非法字符）建立的多项式以及多项式相加的运行结果在屏幕上显示。

多项式显示的格式为：c1x^e1+c2x^e2+…+cnx^en3、设计思路分析：要解决多项式相加，必须要有多项式，所以必须首先建立两个多项式，序数coef 指数expn 指针域next元多项式a和b，a+b的求和运算等同于单链表的插入问题（将单链表polyn p中的结点插入到单链表polyn h中），因此“和多项式”中的结点无须另生成。

一元多项式计算(数据结构课程设计)一、系统设计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.课题分析1.1课题背景及意义《数据结构课程设计》是一门实践性的计算机课程，为了学好这门课程，必须在掌握理论知识的同时，加强上机实践。

通过这次课程设计，要求掌握较大程序的设计方法，相应数据结构的选择应用、算法的设计及其实现和性能分析等方面中加深对课程基本内容的理解。

同时，在设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练。

1.2程序功能本程序的功能是建立按照指数降序排列的两个一元多项式，并能够完成加、减和乘运算，最后将结果按照指数降序排列显示出来。

输入和输出值范围：系数精确到小数点6位，指数以整数表示。

输入形式：系数指数系数指数……0 0 //以0 0作为结束输出形式：fk(x)=系数x^指数+系数x^指数+……+0 x^01.3测试数据：1）加法操作:请输入第一个要操作的多项式：请按多项式指数由高到低输入系数和指数：（以0 0结束）8 64 5-2 4-123 3-1 110 00 0fa(x)=(8.000000x^6)+(4.000000x^5)+(-2.000000x^4)+(-123.000000x^3)+(-1.000000x ^1)+(10.000000x^0)请输入第二个要操作的多项式：请按多项式指数由高到低输入系数和指数：（以0 0结束）2 3-5 21 10 0fb(x)=(2.000000x^3)+(-5.000000x^2)+(1.000000x^1)请选择你要进行的操作:1.多项式相加2.多项式相减3.多项式相乘1fa(x)+f(b)=(8.000000x^6)+(4.000000x^5)+(-2.000000x^4)+(-121.000000x^3)+(-5.000 000x^2)+(10.000000x^0)2）减法操作:请输入第一个要操作的多项式：请按多项式指数由高到低输入系数和指数：（以0 0结束）8 64 5-2 4-123 3-1 110 00 0fa(x)=(8.000000x^6)+(4.000000x^5)+(-2.000000x^4)+(-123.000000x^3)+(-1.000000x ^1)+(10.000000x^0)fa(x)=(3.000000x^3)+(2.000000x^2)请输入第二个要操作的多项式：请按多项式指数由高到低输入系数和指数：（以0 0结束）2 3-5 21 10 0fb(x)=(2.000000x^3)+(-5.000000x^2)+(1.000000x^1)请选择你要进行的操作:1.多项式相加2.多项式相减3.多项式相乘2fa(x)-fb(x)=(8.000000x^6)+(4.00000x^5)+(-2.000000x^4)+(-125.000000x^3)+(-5.0000 00x^2)+(-2.000000x^1)+(10.000000x^0)3）乘法操作:请输入第一个要操作的多项式：请按多项式指数由高到低输入系数和指数：（以0 0结束）8 64 5-2 4-123 3-1 110 00 0fa(x)=(8.000000x^6)+(4.000000x^5)+(-2.000000x^4)+(-123.000000x^3)+(-1.000000x ^1)+(10.000000x^0)fa(x)=(3.000000x^3)+(2.000000x^2)请输入第二个要操作的多项式：请按多项式指数由高到低输入系数和指数：（以0 0结束）2 3-5 21 10 0fb(x)=(2.000000x^3)+(-5.000000x^2)+(1.000000x^1)请选择你要进行的操作:1. 多项式相加2. 多项式相减3. 多项式相乘3fa(x)*fb(x)=(16.000000x^9)+(-32.000000x^8)+(-16.000000x^7)+(-232.000000x^6)+(6 13.000000x^5)+(-125.000000x^4)+(25.000000x^3)+(-51.000000x^2)+(10.000000x^1) 2.概要设计2.1本程序包含的模块typedefstructLinkNode //定义单向链表{}linknode;voidcreatelink(linknode *head){ }；//构建一个以单链表存储的多项式void show(linknode *head){ }；//显示多项式voidaddtion(linknode *fa,linknode *fb,linknode *fc){ }；//加法操作void subtraction(linknode *fa,linknode *fb,linknode *fc){ } ；//减法操作void multiply(linknode *fa,linknode *fb,linknode *fc){ }；//乘法操作voidsortion(linknode *fc){ }；//将乘法所得的结果合并同类项void deletion(linknode *head,linknode *s);{ }；//删除结点操作voidmian(){ }；//主程序2.2问题解决的思路概述首先是确定结构化程序设计的流程图，利用已存在的数据结构来构造一个存储一元多项式的结构，接着把三则运算分成五个主要的模块：实现加法的模块、实现减法的模块、实现乘法的模块、实现合并同类项模块、删除结点模块，然后各个模块里面还要分成若干种情况来考虑并通过函数的嵌套调用来实现其功能。

课程设计报告一元多项式计算订票系统系别专业年级学生姓名学号任课教师二○一二年三月一、题目内容实验二一元多项式计算**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.引言此程序的数据结构是选择用带头结点的单链表存储多项式。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

总体设计：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开始，一一比较指数大小，直到大于或等于当前指向的数据或遍历完所有数据时停止，然后开始链表中数值的插入，如果相等则直接将指数相加，如果大于就将新数据插入到当前指向的前面，否则将新数据插入到最后。

数学与计算机学院课程设计说明书课程名称: 数据结构课程设计课程代码: 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. 一元多项式的除法：详细讲解长除法运算步骤，以及商和余数的概念，通过实际操作和练习，提高学生除法运算能力。

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

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

学号：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++课程设计实验报告（一元多项式加减法）C++程序设计课程设计报告课题: 一元多项式加减法专业班级：学号：姓名：同组者姓名：指导教师：目录一、课程设计的目的意义．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．..2二、程序报告要求．．．．．．．．．．．．．．．．．．．．．．．．．．．．．． 3三、程序流程图 (4)四、运行和调试．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．5五、错误分析 (8)六、课程设计的心得．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．8七、参考书目．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．9八、附录：源代码．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．．101、设计系统的目的意义《数据结构》主要介绍一些最常用的数据结构，阐明各种数据结构内在的逻辑关系，讨论其在计算机中的存储表示，以及在其上进行各种运算时的实现算法，并对算法的效率进行简单的分析和讨论。

数据结构是介于数学、计算机软件和计算机硬件之间的一门计算机专业的核心课程，它是计算机程序设计、数据库、操作系统、编译原理及人工智能等的重要基础，广泛的应用于信息学、系统工程等各种领域。

学习数据结构是为了将实际问题中所涉及的对象在计算机中表示出来并对它们进行处理。

通过课程设计可以提高学生的思维能力，促进学生的综合应用能力和专业素质的提高。

通过此次课程设计主要达到以下目的：了解并掌握数据结构与算法的设计方法，具备初步的独立分析和设计能力；初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能；提高综合运用所学的理论知识和方法独立分析和解决问题的能力；训练用系统的观点和软件开发一般规范进行软件开发，培养软件工作者所应具备的科学的工作方法和作风。

2、程序及报告要求1、能够按照指数降序排列建立并输出多项式；2、能够完成两个多项式的相加、相减，并将结果输入；3、在上交资料中请写明：存储结构、多项式相加的基本过程的算法（可以使用程序流程图）、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法；3、程序流程图程序流程图如下：是4、运行和测试1、系统需求、功能分析：由用户输入两个一元多项式，计算得到它们的和、差并输出。

一元多项式的计算数据结构专业课程设计一元多项式的计算—加，减摘要(题目)一元多项式计算任务：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减，并将结果输入；目录一:引言:通过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++语言，程序采用了链表的存储方法以及结构化和模块化的设计方法，通过调试运行，可以进行多项式的相加、相乘和求导，勉强实现了设计目标，并且经过适当的完善后，将可运用到实际中解决某些问题。

山东理工大学计算机学院课程设计（数据结构）班级计科1102姓名张汝全学号1111051010指导教师肖爱梅2013年1 月7 日课程设计任务书及成绩评定课题名称动态链表结构下的一元多项式的加法、减法和乘法的实现。

Ⅰ、题目的目的和要求：1.巩固和加深对数据结构的理解，通过上机实验、调试程序，加深对课本知识的理解，最终使学生能够熟练应用数据结构的知识写程序。

（1）通过本课程的学习，能熟练掌握几种基本数据结构的基本操作。

（2）能针对给定题目，选择相应的数据结构，分析并设计算法，进而给出问题的正确求解过程并编写代码实现。

2.设计题目要求：1)首先判定一元多项式是否稀疏2)分别采用顺序和链式结构实现；3)结果在M(x)中无重复阶项和无零系数项；4)要求结果以升幂排列输出Ⅱ、设计进度及完成情况Ⅲ、主要参考文献及资料[1] 严蔚敏数据结构（C语言版）清华大学出版社 1999[2] 严蔚敏数据结构题集（C语言版）清华大学出版社 1999[3] 谭浩强 C语言程序设计清华大学出版社[4] 与所用编程环境相配套的C语言或C++相关的资料Ⅳ、成绩评定：设计成绩：（教师填写）指导老师：（签字）二年月日目录第一章概述 (1)第二章系统分析 (2)第三章概要设计 (3)第四章详细设计 (4)第五章运行与测试 (18)第六章总结与心得 (20)参考文献 (21)第一章概述课程设计是实践性教学中的一个重要环节，它以某一课程为基础，可以涉及和课程相关的各个方面，是一门独立于课程之外的特殊课程。

课程设计是让同学们对所学的课程更全面的学习和应用，理解和掌握课程的相关知识。

《数据结构》是一门重要的专业基础课，是计算机理论和应用的核心基础课程。

数据结构课程设计，要求学生在数据结构的逻辑特性和物理表示、数据结构的选择和应用、算法的设计及其实现等方面，加深对课程基本内容的理解。

同时，在程序设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练。