一元稀疏多项式计算器(数据结构)
数据结构实习报告——一元稀疏多项式运算器的设计

数据结构实习报告——一元稀疏多项式运算器的设计一、引言在计算机科学领域中,数据结构是研究数据组织、存储和管理的关键概念之一。
在本次实习中,我设计并实现了一个一元稀疏多项式运算器,旨在使用适当的数据结构和算法来高效地进行多项式的加法、减法和乘法运算。
本报告将详细介绍该运算器的设计思路、算法实现以及性能评估。
二、设计思路1. 多项式的表示在设计多项式运算器时,首先需要确定多项式的表示方法。
为了高效地处理稀疏多项式,我选择使用链表作为基本数据结构。
每个节点包含多项式的系数和指数,并通过指针连接在一起形成链表。
这种表示方法可以有效地处理稀疏多项式,减少了不必要的空间浪费。
2. 多项式的输入和输出为了方便用户输入和输出多项式,我设计了简单的交互界面。
用户可以通过命令行输入多项式的系数和指数,并选择进行的运算操作。
运算结果将直接在命令行中输出。
三、算法实现1. 多项式的加法多项式的加法是指将两个多项式相加得到一个新的多项式。
为了实现这个功能,我设计了一个算法如下:- 创建两个空的链表,分别表示两个多项式。
- 逐个读取用户输入的系数和指数,并将其插入到相应的链表中。
- 对两个链表进行遍历,根据指数的大小关系进行合并操作。
- 将合并后的结果链表输出。
2. 多项式的减法多项式的减法是指将一个多项式减去另一个多项式得到一个新的多项式。
为了实现这个功能,我设计了一个算法如下:- 创建两个空的链表,分别表示两个多项式。
- 逐个读取用户输入的系数和指数,并将其插入到相应的链表中。
- 对第二个链表中的每个节点的系数取相反数。
- 对两个链表进行遍历,根据指数的大小关系进行合并操作。
- 将合并后的结果链表输出。
3. 多项式的乘法多项式的乘法是指将两个多项式相乘得到一个新的多项式。
为了实现这个功能,我设计了一个算法如下:- 创建一个空的链表,表示乘法结果。
- 逐个读取用户输入的系数和指数,并将其插入到链表中。
- 对第一个链表中的每个节点,与第二个链表中的每个节点进行乘法运算,并将结果插入到结果链表中。
一元稀疏多项式计算器数据结构

一元稀疏多项式计算器数据结构一元稀疏多项式计算器是一种用于计算多项式的工具,该工具可以用于代数计算、数学分析以及计算机科学中的算法设计。
它可以通过一种特殊的数据结构来存储多项式,并可以对其进行加法、减法、乘法、除法等运算。
这种数据结构被称为稀疏多项式,它是一种基于链表的数据结构。
在稀疏多项式中,每个节点表示一个单项式,节点的数据包含该单项式的系数和指数。
在一个稀疏多项式中,只有少数几个节点表示一个多项式,这就是稀疏性的来源。
稀疏多项式的加法和减法非常简单,只需要对两个多项式的对应节点进行加减即可。
而稀疏多项式的乘法需要更复杂的算法。
乘法的过程中需要将两个多项式的每个单项式乘起来,并将同类项合并成一个新的多项式。
这个过程涉及到大量的链表操作,但只要注意一些细节,将会得到正确的结果。
除了基本的加法、减法、乘法运算,一元稀疏多项式计算器还有一个非常重要的运算,那就是求导。
求导是一种将多项式每个单项式的指数减一,并将系数乘以指数的运算。
它常用于解决微积分、概率论等问题。
求导操作可以通过修改节点的指数和系数来实现。
在计算机科学中,稀疏多项式可以用于设计高效的算法,例如在数论、密码学、图像处理、计算器表达式求值等方面。
稀疏多项式的优点在于它可以有效地节省存储空间和计算时间。
通过动态链表的形式,可以轻松地添加、删除节点,使得稀疏多项式非常适合用于处理大规模的数据。
总的来说,一元稀疏多项式计算器是一种非常实用的工具。
它可以用于解决多项式运算问题,并可以为计算机科学方面的算法设计提供很大的帮助。
通过了解这种数据结构,我们可以更深入地理解代数学、微积分学等数学原理,并且能够更好地应用于实际问题中。
数据结构实习报告——一元稀疏多项式运算器的设计

数据结构实习报告——一元稀疏多项式运算器的设计一、引言在计算机科学领域中,数据结构是构建各种算法和程序的基础。
本次实习项目旨在设计一个一元稀疏多项式运算器,通过合理的数据结构和算法实现多项式的加法、减法和乘法运算,以及求导和求值等功能。
本文将详细介绍该运算器的设计思路、数据结构选择、算法实现和性能优化等方面。
二、设计思路为了实现一元稀疏多项式的运算,我们需要选择合适的数据结构来存储和操作多项式的系数和指数。
考虑到多项式中只有少数系数非零,我们可以使用链表来表示多项式,每个节点存储一个非零系数和对应的指数。
这样可以节省空间,并且方便插入和删除操作。
三、数据结构选择在设计中,我们选择了一个单向链表作为多项式的数据结构。
链表节点的定义如下:```struct Node {int coefficient; // 系数int exponent; // 指数Node* next; // 下一个节点指针};```链表的头节点指针指向第一个非零项,便于遍历和操作。
四、算法实现1. 多项式的输入用户可以通过标准输入方式输入多项式的系数和指数,我们通过读取用户输入的系数和指数,并根据其大小构建链表。
2. 多项式的加法和减法运算多项式的加法和减法运算可以通过遍历两个多项式的链表,并根据指数的大小进行合并操作。
具体的实现可以使用双指针的方式,分别指向两个链表的当前节点,比较指数的大小,然后将较小的节点插入到结果链表中,并将指针向后移动。
3. 多项式的乘法运算多项式的乘法运算可以通过遍历两个多项式的链表,并将每一项相乘得到新的项,然后将新的项插入到结果链表中。
具体的实现中,可以使用一个嵌套的循环,先遍历一个多项式的链表,再遍历另一个多项式的链表,将每一项相乘,并根据指数的大小插入到结果链表中。
4. 多项式的求导和求值多项式的求导可以通过遍历链表,将每一项的系数乘以指数,并将指数减一得到新的项。
多项式的求值可以通过遍历链表,将每一项的系数乘以变量的值的指数次方,并累加得到结果。
一元稀疏多项式计算器(数据结构)

