一元多项式计算(数据结构课程设计)
数据结构课程设计-一元多项式的加法、减法、乘法的实现
数据结构课程设计-一元多项式的加法、减法、乘法的实现一、设计题目一元多项式的加法、减法、乘法的实现。
二、主要内容设有一元多项式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等数学软件对一元多项式的计算过程，步骤后。
一元多项式数据结构课程设计报告
一元多项式计算摘要一元多项式计算是用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项的系数和指数，序列按指数的降序序列排列；其三，多项式排序，多项式按指数的降序序列排列；其四，多项式相加，指数相同系数相加，指数不同则把此项加进去；其五，多项式相减，指数相同系数相加，指数不同则把此项取反再加进去；其六，返回多项式的项数。
数据结构课程设计,一元多项式
数据结构课程设计,一元多项式(共15页)-本页仅作为预览文档封面，使用时请删除本页-湖南工学院课程设计一元多项式计算班级：信息本1002学号： 09姓名：班级：信息本1002学号：26姓名：班级：信息本1002学号：34姓名：班级：信息本1002学号：41姓名：目录一、课题任务 .................................................................................... 错误!未定义书签。
二、概要设计 ................................................................................... 错误!未定义书签。
三、详细设计 ................................................................................... 错误!未定义书签。
四、调试分析 ................................................................................... 错误!未定义书签。
五、测试结果 ................................................................................... 错误!未定义书签。
六、课程设计总结............................................................................ 错误!未定义书签。
七、参考文献 ................................................................................... 错误!未定义书签。
数据结构课程设计之一元多项式加减乘
##大学数据结构课程设计报告题目：顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现院（系）：计算机工程学院学生姓名:班级：学号:起迄日期: 2011.06.20-06.30指导教师:2010—2011年度第 2 学期一、需求分析1、顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现。
可以分为几个模块：输入模块、输出模块（升幂降幂）、数据处理模块（多项式的加减乘）、主程序模块。
2、在程序过程中加入汉字提示符，让读者清楚明白的操作该程序。
运行程序时看起来简洁有序，操作简单明了3、程序执行时的命令：①选择创建两个一元多项式②输入第一个一元多项式的项数③依次输入一元多项式的系数和指数④以相同方式输入第二个一元多项式⑤选择操作方式⑥选择降幂或升幂排序⑦输出结果⑧是否退出。
4、测试数据。
输入的一元多项式系数指数分别为7 0,3 1,9 8,5 17和8 1,22 7，-9 8。
加法结果为；升幂降幂减法结果为：升幂降幂乘法结果为：升幂降幂二、概要设计1、设计思路：在该程序中分别分为顺序存储和链式存储结构。
2、数据结构设计：一元多项式抽象数据类型的定义：ADT Polynomial{数据对象：D={ai|ai∈TermSet,i=1,2…,m,m>=0TermSet中的每一个元素包含一个表示系数的实数和表示指数的整数}数据关系:R1={<ai-1,ai>|ai-1,ai∈D, 且ai-1中的指数值<ai中的指数值，i=2,…,n} 基本操作：CreatPolyn(&P,m)操作结果：输入m项的系数和指数，建立一元多项式P.DesteoyPolyn(&P)初始条件：一元多项式P已存在。
操作结果：销毁一元多项式P。
PrintfPolyn(P)初始条件：一元多项式P已存在。
操作结果：打印输出一元多项式P。
PolynLength(P)初始条件：一元多项式P已存在。
数据结构课程设计(一元多项式)
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.1设计题目与要求1.1.1设计题目1）一元多项式计算任务：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减，并将结果输入；基本要求：在上交资料中请写明：存储结构、多项式相加的基本过程的算法（可以使用程序流程图）、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法；本程序关键点是如何将输入的两个多项式相加、相减操作。
①如何将输入的一元多项式按指数的降序排列②如何确定要输入的多项式的项数；③如何将输入的两个一元多项式显示出来。
④如何将输入的两个一元多项式进行相加操作。
⑤如何将输入的两个一元多项式进行相减操作。
本程序是通过链表实现一元多项式的相加减操作。
1.1.2、任务定义此程序需要完成如下的要求：将多项式按照指数降序排列建立并输出，将两个一元多项式进行相加、相减操作，并将结果输入。
a：输入多项式的项数并建立多项式；b：输出多项式，输出形式分别为浮点和整数序列，序列按指数升序排列；c：多项式a和b相加，建立多项式a+b；d：多项式a和b相减，建立多项式a-b。
e：多项式的输出。
1.2 数据结构的选择和概要设计：1.2.1数据结构的选用A:基于链表中的节点可以动态生成的特点，以及链表可以灵活的添加或删除节点的数据结构，为了实现任意多项式的加法，减法，因此选择单链表的结构体，它有一个系数，指数，下一个指针3个元属；例如，图1中的两个线性链表分别表示一元多项式和一元多项式。
从图中可见，每个结点表示多项式中的一项。
图1 多项式表的单链存储结构B：本设计使用了以下数据结构：typedef struct node{int xs; /*系数*/int zs; /*指数*/struct node * next; /*next指针*/}Dnode,* Dnodelist;C：设计本程序需用到八个模块，用到以下八个子函数如下：1.Dnodelist Creat_node(void) /*链表初始化*/2.int Insert_node(Dnodelist D,int xs,int zs) /*插入函数*/3.Dnodelist Creat_Dmeth(int length) /*创建多项式*/4.Dnodelist Addresult(Dnodelist D1,Dnodelist D2) /*多项式相加*/5.Dnodelist Subresult(Dnodelist D1,Dnodelist D2) /*多项式相减*/6.Dnodelist select(Dnodelist D1,Dnodelist D2) /*选择函数*/7void Show(Dnodelist D) /*显示（输出）函数*/8void main()主程序模块调用链一元多项式的各种基本操作模块。
数据结构课程设计——一元多项式计算
数据结构课程设计——一元多项式计算一、课程设计题目及要求二、设计思路和方法三、程序流程图四、程序代码及注释五、测试结果及分析六、结论七、参考文献本次课程设计的题目为“一元多项式计算”，要求设计一个程序，能够实现一元多项式的加、减、乘、求导和求值等操作。
在设计思路和方法上，我们采用了链表的数据结构来存储多项式，同时设计了相应的函数来实现各种操作。
程序的流程图如下所示：插入流程图）程序的代码及注释如下所示：插入代码及注释）在测试结果及分析方面，我们对程序进行了多组测试，并对其进行了详细的分析和比较。
结果表明，我们的程序能够正确地实现各种操作，并且具有较高的效率和稳定性。
综上所述，本次课程设计的目标已经得到了圆满地实现，我们对于所取得的成果感到非常满意。
同时，我们也希望能够通过这次课程设计，加深对于数据结构及其应用的理解和掌握，为今后的研究和工作打下坚实的基础。
设计目标：本课程设计旨在结合理论与实际应用，提高学生组织数据及编写大型程序的能力。
通过掌握数据组织、算法设计和算法性能分析的方法，培养学生良好的程序设计能力。
具体实现是利用单链表表示一元多项式，实现多项式的输入、建立、输出、相加、相减和相乘。
总体设计：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开始，一一比较指数大小，直到大于或等于当前指向的数据或遍历完所有数据时停止，然后开始链表中数值的插入，如果相等则直接将指数相加，如果大于就将新数据插入到当前指向的前面，否则将新数据插入到最后。
一元多项式计算课程设计
一元多项式计算课程设计一、课程目标知识目标：1. 理解一元多项式的概念，掌握其标准形式和各项系数的含义。
2. 学会使用合适的方法进行一元多项式的加、减、乘运算，并能够准确写出结果。
3. 掌握一元多项式的除法法则，能对给定的一元多项式进行长除法运算。
技能目标：1. 能够运用所学知识解决实际问题中涉及一元多项式的计算问题。
2. 培养学生运用代数运算解决复杂问题的能力，提高逻辑思维和运算准确性。
3. 通过一元多项式的运算，提升学生的数学表达和推理能力。
情感态度价值观目标：1. 培养学生对数学学习的兴趣，激发学生主动探索一元多项式运算规律的积极性。
2. 培养学生团队合作意识，通过小组讨论与合作，共同解决一元多项式运算中的问题。
3. 引导学生认识到数学知识在实际生活中的应用，体会数学学习的实用价值。
课程性质：本课程为初中数学课程，旨在帮助学生掌握一元多项式的运算方法，提高数学思维和解决问题的能力。
学生特点：初中年级的学生已经具备一定的代数基础，但运算技巧和逻辑思维能力有待提高。
教学要求：注重理论与实践相结合，通过具体例题和练习，使学生熟练掌握一元多项式的计算方法，并能应用于实际问题。
在教学过程中，关注学生的个体差异，提供个性化指导，确保每个学生都能达到课程目标。
二、教学内容本课程依据课程目标，结合教材内容，组织以下教学重点：1. 一元多项式的定义与表示：介绍一元多项式的概念，包括常数项、一次项、二次项等，并学习其标准形式。
2. 一元多项式的加减法：讲解同类项合并原则，通过实例演示和练习，使学生掌握一元多项式的加减运算。
3. 一元多项式的乘法：教授多项式乘法法则，运用分配律进行展开，并通过典型例题强化学生乘法运算技巧。
4. 一元多项式的除法：详细讲解长除法运算步骤，以及商和余数的概念，通过实际操作和练习，提高学生除法运算能力。
教学内容安排如下：第一课时：一元多项式的定义与表示，同类项的合并。
第二课时：一元多项式的加法和减法运算。
数据结构课程设计-一元多项式的四则运算
一元多项式的四则运算学生姓名：指导老师：摘要本课程设计主要解决一元多项式的运算问题，通过链表的使用，实现对一元多项式的构建、录入、存储、打印、以及之间的运算。
在本课程设计中，程序设计语言为C++语言，程序运行平台为Windows/98/2000/XP，程序采用了链表存储方法以及结构化和模块化的设计方法，通过调试运行，可以进行多项式的加、减、乘运算，勉强实现了设计目标，并且经过适当完善后，将可应用到实际中解决某些问题。
关键词程序设计； C++ ；一元多项式；运算1 引言一般来说，我们只知道数学上的一元多项式的运算，这一般都是用笔来进行运算的，然而此课程设计将一元多项式的运算用电脑来进行，只需要将多项式输入，然后就可以出结果，速度快，省去了认为计算的环节，在现实中带来不少方便。
1.1 课题背景一元多项式的运算，虽然无法直接在除数学外的其他领域作出贡献，但是在数学上，它可以为人们解决一些自己动笔动手很难解决的问题，比如说那些很长很长的多项式，用笔算可能要算半天，但是用该程序，只需短短的几秒钟，所以它给人们带来了不少方便，同时相信它也能间接地为其他领域做出贡献。
1.2 课程设计目的个人觉得，该数据结构课程设计一方面可以让自己更加熟悉那些些常用的数据结构，掌握数据结构内在的逻辑关系，以及它们在计算机中的存储表示，和对它们实行的各种运算；另一方面，可以让自己对于整体和局部，以及结构化和模块化编程有一个更深层次的了解。
作为网络工程的学生，虽然之前有过一次Ｃ语言课程设计，但是深知自己编程能力尚为欠缺，所以这一次数据结构课程设计是对我的编程能力和组织能力的又一次考验。
1.3课程设计内容本课程设计是用链表实现一元多项式的存储及运算，其中包括多项式系数及指数的录入（即一元多项式的录入），以及储存、一元多项式的显示、一元多项式之间的加、减、乘法运算。
2 设计思路与方案2.1设计思路该系统使用Ｃ++语言进行开发和实现，程序中的各个功能分别由不同的的函数实现，然后在main函数中调用实现。
一元多项式的计算,数据结构程序设计图形界面
一元多项式的计算,数据结构程序设计图形界面
对于一元多项式的计算,可以使用链表来存储每一项的系数和指数,然后进行加减乘除等运算。
具体实现的步骤如下：
1. 定义一个多项式节点的结构体,包含两个成员：系数和指数。
2. 定义一个链表结构体,包含两个成员：头节点和尾节点。
3. 实现链表的初始化函数、插入节点函数、删除节点函数、遍历链表函数等基本操作。
4. 实现多项式加法、减法、乘法、除法等运算函数。
对于加减法,可以遍历两个链表,依次将相同指数的项相加或相减；对于乘法,可以使用两个for循环遍历两个链表,将每一项相乘并按照指数相加；对于除法,可以使用辗转相除法,将被除数一部分一部分地减去除数,直到余数小于除数为止,每一部分的商可视为一项。
对于数据结构程序设计图形界面,可以使用Qt等UI框架来实现。
可以使用布局管理器来设计UI界面,使用信号与槽机制来处理用户的操作输入,将用户输入的参数传递给多项式计算函数,最终将计算结果显示在UI界面上。
数据结构课程设计—一元多项式加法、减法、乘法运算的实现
1、一元多项式加法、减法、乘法运算得实现１、1设计内容及要求1)设计内容（1）使用顺序存储结构实现多项式加、减、乘运算。
例如：，求与结果：(2）使用链式存储结构实现多项式加、减、乘运算,，求与结果：2)设计要求（1)用C语言编程实现上述实验内容中得结构定义与算法。
（2）要有main（）函数,并且在ｍain(）函数中使用检测数据调用上述算法。
(3）用sｗitch语句设计如下选择式菜单。
＊**＊*＊*＊*＊**＊*＊数据结构综合性实验*＊＊**＊*＊＊＊*＊＊＊＊＊**＊＊*＊＊一、多项式得加法、减法、乘法运算*＊*＊***＊＊＊＊*＊＊＊＊＊ 1、多项式创建 *＊*＊*＊＊＊**＊*＊＊＊*＊2、多项式相加＊*＊＊＊****＊*＊＊＊**＊ 3、多项式相减＊**＊＊**＊*＊***＊＊＊＊４、多项式相乘＊*＊*＊＊*＊＊＊＊＊＊*＊＊* 5、清空多项式*＊＊＊＊＊**＊＊＊**＊＊＊＊０、退出系统 *＊＊＊＊*＊＊＊*＊＊＊＊＊** 请选择(０—5） *＊*＊***＊*＊＊＊＊**＊＊＊*＊＊＊*******＊＊*＊＊＊＊*＊*＊*＊*＊＊＊**＊*＊*＊*＊＊＊＊＊*请选择（０—5）:1、2数据结构设计根据下面给出得存储结构定义：#defiｎe ＭＡXSIZE 20 //定义线性表最大容量//定义多项式项数据类型ｔｙpｅdｅｆ stｒｕｃt｛ﻩfloaｔｃｏef; /／系数iｎt ｅxpn； //指数}teｒｍ，elｅmType;ｔｙｐedｅf sｔrｕｃt{ﻩterm ｔｅrｍs[MＡXSIZE]； //线性表中数组元素ｉｎt ｌast; //指向线性表中最后一个元素位置｝SeｑＬｉst;tyｐedef ＳeqLiｓt poｌynomｉal;１、3基本操作函数说明poｌynoｍial＊Init_Ｐｏlynomial()；/／初始化空得多项式int PｌｏｙｎSｔａtuｓ(polyｎomｉａl*p)//判断多项式得状态ｉnt Ｌocａtion＿Eｌeｍent（polynoｍial*p，terｍ x）在多项式p中查找与x项指数相同得项就是否存在ｉｎt Iｎserｔ_EｌemeｎｔBｙＯrder（polｙnomial*p,term ｘ)//在多项式ｐ中插入一个指数项xｉnt CｒeａtｅPolyn(polyｎomial＊Ｐ，iｎt m)//输入m项系数与指数，建立表示一元多项式得有序表pchａｒｐａre（term term1，teｒｍterm2)／/比较指数项tｅrm1与指数项ｔｅrm２poｌｙｎomｉａl＊ａdｄPｌｏyn（polｙnomiaｌ＊p1,ｐolynｏmiａl＊p2) ／/将多项式p１与多项式p２相加，生成一个新得多项式polynomial＊sｕbStｒacｔPloｙn（polｙnomiaｌ*p１，polｙnomial*ｐ２）/／多项式p1与多项式p２相减,生成一个新得多项式polynoｍiaｌ＊ｍulitPloyｎ(pｏｌｙnomｉal＊ｐ1，poｌynomiａl*ｐ2) ／／多项式p１与多项式p２相乘，生成一个新得多项式ｖoid prinｔPloｙn(polynｏmiaｌ＊p）／/输出在顺序存储结构得多项式p１、４程序源代码＃incluｄe〈stdlｉb、h>#inclｕdｅ〈stｄio、h＞#include〈iｏstreaｍ、h〉＃dｅfine NＵLL 0#ｄeｆine ＭAXSＩZＥ 20tyｐｅdef struct{ﻩfloat coef；ﻩｉnt expn；｝tｅrm，elemＴype;ｔypedef sｔrucｔ｛ﻩｔerm ｔerms[MAＸSIＺE];ﻩint lａst;｝SeｑＬiｓt；typｅdeｆ SｅqLｉst polynｏmiaｌ；ｖｏiｄｐｒiｎtPlｏｙｎ（polyｎoｍial*p)；iｎt PloyｎStatus(pｏlynｏｍiａl*p)｛if(p==ＮULL）ﻩ{retｕrn －1;｝ﻩelｓｅｉf（ｐ—>ｌaｓt=＝—1)｛ﻩｒetuｒn ０；ﻩ｝ｅｌseﻩ{ﻩrｅturｎ 1;ﻩ｝｝poｌynomial*Inｉt_Polyｎｏmial（）{ｐｏlynomiａl*Ｐ;ﻩP=new polｙnomial;ﻩif（P！=NULL）ﻩ｛P－＞last＝-1；ﻩﻩreｔurn P;ﻩ｝ﻩelse{ﻩﻩreturｎ NUＬL；ﻩ}}void Reｓet_Pｏlｙnomiaｌ（pｏｌynｏmial*ｐ){if(ＰlｏynStatｕs(p）＝=1）｛p-〉lａsｔ=－1;}｝ｉｎt Ｌocation_Elemeｎt（polｙnoｍial＊p，tｅrｍ x）{ﻩiｎt i=0；ｉf（PloyｎStａtｕs（ｐ)==—1)ﻩﻩreｔuｒn 0；ｗhilｅ(i〈＝ｐ->lasｔ＆＆ p—>tｅｒmｓ[ｉ］、expｎ!＝x、ｅxpn）｛i+＋；ﻩ}if（i〉ｐ—>last）｛ﻩﻩretuｒn 0;}elseﻩ｛retuｒｎ 1；ﻩ}｝int Insｅrｔ＿ElemenｔＢyＯrdｅr(polｙnomial＊p，term x）{ﻩint ｊ；ﻩiｆ(PｌoynＳtatｕｓ（p)==－１）return ０;ﻩif(p—＞last==MAXSIZE—１）{ﻩcoｕt＜<"Ｔhｅ polyｍ is ｆull!"〈＜ｅｎdｌ；ﻩｒeｔuｒn ０;｝ﻩj＝p—〉last;wｈｉlｅ(ｐ—＞ｔermｓ［j]、eｘpｎ<x、ｅxｐn && ｊ＞=0) {ﻩ p-〉tｅrms［j＋1］=ｐ->tｅrms[j];ﻩ j-—；｝p->tｅｒmｓ［j+1]=x；ｐ—〉ｌａst++；ﻩreturn 1；｝iｎｔ CｒeａｔePolyn(polｙnomiaｌ*Ｐ，int ｍ）｛float coeｆ;ｉnt exｐn；ｔerm x；if（PlｏyｎStatｕs（P）==－1）ﻩreturn ０；ﻩｉf(m＞MAXSIZＥ）{printf(”顺序表溢出\n"）；ﻩｒetuｒｎ0;｝elsｅ｛ﻩprｉntf（”请依次输入%ｄ对系数与指数、、、\ｎ＂，m）；ﻩfｏr(int i=０；ｉ<m；i++)ﻩﻩ{ﻩscanf(”％f％ｄ",＆ｃoef,&exｐn）;ﻩx、coｅf＝coｅf;ｘ、ｅxpn＝expｎ;ﻩﻩif（！Loｃaｔion＿Elemｅnt(P,ｘ）)｛ﻩﻩﻩIｎｓert＿ＥlｅmentBｙＯrder(Ｐ，x)；}ﻩﻩ}｝ｒeｔuｒn 1;｝chaｒ pａre（tｅｒm tｅrm１,terｍ tｅｒｍ2){iｆ（tｅrｍ１、expn〉ｔerm２、expn）｛ﻩｒeｔuｒn’＞＇；ﻩ}else iｆ(ｔerｍ1、expn〈teｒm2、expn）ﻩ｛retｕrｎ’＜';｝ﻩｅlseﻩ{ﻩreturn＇=’；ﻩ｝｝polｙｎomｉａl*aｄdPｌoｙｎ(ｐolynomｉal*ｐ1，polynomiaｌ＊p2）{ｉｎｔ i，ｊ,ｋ；ﻩi＝０;ﻩｊ=０；k=０；if(（PｌoynStａｔus(p1）==-１）｜|（PｌoyｎStatｕs(p2）==-1)) ﻩ｛ﻩﻩreturｎ NＵＬL；｝ﻩpolynｏｍiａl＊p3＝Iniｔ_Poｌｙnoｍiaｌ()；ｗhｉle（i＜=p１—>ｌast ＆＆ j＜=p2—＞last){ｓwｉtｃh(pａre(p１-＞terms[ｉ］,ｐ２->ｔerｍs［j］））ﻩﻩ{ﻩﻩcase'>’:ﻩﻩp3—〉termｓ［k++］＝p1-＞tｅｒｍs［i++］;ﻩp3—＞last+＋;ﻩﻩﻩﻩｂreak;ﻩcase'〈’:ﻩﻩﻩﻩｐ3－>terms［ｋ＋+]=p2—>ｔeｒｍs［ｊ＋+］;ﻩﻩp3－>laｓt+＋;ﻩbｒeak；ﻩcａse'='：ﻩﻩｉｆ（ｐ1－〉terｍs［i]、coｅf+p２-〉teｒｍｓ[j］、coef！＝0) ﻩﻩﻩ｛ﻩﻩp３->teｒｍｓ［ｋ］、coef=ｐ1->teｒms［i]、cｏef＋p２—〉ｔerm ｓ［ｊ]、cｏef；ﻩﻩp3－>teｒms[k]、expｎ＝p1-＞ｔerms［i]、ｅxpn;ﻩﻩﻩｋ＋+；ﻩp3—＞lａsｔ+＋;ﻩ｝ﻩﻩﻩi＋+；ﻩﻩﻩj++;｝ﻩ｝ﻩwhile(i〈=p１—〉last）{ﻩﻩp3－>tｅｒms［k+＋］=p1－〉ｔermｓ［ｉ++]；ﻩｐ3－〉lasｔ++;｝retｕrn p3;｝ｐolyｎｏmiａl＊sｕbＳtrａctPlｏｙｎ（polynoｍiａl＊p1，ｐoｌynomial*p2）{ﻩint i;i=０;ﻩiｆ（(PloynＳtaｔuｓ（p１）!=1)｜｜(PloynStatｕs（p2)!＝1))ﻩ{ﻩreｔurn ＮULL;}polynｏmial＊ｐ３＝Iｎit＿Polynoｍiaｌ（）;ﻩp3－〉ｌast=ｐ2—>last;fｏr(i=0；i〈=p2—>ｌａｓｔ;i++){ﻩﻩp3—>terms［i]、coef=—ｐ2－＞termｓ［i]、coeｆ;ﻩﻩp３—＞terｍs[i］、expn=ｐ2-〉terｍs［ｉ］、expn；｝ﻩp3=addＰloｙｎ（p1，p３);retｕrn ｐ3;｝ｐolynoｍial＊ｍulitPｌoｙｎ（ｐolynｏｍial＊p１，poｌynｏmｉal*p２) {ﻩint i;inｔ j;int k；ﻩi＝0;if((PloynＳtａtus(p1）!=1)｜|(PｌoynStaｔｕs(p２)!=1）)ﻩ｛ﻩretuｒn NULL;ﻩ｝polynoｍｉal*p3=Iｎiｔ_Polｙnomiaｌ(）；polyｎomiaｌ*＊p=new polyｎoｍiａｌ＊［p2－〉lasｔ+1］;ﻩfor(i=0;i〈=p2－＞ｌａsｔ；i＋+){ﻩfor(k＝0；k＜=p2-〉last;k++）{ﻩﻩp[k］=Ｉnit_Polｙnｏmiaｌ（)；ﻩﻩp[k］－＞ｌast＝ｐ１—>lａst；ﻩﻩfｏr（ｊ=0；j〈=ｐ１-＞ｌasｔ；ｊ++）ﻩ｛p［k］—>teｒms［j］、coeｆ=p１－>tｅrms［j]、coef＊ｐ２—>terｍs［k]、coef；ﻩp[k］-〉ｔｅｒｍs[j］、eｘpn=p1—>terms［j]、ｅｘｐn＋p2-〉terms[k］、expn;ﻩ}p３=addPloyn(p3，ｐ[ｋ]）；ﻩ｝ﻩ}ﻩｒeturn p3；｝void priｎtPloｙn(ｐolｙnｏmiａl＊p){ｉnt ｉ；fｏr（i=0;i〈＝p－>lａｓt；i++）ﻩ｛ﻩｉf(ｐ-＞terms[i]、ｃoeｆ〉0 ＆＆i＞０）ﻩcｏut＜<"+"＜<ｐ—＞terｍs[i]、coef;elsｅﻩﻩﻩcout＜〈ｐ—>ｔerms［i］、coef；ﻩcｏｕｔ＜＜＂x^"〈<p—＞tｅrms［i]、expn;ﻩ}ﻩcoｕt〈＜eｎdｌ；｝voｉｄ mｅnu（）｛ﻩｃoｕt〈〈”\t\t＊**＊*＊*数据结构综合性实验＊*＊＊＊＊＊＊*＂＜〈ｅndl；ｃout<<”\ｔ＼t*＊*一、多项式得加、减、乘法运算**＊”<<enｄｌ；ﻩcoｕt〈＜＂\t\t＊*＊*＊＊＊１、多项式创建 ****＊＊＊＊*”<〈eｎdl；ﻩcoｕt<〈＂\t\ｔ*＊＊＊*＊* 2、多项式相加 *＊**＊＊*＊＊”<＜e ｎdｌ;ｃouｔ<〈”\t＼t＊＊*＊＊＊* 3、多项式相减**＊*＊**＊*＂<<endl;cｏｕt＜<”\t\t*＊***＊* 4、多项式相乘＊＊*＊＊*＊*＊”<〈en ｄｌ;cout＜<"\t\t**＊**＊* 5、清空多项式 ***＊＊＊*＊*"〈〈endl；ｃout<〈"\t\t**＊＊**＊ 0、退出系统 *＊*＊＊＊＊＊*＂＜<endl；couｔ＜＜”\t\t＊**＊*＊请选择(０—5）*＊******"〈<e ｎdｌ;cout＜〈"\t\t*＊＊＊＊**＊*＊＊＊**＊＊**＊**＊＊*＊******＊＊＊*"〈＜endl；｝void ｍain（）｛ｉnt sｅl；ﻩpｏlynomiａl*p１=NULL；pｏｌynomial＊p2=NULL；ﻩpolｙｎｏｍiａl＊p3=NULL；ｗｈilｅ(１）｛ﻩﻩｍenｕ（);ﻩcout〈<”\t＼t*请选择(0-5)：”；ｃiｎ〉＞seｌ；sｗｉｔｃh（ｓel)ﻩ｛caｓe 1：ﻩﻩｐ1=Ｉｎit＿Poｌynomｉａl();ﻩﻩp2=Iｎit_Ｐolynomｉal（）；iｎｔ m;pｒiｎtf（"请输入第一个多项式得项数:\n"）；ﻩscanf（＂％d”,＆m）;ﻩﻩCreatePoｌyｎ（p1,m)；priｎｔf(＂第一个多项式得表达式为p1=”);ﻩﻩpｒｉｎtＰｌoyn（ｐ1）;ｐrintｆ（＂请输入第二个多项式得项数:\n＂)；ﻩﻩscaｎf（＂%ｄ＂,&m）;ﻩＣrｅatePoｌｙn(p2，m）;priｎtf（＂第二个多项式得表达式为p２="）；pｒinｔPloyn(ｐ2);ﻩﻩｂreak;ﻩｃaｓe ２：ﻩﻩpｒｉｎｔｆ(”p1+p2=＂)；if(（p3＝suｂStractＰｌoｙn（p1,p2)）！=NULL) ﻩﻩﻩｐrｉntPloyn(p3)；ﻩﻩbreak；ｃase 3:ﻩprintf（”\ｎp1—ｐ２＝”）;ﻩﻩif(（p3=ｓｕbStraｃtＰloyn（p1，p２）)!＝NULL)ﻩﻩprinｔPloyn（ｐ3）;ﻩﻩbreak；ﻩﻩcａｓｅ 4：ﻩprｉｎtf("＼ｎp1＊ｐ2=")；ﻩif((p3＝muliｔPlｏyn(p１，p2)）!＝NULL) ﻩﻩｐrｉntPｌoyn（ｐ3）;ﻩｃase ５：Rｅsｅｔ＿Pｏlynｏｍial（ｐ1）；Reseｔ_Polｙnｏmiａl（p2)；Resｅｔ_Ｐoｌｙnomial（p3）；ﻩﻩﻩｂreａk；ﻩcａse 0:return；ﻩﻩ｝ﻩ｝ﻩｒetuｒn;}1、5程序执行结果2、迷宫问题实现２、1设计内容及要求1)设计内容以一个m＊ｎ得长方阵表示迷宫,０与１分别表示迷宫中得通路与障碍。
一元多项式的计算数据结构专业课程设计
一元多项式的计算数据结构专业课程设计一元多项式的计算—加，减摘要(题目)一元多项式计算任务：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减，并将结果输入；目录一:引言:通过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）功能：将要进行运算的多项式输入输出。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一元多项式计算(数据结构课程设计)一、系统设计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环境中调试运行。