院系:计算机科学学院专业:软件工程年级: 2013级课程名称:数据结构姓名:韦宜(201321092034)指导教师:宋中山2015年 12 月 15日题目:设计一个一元稀疏多项式简单计算器班级:软件工程1301 姓名:韦宜学号:201321092034 完成日期:12月15日一、需求分析问题描述:设计一个一元多项式加法器基本要求:输入并建立多项式;(2)两个多项式相加;(3)输出多项式:n, c1, e1, c2, e2, …cn , en, 其中,n是多项式项数,ci和ei分别是第 i 项的系数和指数,序列按指数降序排列。
(4)计算多项式在x处的值;(5)求多项式的导函数。
软件环境:Windows,UNIX,Linux等不同平台下的Visual C++ 6.0硬件环境: 512MB内存,80Gb硬盘,Pentium4 CPU,CRT显示器。
概要分析本程序有五个函数:PolyNode *Input()(输入函数);PolyNode *Deri(PolyNode *head)(求导函数);PolyNode * Plus(PolyNode *A,PolyNode *B)(求和函数);void Output(PolyNode*head)(输出函数);int main()(主函数)本程序可使用带有附加头结点的单链表来实现多项式的链表表示,每个链表结点表示多项式的一项,命名为node,它包括两个数据成员:系数coef和指数exp,他们都是公共数据成员,*next为指针域,用链表来表示多项式。
适用于不定的多项式,特别是对于项数再运算过程中动态增长的多项式,不存在存储溢出的问题。
其次,对于某些零系数项,在执行加法运算后不再是零系数项,这就需要在结果多项式中增添新的项;对于某些非零系数项,在执行加法运算后可能是零系数项,这就需要在结果多项式中删去这些项,利用链表操作,可以简单的修改结点的指针以完成这种插入和删除运算(不像在顺序方式中那样,可能移动大量数据项)运行效率高。
数据结构课程设计___一元稀疏多项式计算器(报告+代码)__完整版.

数据结构课程设计系别电子信息系专业计算机科学与技术班级学号4090113姓名王健指导教师党群成绩2011年7 月14 日目录一、课程题目 (1)二、需求分析 (1)三、测试数据 (2)四、概要设计 (2)五、调用关系图 (3)六、程序代码 (3)七、心得体会及总结 (12)数据结构课程设计一、课程题目一元稀疏多项式计算器二、需求分析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、设计思路分析要解决多项式相加,必须要有多项式,所以必须首先建立两个多项式,在这里采用链表的方式存储链表,所以我将结点结构体定义为运用尾插法建立两条单链表,以单链表polyn p和polyn h分别表示两个一元多项式a和b,a+b的求和运算等同于单链表的插入问题(将单链表polyn p中的结点插入到单链表polyn h中),因此“和多项式”中的结点无须另生成。
为了实现处理,设p、q分别指向单链表polya和polyb的当前项,比较p、q结点的指数项,由此得到下列运算规则:① 若p->expn<q->expn,则结点p所指的结点应是“和多项式”中的一项,令指针p后移。
数据结构实习报告——一元稀疏多项式运算器的设计

数据结构实习报告班级 XXXXXX学生姓名 XXXXXX学号 *******XXXX指导教师 XXXXXX日期 2012年11月10日报告简介:整篇实习报告主要分为三部分:实习一,实习二以及实习困惑。
其中每个实习报告涉及6个部分:需求分析,设计,调试分析,用户手册,测试结果,源程序清单。
具体报告内容如下:实习一:一元稀疏多项式运算器的设计1、需求分析【问题描述】设计一个一元稀疏多项式简单计算器。
【基本要求】(1)输入并建立两个多项式;(2)多项式a与b相加,建立和多项式c;(3)多项式a与b相减,建立和多项式d;(4)输出多项式a,b,c,d。
输出格式:比如多项式a为:A(x)=c1xe1+ c2xe2+…+ cmxem,其中,ci和ei分别为第i项的系数和指数,且各项按指数的升幂排列,即0≤e1<e2<…<em。
2、设计(1)设计思想存储结构:以带头结点的单链表存储多项式。
算法主要思想:●首先定义单链表中每个结点的结构体类型,设计能够生成多项式链表的函数,这个函数的功能是可以根据给定的多项式来创建存储它的单链表。
●然后需要设计两个多项式相加的函数与两个多项式相减的函数。
●要检验多项式的运算结果以及初始的多项式链表正确与否,需要将其打印输出,故还需要设计打印输出函数。
●主函数的设计:依次调用多项式链表生成的函数、多项式相加减的函数,最后将结果打印输出。
(2)概要设计整个算法需要设计五个函数,分别是:多项式链表生成的函数、两个多项式相加的函数、两个多项式相减的函数、打印输出的函数以及主函数。
在设计各个函数之前,要定义单链表结点的结构体类型。
每个结点应该包括指数code、系数exp和指向下一个结点的指针next。
多项式链表生成的函数:函数的返回值应该为定义的结构体类型,不需要设置参数。
函数内部,需要有多项式指数和系数的输入,直至输入的系数为零时结束,将每一对输入的指数和系数保存到新结点中,并将结点插入到链表中。
(完整word版)一元稀疏多项式计算器实现(完整实现版,详细源码)
1。
5一元稀疏多项式计算器实习报告一、需求分析1.输入并建立多项式;2.输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,……,c n,e n,其中n是多项式的项数,c i 和e i分别是第i项的系数和指数,序列按指数降序排列;3.多项式a和b相加,建立多项式a+b;4.多项式a和b相减,建立多项式a-b;5.多项式a和b相乘,建立多项式a×b;6.计算多项式在x处的值;7.求多项式P的导函数P’;8。
多项式的输出形式为类数学表达式;9.做出计算器的仿真界面;10。
测试数据:(1)(2x+5x^8—3.1x^11)+(7—5x^8+11x^9)=(—3。
1x^11+11x^9+2x+7)(2)(6x^—3-x+4。
4x^2—1。
2x^9+1.2x^9)-(-6x^—3+5.4x^2—x^2+7。
8x^15 )=(-7。
8x^15—1.2x^9+12x^-3—x);(3)(1+x+x^2+x^3+x^4+x^5)+(-x^3—x^4)=(1+x+x^2+x^5);(4)(x+x^3)+(-x—x^3)=0(5)(x+x^100)+(x^100+x^200)=(x+2x^100+x^200)(6)(x+x^2+x^3)+0=x+x^2+x^3(7)互换上述测试数据中的前后两个多项式二、概要设计1.链表的抽象数据类型定义为:ADT LinkList{数据对象:D={ ai | ai∈ElemSet, i=1,2,...,n,n≥0 }数据关系:R1={〈ai-1,ai〉|ai—1,ai∈D, i=2,.。
,n }基本操作:InitList(&L)操作结果:构造一个空的线性表L.DestroyList(&L)初始条件:线性表L已存在.操作结果:销毁线性表L。
ClearList(*L)初始条件:线性表L已存在。
操作结果:将线性表L重置为空表。
LocateElem(L,e, cmp())初始条件:线性表L已存在,compare()是元素判定函数。
一元稀疏多项式计算器实验报告(c++编写,附源代码)
一元稀疏多项式计算器实验报告级班年月日学号_1.实验题目设计一个一元稀疏多项式简单计算器。
2.需求分析本程序用VC编写,实现一元浮点系数,整数指数稀疏多项式的创建、两个一元多项式相加、两个一元多项式相减、输出一元多项式。
①输入的形式和输入值的围:A.输入指定的数字,以此选择两个多项式的运算方式,运算方式有两个一元多项式相加、两个一元多项式相减。
B.创建多项式时,需要输入此多项式,每一项的系数和指数。
②输出的形式:每次输入一个完整的多项式后、每次得出多项式运算结果时,会以指定的方式输出多项式。
③程序所能达到的功能:实现一元稀疏多项式的创建、两个一元多项式相加、两个一元多项式相减、输出一元多项式。
④测试数据:输入数据:A.出现选择两个多项式的运算方式菜单时,输入1(即使两个多项式相加);B.首先输入多项式p的每一项系数和指数,当输入的指数为-5000时,表示该多项式输入完毕,输入的数据依次为:3,3,0,-5000;C.其次输入多项式q的每一项系数和指数,输入数据依次为:2,2,0,-5000。
输出结果:多项式q+p的结果为:多项式为:3x3+2x23.概要设计1)为了实现上述程序功能,需要定义多项式结点的抽象数据类型:class Term{数据对象:float coef; 该数据对象为多项式一项中的系数。
int exp; 该数据对象为多项式一项中的指数。
Term* link; 该数据对象为指向下一个多项式结点的指针。
基本操作:A. Term (float c, int e)初始条件:无操作结果:初始化多项式结点对象,将c赋值给该结点的数据成员coef(表示系数),将e赋值给该结点的数据成员exp(表示指数),将该结点的数据成员link赋值为0。
B.Term (float c, int e, Term* next)初始条件:无操作结果:初始化多项式结点对象,将c赋值给该结点的数据成员coef(表示系数),将e赋值给该结点的数据成员exp(表示指数),将next赋值给该结点的数据成员link(link表示指向下一个多项式结点的指针)。
一元稀疏多项式计算器(最多功能)
此程序主要以c和部分c++语言进行编辑,在visual C++2013上进行了检验,事实证明可行,部分代码仍需优化,但仍是网络上功能暂时最强大的一个多项式计算器了。
#include<stdio.h>#include<stdlib.h>#include<iostream>char name1='A';char name2;char name3;int counter = 0;typedef struct Polynomial//结点类型{float coef; //系数int exp; //指数Polynomial *next;}*Polyn; //Polyn为结点指针类型struct Polynomial *ptr[52] = { 0 };struct Polynomial *ptr_2[52] = { 0 };int amount[52] = { 0 };void PrintPolyn(Polyn P) //输出多项式{Polyn q = P->next;int flag = 1; //项数计数器if (!q) //若多项式为空,输出0{putchar('0');printf("\n");return;}while (q){if (q->coef>0 && flag != 1) //系数大于0且不是第一项putchar('+');if (q->coef != 1 && q->coef != -1) //系数非1或-1{printf("%g", q->coef);if (q->exp == 1)putchar('X');else if (q->exp)printf("X^%d", q->exp);}else{if (q->coef == 1){if (!q->exp)putchar('1');else if (q->exp == 1)putchar('X');elseprintf("X^%d", q->exp);}if (q->coef == -1){if (!q->exp)printf("-1");else if (q->exp == 1)printf("-X");elseprintf("-X^%d", q->exp);}}q = q->next;flag++;}printf("\n");}void PrintAll(int m){int temp3 = 0;name2 = 'A';for (; temp3 < m; temp3++){printf("%c=", name2);PrintPolyn(ptr[temp3]);name2++;}}void InsertNode(Polyn p, Polyn head)//插入结点,按指数降序排列{if (p->coef == 0)delete p; //释放系数为0的结点else{Polyn q1, q2;q1 = head;q2 = head->next;while (q2 != NULL&&p->exp<q2->exp) //查找插入位置,{q1 = q2;q2 = q2->next;}if (q2 != NULL&&p->exp == q2->exp) //将指数相同的合并{q2->coef += p->coef; //系数相加delete p; //释放pif (!q2->coef) //释放系数为0的结点{q1->next = q2->next;delete q2;}}else//无相同指数时将该结点插入{p->next = q2;q1->next = p;}}}void CreatePolyn_1(Polyn &head) // 创建多项式头指针为head、项数为m {head = new Polynomial; //生成头结点head->next = NULL;}Polyn CreatePolyn_2(Polyn head, int m){Polyn p;CreatePolyn_1(head);for (int i = 0; i < m; i++){p = new Polynomial; //建立新结点printf("请输入第%d项的系数与指数(空格或回车隔开):", i + 1);scanf_s("%f%d", &p->coef, &p->exp);InsertNode(p, head); //调用InsertNode函数插入结点}return head;}int Compare(Polyn a, Polyn b)//依a的指数值<、=或>b的指数值,分别返回-1、0或1 {if (a&&b){if (!b || a->exp>b->exp)return 1;else if (!a || a->exp<b->exp)return -1;elsereturn 0;}else if (!a&&b)return -1; //a多项式为空,但b多项式非空elsereturn 1; //b多项式为空,但a多项式非空}void ClearPolyn(Polyn p) //清空多项式p{Polyn q1, q2;q1 = p->next;if (q1 == NULL) //结果系数为0的情况return;q2 = q1->next;while (q1->next){delete q1;q1 = q2; //指针后移q2 = q2->next;}p->next = 0;}Polyn AddPolyn(Polyn pa, Polyn pb) //求解并建立多项式A+B{Polyn qa = pa->next;Polyn qb = pb->next;Polyn heada, hc, qc;hc = new Polynomial; //建立头结点hc->next = NULL;heada = hc;while (qa || qb){qc = new Polynomial;switch (Compare(qa, qb)){case 1: //a项的指数大于b项的指数{qc->coef = qa->coef;qc->exp = qa->exp;qa = qa->next;break;}case 0: //a项的指数等于b项的指数{qc->coef = qa->coef + qb->coef;qc->exp = qa->exp;qa = qa->next;qb = qb->next;break;}case -1: //a项的指数小于b项的指数{qc->coef = qb->coef;qc->exp = qb->exp;qb = qb->next;break;}}if (qc->coef != 0){qc->next = hc->next;hc->next = qc;hc = qc;}elsedelete qc; //当相加系数为0时,释放该结点}return heada; //返回其头指针}Polyn SubPolyn(Polyn pa, Polyn pb) //求解并建立多项式A-B{Polyn p1, p2, heads;p1 = pb;p2 = pb->next;while (p2){p2->coef *= -1; //将pb的系数取反p2 = p2->next;}heads = AddPolyn(pa, p1);for (p2 = p1->next; p2; p2 = p2->next) //恢复pb的系数p2->coef *= -1;return heads; //返回其头指针}Polyn MultiplyPolyn(Polyn pa, Polyn pb) //求解并建立多项式A*B *{Polyn headf, qc;Polyn qa = pa->next;Polyn qb = pb->next;headf = new Polynomial; //建立头结点headf->next = NULL;for (; qa; qa = qa->next){for (qb = pb->next; qb; qb = qb->next){qc = new Polynomial;qc->coef = qa->coef*qb->coef;qc->exp = qa->exp + qb->exp;InsertNode(qc, headf); //调用InsertNode函数合并指数相同的项}}return headf; //返回其头指针}Polyn DevicePolyn_1(Polyn pa, Polyn pb) //求解并建立多项式A/B{Polyn quotient, remainder, temp1, temp2;Polyn qa = pa->next;Polyn qb = pb->next;quotient = new Polynomial; //建立头结点,存储商quotient->next = NULL;remainder = new Polynomial; //建立头结点,存储余数remainder->next = NULL;temp1 = new Polynomial;temp1->next = NULL;temp2 = new Polynomial;temp2->next = NULL;temp1 = AddPolyn(temp1, pa);while (qa != NULL&&qa->exp >= qb->exp){temp2->next = new Polynomial;temp2->next->coef = (qa->coef) / (qb->coef);temp2->next->exp = (qa->exp) - (qb->exp);InsertNode(temp2->next, quotient);pa = SubPolyn(pa, MultiplyPolyn(pb, temp2));qa = pa->next;temp2->next = NULL;}remainder = SubPolyn(temp1, MultiplyPolyn(quotient, pb));pb = temp1;return quotient;}Polyn DevicePolyn_2(Polyn pa, Polyn pb) //求解并建立多项式A/B{Polyn quotient, remainder, temp1, temp2;Polyn qa = pa->next;Polyn qb = pb->next;quotient = new Polynomial; //建立头结点,存储商quotient->next = NULL;remainder = new Polynomial; //建立头结点,存储余数remainder->next = NULL;temp1 = new Polynomial;temp1->next = NULL;temp2 = new Polynomial;temp2->next = NULL;temp1 = AddPolyn(temp1, pa);while (qa != NULL&&qa->exp >= qb->exp){temp2->next = new Polynomial;temp2->next->coef = (qa->coef) / (qb->coef);temp2->next->exp = (qa->exp) - (qb->exp);InsertNode(temp2->next, quotient);pa = SubPolyn(pa, MultiplyPolyn(pb, temp2));qa = pa->next;temp2->next = NULL;}remainder = SubPolyn(temp1, MultiplyPolyn(quotient, pb));pb = temp1;return remainder;}float ValuePolyn(Polyn head, float x) //输入x值,计算并返回多项式的值{Polyn p;int i;float sum = 0, t;for (p = head->next; p; p = p->next){t = 1;for (i = p->exp; i != 0;){if (i<0){t /= x;i++;}//指数小于0,进行除法else{t *= x;i--;}//指数大于0,进行乘法}sum += p->coef*t;}return sum;}Polyn DerivativePolyn(Polyn head)//求导数{Polyn q, p1, p2, hd;q = head->next;p1 = hd = (Polyn)malloc(sizeof(struct Polynomial));hd->next = NULL;while (q){if (q->exp != 0){p2 = (Polyn)malloc(sizeof(struct Polynomial));p2->coef = q->coef*q->exp;//系数p2->exp = q->exp - 1;p2->next = p1->next;p1->next = p2;p1 = p2;}q = q->next;}return hd;}Polyn IntegralPolyn(Polyn head)//求积分{Polyn q, p1, p2, hd;q = head->next;p1 = hd = (Polyn)malloc(sizeof(struct Polynomial));hd->next = NULL;while (q){if (q->exp != 0){p2 = (Polyn)malloc(sizeof(struct Polynomial));p2->coef = q->coef/((q->exp)+1);//系数p2->exp = q->exp + 1;p2->next = p1->next;p1->next = p2;p1 = p2;}q = q->next;}return hd;}void DestroyPolyn(Polyn pa){delete pa;}Polyn CopyPolyn(Polyn pa,Polyn pb){Polyn headc;headc = AddPolyn(pa, pb);return headc;}void KeepResultPolyn(Polyn pa, int k){printf("已自动将结果保留至下一个空闲多项式位置\n");ptr[k] = CopyPolyn(pa, ptr[k]);}int main() //主函数{int i = 0;int m, n = 0;int temp1 = 0;int temp2 = 1;float x;float up = 0;float down = 0;char first = 'a';char second = 'b';for (; i < 26; i++)CreatePolyn_1(ptr[i]);i = 0;printf("︵︵§米娜桑早上好!欢迎使用一元稀疏多项式计算器\t\t\t╭─╮\n");printf("\n");printf(" ︶ \n");printf("祝使用愉快,再次对您的使用表示万分感谢!\n");//输出菜单printf("\t\t\t【功能选择项】\n\t≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡\n");printf("\t║ 1.输入一个新的多项式║\t2.修改一个多项式║\n");printf("\t║ 3.复制一个多项式║\t4.清空一个多项式║\n");printf("\t║ 5.计算多项式加法║\t6.计算多项式减法║\n");printf("\t║ 7.计算多项式乘法║\t8.计算多项式除法║\n");printf("\t║ 9.计算多项式乘方║\t10.计算多项式的值║\n");printf("\t║ 11.计算多项式的定积分║\t12.计算多项式的不定积分║\n");printf("\t║ 13.计算多项式的微分║\t14.计算多项式的公因式║\n");printf("\t║ 15.计算多项式的公倍式║\t16.退出║\n");printf("\t≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡\n");do{printf("\t请输入选择:");scanf_s("%d", &i);switch (i){case 0:{printf("\t请不要输入奇怪的东西,谢谢!!!\n");getchar();break;}case 1:{printf("\t请输入多项式项数:");scanf_s("%d", &amount[counter]);ptr[counter] = CreatePolyn_2(ptr[counter], amount[counter]);//建立多项式printf("\t您创建的多项式名称为%c\n", name1);printf("\t您创建的多项式内容为");PrintPolyn(ptr[counter]);counter++;name1++;break;}case 2:{m = counter;PrintAll(m);printf("\t您想修改哪一个多项式?");std::cin >> name3;temp1 = name3 - 'A';ClearPolyn(ptr[temp1]);DestroyPolyn(ptr[temp1]);printf("\t请输入新多项式项数:");scanf_s("%d", &amount[counter]);ptr[counter] = CreatePolyn_2(ptr[counter], amount[counter]);printf("\t已成功修改多项式%c!\n", name3);break;}case 3:{m = counter;PrintAll(m);printf("\t请选择要进行复制的多项式:\n");std::cin >> first;temp1 = first - 'A';printf("\t请选择要将多项式复制至:\n");std::cin >> second;temp2 = second - 'A';if (temp2 >= counter){CreatePolyn_1(ptr[temp2]);ptr[temp2]=CopyPolyn(ptr[temp1],ptr[temp2]);counter++;}else{ClearPolyn(ptr[temp2]);DestroyPolyn(ptr[temp2]);CreatePolyn_1(ptr[temp2]);ptr[temp2] = CopyPolyn(ptr[temp2], ptr[temp1]);}break;}case 4:{m = counter;PrintAll(m);printf("\t请选择要清空的多项式:");std::cin >> first;temp1 = first - 'A';ClearPolyn(ptr[temp1]);DestroyPolyn(ptr[temp1]);CreatePolyn_1(ptr[temp1]);printf("\t已成功清空多项式%c!", first);break;}case 5:{m = counter;PrintAll(m);printf("\t请输入操作数1:\n");std::cin >> first;temp1 = first - 'A';printf("\t请输入操作数2:\n");std::cin >> second;temp2 = second - 'A';ptr[25] = AddPolyn(ptr[temp1], ptr[temp2]);printf("\t%c+%c=", first, second);PrintPolyn(ptr[25]);KeepResultPolyn(ptr[25], counter);ClearPolyn(ptr[25]);counter++;break;}case 6:{m = counter;PrintAll(m);printf("\t请输入操作数1:\n");std::cin >> first;temp1 = first - 'A';printf("\t请输入操作数2:\n");std::cin >> second;temp2 = second - 'A';ptr[25] = SubPolyn(ptr[temp1], ptr[temp2]);printf("\t%c-%c=", first, second);PrintPolyn(ptr[25]);KeepResultPolyn(ptr[25], counter);ClearPolyn(ptr[25]);counter++;break;}case 7:{m = counter;PrintAll(m);printf("\t请输入操作数1:\n");std::cin >> first;temp1 = first - 'A';printf("\t请输入操作数2:\n");std::cin >> second;temp2 = second - 'A';ptr[25] = MultiplyPolyn(ptr[temp1], ptr[temp2]);printf("\t%c*%c=", first, second);PrintPolyn(ptr[25]);KeepResultPolyn(ptr[25], counter);ClearPolyn(ptr[25]);counter++;break;}case 8:{m = counter;PrintAll(m);printf("\t请输入操作数1(被除数):");std::cin >> first;temp1 = first - 'A';printf("\t请输入操作数2(除数):");std::cin >> second;temp2 = second - 'A';if (amount[temp2] == 0){printf("除数为0时不能进行除法运算!\n");break;}ptr[24] = DevicePolyn_1(ptr[temp1], ptr[temp2]);printf("其商为:");PrintPolyn(ptr[24]);KeepResultPolyn(ptr[24], counter);counter++;ptr[25] = DevicePolyn_2(ptr[temp1], ptr[temp2]);counter++;printf("其余为:");PrintPolyn(ptr[25]);KeepResultPolyn(ptr[25], counter);ClearPolyn(ptr[24]);ClearPolyn(ptr[25]);break;}case 9:{m = counter;PrintAll(m);printf("\t请选择要进行乘方的多项式:");std::cin >> first;temp1 = first - 'A';printf("\t请输入要对%c进行几次方:", first);std::cin >> temp2;ptr[25] = CopyPolyn(ptr[temp1], ptr[25]);for (int temp3 = 1; temp3 < temp2; temp3++){ptr[24] = MultiplyPolyn(ptr[25], ptr[temp1]);ClearPolyn(ptr[25]);ptr[25]=CopyPolyn(ptr[24], ptr[25]);ClearPolyn(ptr[24]);}printf("%c^%d=", first, temp2);PrintPolyn(ptr[25]);KeepResultPolyn(ptr[25], counter);counter++;ClearPolyn(ptr[25]);break;}case 10:{m = counter;PrintAll(m);printf("\t请选择您想求值的多项式:");std::cin >> first;temp1 = first - 'A';printf("\t输入x的值:x=");scanf_s("%f", &x);printf("\t多项式A的值:%g\n", ValuePolyn(ptr[temp1], x));break;}case 11:{m = counter;PrintAll(m);printf("\t请选择您想定积分的多项式:");std::cin >> first;temp1 = first - 'A';printf("\t请输入积分下限:");std::cin >> down;printf("\t请输入积分上限:");std::cin >> up;if (down>up){printf("\t积分下限大于积分上限,请小心!强制计算结果为:");}else{printf("\t∫(%f->%f)%c=", down, up, first);}ptr[23] = IntegralPolyn(ptr[temp1]);printf("%f\n", ValuePolyn(ptr[23], up) - ValuePolyn(ptr[23], down));ClearPolyn(ptr[23]);break;}case 12:{m = counter;PrintAll(m);printf("\t请选择要进行不定积分的多项式:");std::cin >> first;temp1 = first - 'A';printf("\t%c的一个原函数为",first);PrintPolyn(ptr[23] = IntegralPolyn(ptr[temp1]));ClearPolyn(ptr[23]);break;}case 13:{m = counter;PrintAll(m);printf("\t请选择要进行微分的多项式:");std::cin >> first;temp1 = first - 'A';printf("\t请输入要进行微分的次数:");std::cin >> temp2;ptr[24] = DerivativePolyn(ptr[temp1]);for (temp1 = 1; temp1 < temp2; temp1++){ptr[25] = DerivativePolyn(ptr[24]);ClearPolyn(ptr[24]);ptr[24] = CopyPolyn(ptr[25], ptr[24]);ClearPolyn(ptr[25]);}printf("%c(%d)=", first, temp2);PrintPolyn(ptr[24]);KeepResultPolyn(ptr[24], counter);counter++;ClearPolyn(ptr[24]);break;}case 14:{m = counter;PrintAll(m);printf("\t请输入操作数1:");std::cin >> first;temp1 = first - 'A';printf("\t请输入操作数2:");std::cin >> second;temp2 = second - 'A';ptr[24] = CopyPolyn(ptr[temp2], ptr[24]);ptr[25] = DevicePolyn_2(ptr[temp1], ptr[temp2]);for (; ptr[25]->next != NULL;){ptr[23] = CopyPolyn(ptr[25], ptr[23]);ptr[25] = DevicePolyn_2(ptr[24], ptr[25]);ClearPolyn(ptr[24]);ptr[24] = CopyPolyn(ptr[23],ptr[24]);}printf("\t这两个多项式的最大公因式为(系数可变):");PrintPolyn(ptr[24]);ClearPolyn(ptr[24]);ClearPolyn(ptr[25]);break;}case 15:{m = counter;PrintAll(m);printf("\t请输入操作数1:");std::cin >> first;temp1 = first - 'A';printf("\t请输入操作数2:");std::cin >> second;temp2 = second - 'A';ptr[24] = CopyPolyn(ptr[temp2], ptr[24]);ptr[25] = DevicePolyn_2(ptr[temp1], ptr[temp2]);for (; ptr[25]->next != NULL;){ptr[23] = CopyPolyn(ptr[25], ptr[23]);ptr[25] = DevicePolyn_2(ptr[24], ptr[25]);ClearPolyn(ptr[24]);ptr[24] = CopyPolyn(ptr[23], ptr[24]);}printf("\t这两个多项式的最小公倍式为(系数可变):");ptr[22] = MultiplyPolyn(ptr[temp1], ptr[temp2]);ptr[21] = DevicePolyn_1(ptr[22], ptr[24]);PrintPolyn(ptr[21]);ClearPolyn(ptr[24]);ClearPolyn(ptr[22]);ClearPolyn(ptr[25]);ClearPolyn(ptr[21]);break;}case 16:{printf("\t欢迎再次使用!O(∩_∩)O谢谢\n");system("pause");break;}default:printf("\t请不要输入奇怪的东西,谢谢!!!\n");break;}} while (i != 16);for (temp2 = 0; temp2 < 26;temp2++)DestroyPolyn(ptr[temp2]);return 0;}。
实验报告(实验二:一元稀疏多项式计算器)
云南大学软件学院实验报告指导教师:朱艳萍 2009秋季学期学号:20081120064 姓名:李雪寒【实验题目】实验2. 一元稀疏多项式简单计算器【问题描述】设计并实现一个一元稀疏多项式的简单计算器。
【基本要求】一元稀疏多项式简单计算器的基本功能是:1.输入并建立多项式;2.输出多项式,序列按指数降序排列;3.多项式a和b相加,并建立多项式a+b;4.多项式a和b相减,并建立多项式a-b;【实现提示】1.用带头节点的单链表作为多项式的存储结构;一、【概要设计】链式存储结构,由于不要求逻辑上相邻的元素在物理上也相邻,因此,能够迅速进行插入或删除操作,而且不像顺序存储结构那样需要移动大量元素,但也没有顺序表那样随机存取的优点。
主程序中通过调用void create(polynmial &L) 创建存储在单链表中的多项式,调用void display(polynmial L); 输出显示多项式,调用void sort(polynmial &L)和void reverse(polynmial &L)对多项式进行排序,使其按降序排列,调用void add(polynmial La,polynmial Lb, polynmial &Lc) 和void subtract(polynmial La, polynmial Lb, polynmial &Ld) 对两个多项式进行加减操作。
二、【详细设计】在此次试验中,主要通过以下7个子函数对存储在单链表中的多项式进行操作:void create(polynmial &L) //输入并建立多项式L{int i, n;static struct node *p;printf("输入多项式项数:\n");scanf("%d", &n);//输入多项式的项数L = (struct node *)malloc (sizeof(struct node));L->next = NULL;for(i = 0; i < n; i++){p = (struct node *)malloc(sizeof(struct node));printf("输入一个项的系数和指数,用空格隔开:\n");scanf("%f %d", &p->c, &p->e);p->next = L->next;L->next = p;}//利用for循环输入多项式中每一项的系数和指数}void display(polynmial L)//显示,输出多项式L{struct node *p, *q;//建立两个结点int flag = 0;int k = 0;q = L->next;while(q){if(q->c!= 0)k++;//计算多项式的项数q = q->next;}printf("共%d项\n", k);//输出多项式的项数p = L->next;if(p->c != 0){printf("+%.1fx^%d", p->c, p->e);flag++;}//判断该项是否为零,不为零则输出for(p = p->next; p; p = p->next){if(p->c != 0){printf("+%.1fx^%d", p->c, p->e);flag++;}}//输出多项式if(flag == 0)printf("%d\n", flag);elseprintf("\n");}void sort(polynmial &L)//多项式L按指数排序{polynmial p, q, r, s;p = L->next;L->next = NULL;while(p != NULL){r = L;q = L->next;while((q != NULL) && (q->e <= p->e)){r = q;q = q->next;}s = p->next;r->next = p;p->next = q;p = s;}}void reverse(polynmial &L)//逆置{polynmial H;static struct node *p, *q, *s;H = (struct node*)malloc(sizeof(struct node));H->next = NULL;p = (struct node*)malloc(sizeof(struct node));s = L->next;p->c = s->c;p->e = s->e;p->next = s->next;while(s){p->c = s->c;p->e = s->e;p->next = s->next;q = H->next;H->next = p;p->next = q;p = (struct node*)malloc(sizeof(struct node));s = s->next;}p = H->next;q = L->next;while(p){q->c = p->c;q->e = p->e;q = q->next;p = p->next;}}void select() //用户选择加减操作{printf("请选择加减操作\n");printf("1.两个一元多项式相加\n");printf("2.两个一元多项式相减\n");}void add(polynmial La, polynmial Lb, polynmial &Lc)//多项式La,Lb相加,并付给Lc {struct node *pa, *pb;static struct node *pc;Lc = (struct node*)malloc(sizeof(struct node));pa = La->next;pb = Lb->next;Lc->next = NULL;while(pa && pb){pc = (struct node*)malloc(sizeof(struct node));if(pa->e < pb->e){pc->next = Lc->next;Lc->next = pc;pc->c = pa->c;pc->e = pa->e;pa = pa->next;}elseif(pa->e == pb->e){pc->next = Lc->next;Lc->next = pc;pc->e = pa->e;pc->c = pa->c + pb->c;pa = pa->next;pb = pb->next;}else{pc->next = Lc->next;Lc->next = pc;pc->c= pb->c;pc->e = pb->e;pb = pb->next;}}while(pa){pc = (struct node*)malloc(sizeof(struct node));pc->next = Lc->next;Lc->next = pc;pc->c = pa->c;pc->e = pa->e;pa = pa->next;}while(pb){pc = (struct node*)malloc(sizeof(struct node));pc->next = Lc->next;Lc->next = pc;pc->c = pb->c;pc->e = pb->e;pb = pb->next;}}void subtract(polynmial La, polynmial Lb, polynmial &Ld)//多项式La减去Lb,结果赋给Ld{struct node *pa, *pb;static struct node *pd;Ld = (struct node*)malloc(sizeof(struct node));pa = La->next;pb = Lb->next;Ld->next = NULL;while(pa && pb){pd = (struct node*)malloc(sizeof(struct node));if(pa->e< pb->e){pd->next = Ld->next;Ld->next = pd;pd->c= pa->c;pd->e = pa->e;pa = pa->next;}elseif(pa->e == pb->e){pd->next = Ld->next;Ld->next = pd;pd->e= pa->e;pd->c = pa->c - pb->c;pa = pa->next;pb = pb->next;}else{pd->next = Ld->next;Ld->next = pd;pd->c = pb->c;pd->e = pb->e;pb = pb->next;}}while(pa){pd = (struct node*)malloc(sizeof(struct node));pd->next = Ld->next;Ld->next = pd;pd->c = pa->c;pd->e = pa->e;pa = pa->next;}while(pb){pd = (struct node*)malloc(sizeof(struct node));pd->next = Ld->next;Ld->next = pd;pd->c = -pb->c;pd->e = pb->e;pb = pb->next;}}三、【测试结果】四、【实验总结】此次实验较实验一来说要难得多,算法也复杂得多,原因主要有:1、C语言的应用很生疏,有待加强;2、对于单链表的插入和删除操作不熟练,需要借助课本和资料进行参考;3、程序比较复杂,算法思想也很难理清,需要多加锻炼。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
院系:计算机科学学院专业:软件工程年级: 2013级课程名称:数据结构姓名:韦宜(201321092034)指导教师:***2015年 12 月 15日题目:设计一个一元稀疏多项式简单计算器班级:软件工程1301 姓名:韦宜学号:201321092034 完成日期:12月15日一、需求分析问题描述:设计一个一元多项式加法器基本要求:输入并建立多项式;(2)两个多项式相加;(3)输出多项式:n, c1, e1, c2, e2, …cn , en, 其中,n是多项式项数,ci和ei分别是第i 项的系数和指数,序列按指数降序排列。
(4)计算多项式在x处的值;(5)求多项式的导函数。
软件环境:Windows,UNIX,Linux等不同平台下的Visual C++ 6.0硬件环境: 512MB内存,80Gb硬盘,Pentium4 CPU,CRT显示器。
二、概要分析本程序有五个函数:PolyNode *Input()(输入函数);PolyNode *Deri(PolyNode *head)(求导函数);PolyNode * Plus(PolyNode *A,PolyNode *B)(求和函数);void Output(PolyNode*head)(输出函数);int main()(主函数)本程序可使用带有附加头结点的单链表来实现多项式的链表表示,每个链表结点表示多项式的一项,命名为node,它包括两个数据成员:系数coef和指数exp,他们都是公共数据成员,*next为指针域,用链表来表示多项式。
适用于不定的多项式,特别是对于项数再运算过程中动态增长的多项式,不存在存储溢出的问题。
其次,对于某些零系数项,在执行加法运算后不再是零系数项,这就需要在结果多项式中增添新的项;对于某些非零系数项,在执行加法运算后可能是零系数项,这就需要在结果多项式中删去这些项,利用链表操作,可以简单的修改结点的指针以完成这种插入和删除运算(不像在顺序方式中那样,可能移动大量数据项)运行效率高。
三、详细设计(1)主函数:int main(){PolyNode *head_a,*head_b;int choice;head_a=new PolyNode;head_a->next=NULL;do{system("cls");//清屏函数Output(head_a);cout<<" ______________________________\n";cout<<"|---------1.输入公式-----------|\n";cout<<"|---------2.求导-----------|\n";cout<<"|---------3.两式求和-----------|\n";cout<<"|---------4.退出程序-----------|\n";cout<<" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";cin>>choice;if (choice==1) head_a=Input();else if (choice==2) head_a=Deri(head_a); //求导else if (choice==3) {head_b=Input();head_a=Plus(head_a,head_b);}//求和else if (choice==4) break;else cout<<"输入错误,重新输入:\n";}while(choice!=5);return 0;(2)由于此程序是二人合作完成,我在此程序中主要是完成求和和求导函数的设计。
所以下面着重介绍下求和函数和求导函数。
PolyNode *Deri(PolyNode *head)(求导函数):流程图如下:求导函数部分代码:PolyNode *Deri(PolyNode *head) //求导{PolyNode *p=head;while (p->next!=NULL){if(p->next->exp==0) p->next=NULL; //指数为零返回else{p->next->coef*=p->next->exp; //系数乘以指数p->next->exp--; //指数减一p=p->next;}}return head;用于对输入的多项式进行求导,求导在链表内进行计算,即运算完成链表的值改变,返回头指针。
PolyNode * Plus(PolyNode *A,PolyNode *B)(求和函数):流程图如下:本函数用于对多项式进行加法计算,需要运用存有两个多项式的头指针,前一头指针可是前一计算的计算结果,也可是调用输入函数,后一头指针是调用输入函数输入的多项式的头接点。
经过计算得到一个新的链表,函数返回链表的头指针。
求和函数部分代码PolyNode * Plus(PolyNode *A,PolyNode *B)//相加{PolyNode *head,*p;head=new PolyNode;p=head;A=A->next;B=B->next;while(A!=NULL||B!=NULL){if(A==NULL) {p->next=B; break;} //如果A空,把B后面的所有接点接到p之后if(B==NULL) {p->next=A; break;} //如果B空,把A后面的所有接点接到p之后if(A->exp==B->exp) //如果两指数数相等,相加{if(A->coef+B->coef!=0){p->next=new PolyNode;p=p->next;p->exp=A->exp;p->coef=A->coef+B->coef;}A=A->next;B=B->next; continue; //如果两系数互为倒数,不保存,后指,继续循环}if(A->exp > B->exp) //A的指数大于B的指数{p->next=new PolyNode;p=p->next;p->exp=A->exp;p->coef=A->coef;A=A->next; continue; //将A的当前接点接到新链表后面,A后指}p->next=new PolyNode;p=p->next;p->exp=B->exp;p->coef=B->coef;B=B->next; //将B的当前接点接到新链表后面,B后指}if (A==NULL&&B==NULL) //如果A B 都为空p->next=NULL;return head; //返回头指针}(3)其他函数(同组的成员设计)#include <iostream>#include <process.h>using namespace std;typedef struct node{float coef; //系数int exp; //指数struct node *next; //指针域指向下一个系数不为0的子项} PolyNode;PolyNode *Input() //输入函数{float c; //系数域int e; //指数域PolyNode *p,*q,*r,*head;cout<<"请输入多项式:\n";cout<<"形式:系数1 指数1 系数2 指数2 系数3 指数3......0 0:\n";head=new PolyNode; //建立头接点p=head;p->next=NULL;for (;;){cin>>c>>e;if(c==0&&e==0) break; //结束输入if(c==0) continue; //从新输入,不保存if(head->next==NULL) //输入第一个接点{p->next=new PolyNode;p=p->next;p->coef=c,p->exp=e;p->next=NULL;continue;}p=head;while(p->next!=NULL && e<=p->next->exp) p=p->next; //如果输入的指数小于p的下一个接点,p向后指if (e==p->exp) {p->coef+=c;continue;} //如果相等,直接加上去,继续循环q=new PolyNode;q->coef=c,q->exp=e;if (p->next!=NULL&&e>p->next->exp) //如果p的后继接点的指数小于输入的指数,插入到p的当前接点之后{r=p->next;p->next=q;q->next=r;continue;}p->next=q; //如果输入的值小于所有接点,接在最后一个接点之后p=p->next; p->next=NULL;}return head;}输出函数void Output(PolyNode*head) //输出{PolyNode*p;p=head->next;if(p==NULL) {cout<<"当前没有公式或计算结果为0,请选1输入!!!\n"; return;}if(p!=NULL){cout<<"计算结果:\n";cout<<p->coef<<"X~"<<p->exp;p=p->next;}while(p!=NULL){cout<<"+"<<p->coef<<"X~"<<p->exp;p=p->next;}cout<<endl;cout<<"如果想重新输入公式,请选1输入!!!\n\n";}四、调试分析与操作说明(1)当程序运行时,进入主界面。