桂林理工大学-软件综合实习【一元稀疏多项式计算器】何天从

合集下载

一元稀疏多项式的加法运算数据结构实习

一元稀疏多项式的加法运算数据结构实习

实习一线性表、栈和队列及其应用——一元稀疏多项式的加法运算【问题描述】设计一个实现一元稀疏多项式相加运算的演示程序。

【基本要求】(1)输入并建立两个多项式;(2)多项式a与b相加,建立和多项式c;(3)输出多项式a,b,c。

输出格式:比如多项式a为:A(x)=c1xe1+c2xe2+…+ cmxem,其中,ci和ei分别为第i项的系数和指数,且各项按指数的升幂排列,即0≤e1<e2<…<em。

多项式b,c类似输出。

【测试数据】(1)(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5)(2)(x+x100)+(x100+x200)=(x+2x100+x200)(3)(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11)一.需求分析1.输入的形式和输入值的围:输入是从键盘输入的,输入的容为多项式的系数和指数,其中多项式的每一项分别以一个系数和指数的形式输入,不带未知数X,系数为任意的实数,指数为任意的整数。

要结束该多项式的输入时,输入的指数和系数都为0.2. 输出的形式从屏幕输出,显示用户输入的多项式,并显示多项式加减以后的多项式的值,并且多项式中将未知数X表示了出来. 形式为:+c1X^e1+c2X^e2+…+ciX^ei+…(ci和ei分别是第i 项的系数和指数,序列按指数升序排列。

)当多项式的某一项的系数为+1或者-1时侧该项多项式的输出形式为X^ei或-X^ei;当该项的系数为正时输出+ciX^ei,当为负数时则输出ciX^ei3. 程序所能达到的功能输入并建立多项式,实现一元稀疏多项式的相加并输出。

4. 注意:所有多项式都必须以指数升密形式输入。

5. 测试数据为(1)(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5)(2)(x+x100)+(x100+x200)=(x+2x100+x200)(3)(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11)二.设计1.设计思路(1).储存结构:链式存储(2). 主要算法基本思路首先定义一个多项式的结构体,存放多项式每一项的系数和指数以及next指针;然后定义两个指针,第一个指针指向第一个多项式,第二个指针指向第二个多项式。

一元稀疏多项计算器【加法和减法】

一元稀疏多项计算器【加法和减法】

Data Structure.实习报告【实习一线性表、堆栈和队列的应用】一元稀疏多项式运算器Xiaohui HuangChina University of Geosciences(Wuhan) , Wuhan,Wuhan , Hubei Province , China ;Email : hxh1994@/hxh20111003570@1.问题描述设计一个一元稀疏多项式简单计算器。

要求为:(1)输入并建立两个多项式;(2)多项式a与b相加,建立和多项式c;(3)多项式a与b相减,建立和多项式d;(4)输出多项式a,b,c,d。

输出格式:比如多项式a为:A(x)=c1x e1+ c2x e2+…+ c m x em,其中,c i 和e i分别为第i项的系数和指数,且各项按指数的升幂排列,即0≤e1<e2<…<e m。

2.设计◆设计思想我们知道,一个一元多项式可表示为A(x)=a0+a1x+a2x2+⋯+a n x n 其中,a0、a1、a2、…、a n为多项式的系数,惟一确定了这个多项式,而每一项的指数这隐藏在系数a i的序号中了。

那么我们可以使用线性表(a0、a1、a2、…、a n)来表示。

设A=(a0、a1、a2、…、a n),B=(b0、b1、b2、…、b n),则多项式的加法就相当于A+B=C,其中,C=(c0、c1、c2、…、c n),其中c i=a i+b i。

◆概要设计从设计思想我们可以得知我们这个程序的主要功能是模拟计算器的加法和减法功能。

那么问题就归结于创建两个线性表,通过线性表相对应元素的相加减来模拟计算器的功能。

现在的问题是:我们应该选择什么类型的线性表、我们应该选择线性表的哪一种存储结构。

通过我们所学习的知识可以知道,我们有线性表、堆栈和队列等来可供选择,而经过考虑后,多项式的建立应该使用一种线性结构,故我们选择线性表。

另一方面,我们知道一个多项式并不是每一项的系数是存在的,比如一个只含有两个项的多项式,其中,一个项的指数是1,一个项的指数是1000,如果此时我们采用线性表的顺序存储结构,那么会极大的浪费内存空间。

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

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

数据结构实习报告——一元稀疏多项式运算器的设计一、引言在计算机科学领域中,数据结构是研究数据组织、存储和管理的关键概念之一。

在本次实习中,我设计并实现了一个一元稀疏多项式运算器,旨在使用适当的数据结构和算法来高效地进行多项式的加法、减法和乘法运算。

本报告将详细介绍该运算器的设计思路、算法实现以及性能评估。

二、设计思路1. 多项式的表示在设计多项式运算器时,首先需要确定多项式的表示方法。

为了高效地处理稀疏多项式,我选择使用链表作为基本数据结构。

每个节点包含多项式的系数和指数,并通过指针连接在一起形成链表。

这种表示方法可以有效地处理稀疏多项式,减少了不必要的空间浪费。

2. 多项式的输入和输出为了方便用户输入和输出多项式,我设计了简单的交互界面。

用户可以通过命令行输入多项式的系数和指数,并选择进行的运算操作。

运算结果将直接在命令行中输出。

三、算法实现1. 多项式的加法多项式的加法是指将两个多项式相加得到一个新的多项式。

为了实现这个功能,我设计了一个算法如下:- 创建两个空的链表,分别表示两个多项式。

- 逐个读取用户输入的系数和指数,并将其插入到相应的链表中。

- 对两个链表进行遍历,根据指数的大小关系进行合并操作。

- 将合并后的结果链表输出。

2. 多项式的减法多项式的减法是指将一个多项式减去另一个多项式得到一个新的多项式。

为了实现这个功能,我设计了一个算法如下:- 创建两个空的链表,分别表示两个多项式。

- 逐个读取用户输入的系数和指数,并将其插入到相应的链表中。

- 对第二个链表中的每个节点的系数取相反数。

- 对两个链表进行遍历,根据指数的大小关系进行合并操作。

- 将合并后的结果链表输出。

3. 多项式的乘法多项式的乘法是指将两个多项式相乘得到一个新的多项式。

为了实现这个功能,我设计了一个算法如下:- 创建一个空的链表,表示乘法结果。

- 逐个读取用户输入的系数和指数,并将其插入到链表中。

- 对第一个链表中的每个节点,与第二个链表中的每个节点进行乘法运算,并将结果插入到结果链表中。

实验报告——2一元稀疏多项式计算器

实验报告——2一元稀疏多项式计算器
2345、z34、
(3)(1+x+x +x +x +x ) +( -x-x )
(4)(x+x2+x3)+0
(5)(x+x3)-(-x-x-3)
⑹(x+x2+x3)+0
三、实验内容
主要算法设计
typedef struct Node
{
float coef;
int in dex;
struct Node *n ext;
{
LinkList *pc;
int flag=0;
while(flag==0)
{
if(pb->next==NULL)
flag=1;
else
{
pb=pb->next;
pc=(LinkList *)malloc(sizeof(LinkList));
pc->coef=-pb->coef; pc->index=pb->index; pc->next=NULL;
主冃主冃斗冃主
2,1
5,B -3.1,11
项式b的项数;3 7,0-5.8ffl-ltb疏多项式计算器
3
»■快I列歹序序1数2数弓整t(展lt4L2^^bm、」丄-TrJ二上M?E--uMr.选项选项选现岀岀岀4-.冷丄#-W
3
nV为===*
,2,1
,7,
请输更入塾项更蠢製扌吐 亟人第2项更薑癒吋 备入第咗项的系数却1逼△鄴项翌謎I诰倉△第2项更舍魅吐亟人>项 聶入第4项的系数稲
Insert(pc,head);
}
}
return head;
void main()

一元稀疏多项式计算器数据结构

一元稀疏多项式计算器数据结构

一元稀疏多项式计算器数据结构一元稀疏多项式计算器是一种用于计算多项式的工具,该工具可以用于代数计算、数学分析以及计算机科学中的算法设计。

它可以通过一种特殊的数据结构来存储多项式,并可以对其进行加法、减法、乘法、除法等运算。

这种数据结构被称为稀疏多项式,它是一种基于链表的数据结构。

在稀疏多项式中,每个节点表示一个单项式,节点的数据包含该单项式的系数和指数。

在一个稀疏多项式中,只有少数几个节点表示一个多项式,这就是稀疏性的来源。

稀疏多项式的加法和减法非常简单,只需要对两个多项式的对应节点进行加减即可。

而稀疏多项式的乘法需要更复杂的算法。

乘法的过程中需要将两个多项式的每个单项式乘起来,并将同类项合并成一个新的多项式。

这个过程涉及到大量的链表操作,但只要注意一些细节,将会得到正确的结果。

除了基本的加法、减法、乘法运算,一元稀疏多项式计算器还有一个非常重要的运算,那就是求导。

求导是一种将多项式每个单项式的指数减一,并将系数乘以指数的运算。

它常用于解决微积分、概率论等问题。

求导操作可以通过修改节点的指数和系数来实现。

在计算机科学中,稀疏多项式可以用于设计高效的算法,例如在数论、密码学、图像处理、计算器表达式求值等方面。

稀疏多项式的优点在于它可以有效地节省存储空间和计算时间。

通过动态链表的形式,可以轻松地添加、删除节点,使得稀疏多项式非常适合用于处理大规模的数据。

总的来说,一元稀疏多项式计算器是一种非常实用的工具。

它可以用于解决多项式运算问题,并可以为计算机科学方面的算法设计提供很大的帮助。

通过了解这种数据结构,我们可以更深入地理解代数学、微积分学等数学原理,并且能够更好地应用于实际问题中。

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

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

数据结构实习报告——一元稀疏多项式运算器的设计一、引言在计算机科学领域中,数据结构是构建各种算法和程序的基础。

本次实习项目旨在设计一个一元稀疏多项式运算器,通过合理的数据结构和算法实现多项式的加法、减法和乘法运算,以及求导和求值等功能。

本文将详细介绍该运算器的设计思路、数据结构选择、算法实现和性能优化等方面。

二、设计思路为了实现一元稀疏多项式的运算,我们需要选择合适的数据结构来存储和操作多项式的系数和指数。

考虑到多项式中只有少数系数非零,我们可以使用链表来表示多项式,每个节点存储一个非零系数和对应的指数。

这样可以节省空间,并且方便插入和删除操作。

三、数据结构选择在设计中,我们选择了一个单向链表作为多项式的数据结构。

链表节点的定义如下:```struct Node {int coefficient; // 系数int exponent; // 指数Node* next; // 下一个节点指针};```链表的头节点指针指向第一个非零项,便于遍历和操作。

四、算法实现1. 多项式的输入用户可以通过标准输入方式输入多项式的系数和指数,我们通过读取用户输入的系数和指数,并根据其大小构建链表。

2. 多项式的加法和减法运算多项式的加法和减法运算可以通过遍历两个多项式的链表,并根据指数的大小进行合并操作。

具体的实现可以使用双指针的方式,分别指向两个链表的当前节点,比较指数的大小,然后将较小的节点插入到结果链表中,并将指针向后移动。

3. 多项式的乘法运算多项式的乘法运算可以通过遍历两个多项式的链表,并将每一项相乘得到新的项,然后将新的项插入到结果链表中。

具体的实现中,可以使用一个嵌套的循环,先遍历一个多项式的链表,再遍历另一个多项式的链表,将每一项相乘,并根据指数的大小插入到结果链表中。

4. 多项式的求导和求值多项式的求导可以通过遍历链表,将每一项的系数乘以指数,并将指数减一得到新的项。

多项式的求值可以通过遍历链表,将每一项的系数乘以变量的值的指数次方,并累加得到结果。

一元稀疏多项式简单的计算器

一元稀疏多项式简单的计算器

1.一元稀疏多项式简单的计算器(实验类型:综合型)1)问题描述:用线性表表示一元稀疏多项式,设计一个一元多项式运算器2)实验要求:✧采用单链表存储结构一元稀疏多项式✧输入并建立多项式✧输出多项式✧实现多项式加、减运算3) 实现提示:以两个多项式相加为例✧结果多项式另存✧扫描两个相加多项式,若都未检测完:⏹若当前被检测项指数相等,系数相加,若结果未变成0,则将结果插入到结果多项式。

⏹若当前被检测项指数不等,则将指数较小者插入到结果多项式。

若有一个多项式已检测完,则将另一个多项式剩余部分直接连接到结果多项式。

4.一元稀疏多项式简单的计算器(实验类型:综合型)#include<stdio.h>#include<stdlib.h>typedef struct{float coef;//系数int expn;//指数} Term;typedef struct ploynomial{Term term;ploynomial* next;} ploynomial,*LinkList;void InitList(LinkList&L){//初始化链表L= (ploynomial*)malloc(sizeof(ploynomial));//头结点L->term.coef=0.0;L->term.expn=-1; L->next=NULL;}int cmp(Term a,Term b){//比较结点的系数大小函数if(a.expn>b.expn) return -1;else if(a.expn==b.expn) return 0; else return 1;}void insertNode(LinkList&L,Term e){//将结点插入多项式链表的适当位置,可以同时起到创建链表和多项式相加的功能ploynomial* q=L;while(q->next!=NULL){if(cmp(q->next->term,e)<0)//如果当前结点q的下一个结点的指数大于要插入的结点的指数q=q->next;//q指向下一个结点else break;//此时,q.term.expn>e.expn>=q->next->term.expn }if(q->next!=NULL&&cmp(q->next->term,e)==0) //指数相同,系数相加{q->next->term.coef+=e.coef;}else{ploynomial* node =(ploynomial*) malloc(sizeof(ploynomial));node->term.coef=e.coef;node->term.expn=e.expn;if(q->next==NULL)node->next=NULL; //如果q结点为尾结点,则node的指针域设为NULLelsenode->next=q->next; //否则node的指针域指向q的下一个结点q->next=node;//将node结点插入链表中}}void CreatPolyn(LinkList&L,int m){//输入m项的系数和指数,建立表示一元多项式的有序链表L Term e;InitList(L);for(int i=1; i<=m; i++){printf("\n第%d项的系数和指数:",i);scanf("%f%d",&e.coef,&e.expn);insertNode(L,e);}}void addPolyn(LinkList&L,LinkList L1,LinkList L2){//用L返回L1+L2的结果ploynomial* q;for(q=L1->next; q!=NULL; q=q->next){insertNode(L,q->term);//将L1的每一项插入到L中}for(q=L2->next; q!=NULL; q=q->next) //将L2的每一项插入到L 中{insertNode(L,q->term);}}void SubtracatPolyn(LinkList&L,LinkList L1,LinkList L2){//用L返回L1-L2的结果ploynomial* q;for(q=L1->next; q!=NULL; q=q->next){insertNode(L,q->term);//将L1的每一项插入到L中}for(q=L2->next; q!=NULL; q=q->next){q->term.coef = -(q->term.coef); //把系数变成相反数,再进行相加操作,即为L1-L2insertNode(L,q->term);//将L2的每一项插入到L中}}void multiplyPolyn(LinkList&L,LinkList L1,LinkList L2) {//用L返回L1*L2的结果ploynomial *p,*q;Term term;term.coef=0.0;term.expn=0;for(q=L1->next; q!=NULL; q=q->next){for(p=L2->next; p!=NULL; p=p->next){term.coef=(q->term.coef)*(p->term.coef);//系数相乘term.expn=(q->term.expn)+(p->term.expn);// 指数想加insertNode(L,term);}}}void derivativePolyn(LinkList&L,LinkList L1){//用L返回L1的导数ploynomial *p;Term term;for(p=L1->next; p!=NULL; p=p->next){if(p->term.expn==0){ continue;//指数为0时,导数为0 ,跳过此次循环}else{ term.coef=(p->term.coef)*(p->term.expn); //系数乘以指数term.expn=(p->term.expn)-1;//指数减一insertNode(L,term);}}}void visitList(LinkList L){//以类数学表达式的形式打印输出一元多项式L,//即指数或者系数为1的情况下省略1ploynomial* q=L;int flag;while(q->next!=NULL){q=q->next;flag=1;if(q->term.coef==0) continue;//系数为0 不输出if(q->term.expn==0&&flag==1) //指数为1{if(q->term.coef>0)printf("+%.2f",q->term.coef);elseprintf("%.2f",q->term.coef);flag=0;}if((q->term.coef==1||q->term.coef==-1)&&flag==1)//系数为1{if(q->term.expn==1){ if(q->term.coef==1)printf("+X"); elseprintf("-X");}else{if(q->term.coef==1)printf("+X^%d",q->term.expn); elseprintf("-X^%d",q->term.expn); } flag=0;}if(flag==1){ if(q->term.coef>0)printf("+%.2fX^%d",q->term.coef,q->term.expn);elseprintf("%.2fX^%d",q->term.coef,q->term.expn);} } printf("\n");}int main(){LinkList L1,L2; int n1,n2;printf("请输入多项式L1的项数:");scanf("%d",&n1);CreatPolyn(L1,n1);printf("请输入多项式L2的项数:");scanf("%d",&n2);CreatPolyn(L2,n2);printf("\n多项式L1:");visitList(L1);printf("\n多项式L2: ");visitList(L2);LinkListadd,sub,multiply,derivative1,derivative2;InitList(ad d);InitList(sub);InitList(multiply);InitList(derivative1);InitList(derivative2);derivativePol yn(derivative1,L1);derivativePolyn(derivative2,L2);printf("\nL1的导数:");visitList(derivative1);printf("\nL2的导数:");visitList(derivative2);addPolyn(add,L1,L2);SubtracatPolyn(sub,L1,L2);multiplyPolyn(multiply ,L1,L2);printf("\nL1 + L2: ");visitList(add);printf("\nL1 - L2: ");visitList(sub);printf("\nL1 * L2: ");visitList(multiply);}实验心得:无。

c一元稀疏多项式计算器-课程设计实验报告

c一元稀疏多项式计算器-课程设计实验报告

2016-2017学年第二学期学号1608220203 《网络工程》课程设计报告题目:一元稀疏多项式计算器专业:网络工程班级:网络工程(3)班姓名:代应豪指导教师:代美丽成绩:[键入文字] [键入文字] [键入文字]一、问题描述 (3)二、需求分析 (3)三、概要设计 (4)四、详细设计 (5)五、源代码 (6)六、程序测试 (19)七、使用说明 (25)八、课设总结 (26)一、问题描述1.1基本要求(1)输入并建立多项式;(2)输出多项式,输出形式为整数序列:n,c1,e1, c2,e2,,,,,,, cn,en,其中n 是多项式的项数,ci,ei,分别是第i项的系数和指数,序列按指数降序排序;(3)多项式a和b相加,建立多项式a+b;(4)多项式a和b相减,建立多项式a-b;(5)计算多项式在x处的值。

(6)计算器的仿真界面。

1.2设计目的数据结构是实践性很强的课程。

课程设计是加强学生实践能力的一个强有力手段。

课程设计要求学生在完成程序设计的同时能够写出比较规范的设计报告。

严格实施课程设计这一环节,对于学生基本程序设计素养的培养和软件工作者工作作风的训练,将起到显著的促进作用二、需求分析2.1设计开发环境:软件方面:系统windows 7编程软件:VC++ 6.02.2思路分析:①一般情况下的一元n次多项式可写成pn(x)=p1xe1+p2xe2+……+pmxem其中,p1是指数为ei的项的非零系数,且满足0≦e1<e2<……<em=n ,若用一个长度为m且每个元素有两个数据项(系数项和指数项)的线性表((p1,e1),(p2,e2),……,(pm,em))便可惟一确定多项式pn(x)。

②用两个带表头结点的单链表分别存储两个多项式③根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相同的项,对应系数相加,若其和不为零,则构成“和多项式”中的一项;④只需要将第二个多项式的系数改为其相反数,然后根据一元多项式相加的运算规则便可以得到其相应的“差多项式”三、概要设计图3-1功能模块图为实现上述程序功能,用带表头结点的单链表存储多项式。

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

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

数据结构实习报告班级 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。

多项式链表生成的函数:函数的返回值应该为定义的结构体类型,不需要设置参数。

函数内部,需要有多项式指数和系数的输入,直至输入的系数为零时结束,将每一对输入的指数和系数保存到新结点中,并将结点插入到链表中。

一个一元稀疏多项式简单计算器课程设计报告

一个一元稀疏多项式简单计算器课程设计报告

一个一元稀疏多项式简单计算器课程设计报告课程课课课告学院,课程名,称课课班课,学生姓名, ,学号目课1 一元稀疏多课式课算器1.1 述概课了课课任意多课式的加法~法~因此课课课课表的课~有一系~指~下减构体它个数数一指课个个元素3使用课言,课言C课课课境,VC++ 6.01.2 课课容内、课课描述1课课一一元稀疏多课式课课课算器。

个基本要求,一元稀疏多课式课课课算器的基本功能是,;,课入建立多课式~并1;,课出多课式~课出形式课整序列,数~其中是多课式2n,c1,e1,c2,e2,…cn,en,n的课~数分课是第课的系和指~序按指降序排序~数数数数c1,e1,i;,多课式和相加~建立多课式3aba+b;;,多课式和相~建立多课式减4aba-b;;,课算多课式在课的课~5x;,课算器的界面;课做,。

仿真6、需求分析2;,课入的形式和课入课的范课,1课入是课课课入的~课入的容课多课式的系和指~课任意的整~指课大于从内数数数数数等于的整数0;,课出的形式2从屏并减幕课出~课示用课课入的多课式~课示多课式加以后的多课式的课。

;,程序所能到的功能达3,课入建立多课式~并a,课出多课式~课出形式课整序列,数其中是多课式的课数~bn,c1,e1,c2,e2,……,cn,en,n和分课是第课的系和指~序列按指降序排列~数数数cieii,多课式和相加~建立多课式~caba+b,多课式和相~建立多课式减~daba-b,多课式的课出形式课课表式~数学达e,系课课数的非零课的课出形式中略去系数~而的课出形式课。

f11-1x-x1.3 要课课概、存课课构1typedef struct Polynomial { float coef; int expn; struct Polynomial *next;}*Polyn,Polynomial;课课用以存放第构体课的系和指和下一指课~以课课课基课。

数数个i、函数2Polyn CreatePolyn(Polyn head,int m)课函用于建立一课指课课数个~课课数的一元多课式headm课函用于课毁多课式数void DestroyPolyn(Polyn p)课函用于课出多课式数void PrintPolyn(Polyn P) aPolyn AddPolyn(Polyn pa,Polyn pb)课函用于求解建立多课式数并~返回其课指课a+bPolyn SubtractPolyn(Polyn pa,Polyn pb)课函用于求解建立多课式数并~返回其课指课a-bfloat ValuePolyn(Polyn head,int x)课函用于课入数课~课算返回多课式的课并x课函用于比课数和的指数int compare(Polyn a,Polyn b) ab、流程课3一元稀疏多课式课算器课入建立多课式并课出多课式课算多课式在x课的课课算a+b课算a-b课束1.4 课课分析1、课课分析2、行课果运1.5 源程序代课#include<stdio.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) free(p); else { Polynq1,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){q1->next=q2->next;free(q2);}}else{p->next=q2;q1->next=p; } } } Polyn CreatePolyn(Polyn head,int m) { int i; Polyn p;p=head=(Polyn)malloc(sizeof(struct Polynomial)); head->next=NULL;for(i=0;i<m;i++) { p=(Polyn)malloc(sizeof(struct Polynomial));课课入第课的系指数与数用空格隔课printf("%d ,:",i+1);scanf("%f %d",&p->coef,&p->expn); Insert(p,head); } return head; } 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; } while(q) { if(q->coef>0&&flag!=1) putchar('+'); if(q->coef!=1&&q->coef!=-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');else if(q->expn==1) putchar('X'); else printf("X^%d",q->expn); }if(q->coef==-1) { if(!q->expn) printf("-1"); else if(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; else if(!a||a->expn<b->expn)return -1; else return 0; } else if(!a&&b) return -1; else return1; }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); }return headc; }Polyn SubtractPolyn(Polyn pa,Polyn pb) {Polyn h=pb; Polyn p=pb->next; Polyn pd; while(p){ p->coef*=-1; p=p->next; } pd=AddPolyn(pa,h);for(p=h->next;p;p=p->next) p->coef*=-1; return pd;}float ValuePolyn(Polyn head,int x) {Polyn p; int i,t; floatsum=0;for(p=head->next;p;p=p->next){t=1;for(i=p->expn;i!=0;){if(i<0){t/=x;i++;} else{t*=x;i--;} } sum+=p->coef*t; }return sum; }Polyn MultiplyPolyn(Polyn pa,Polyn pb){ Polyn hf,pf; Polyn qa=pa->next; Polyn qb=pb->next;hf=(Polyn)malloc(sizeof(structPolynomial)); 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); } } return hf; }void main(){ int m,n,a,x,f,k=1; Polyn pa=0,pb=0,pc; while(k!=0){ 课课入的课数printf("a :"); scanf("%d",&m); pa=CreatePolyn(pa,m);课课入的课数printf("b :"); scanf("%d",&n); pb=CreatePolyn(pb,n);课出多课式课出多课式printf(" * 1:a 2:b \n");代入的课课算代入的课课算printf(" * 3:xa 4:xb\n");课出课出printf(" * 5:a+b 6:a-b\n");课出退出printf(" * 7:a*b 0:\n");课课课操作,while(a) { printf("\n "); scanf(" %d",&f); switch(f) { 多课式case 1: { printf("\na="); PrintPolyn(pa); break; }多课式case 2: { printf("\nb="); PrintPolyn(pb); break; }课入的课,case 3: { printf("xx="); scanf("%d",&x);课 printf("\n x=%da=%.3f\n",x,ValuePolyn(pa,x)); break; }课入的课,case 4: {printf("xx="); scanf("%d",&x);课 printf("\n x=%d b=%.3f\n",x,ValuePolyn(pb,x)); break; } case5:{ pc=AddPolyn(pa,pb); printf("\n a+b="); PrintPolyn(pc); break; } case 6:{ pc=SubtractPolyn(pa,pb);printf("\n a-b="); PrintPolyn(pc); break; }case 7:{ pc=MultiplyPolyn(pa,pb);printf("\na*b=");PrintPolyn(pc); break; }case 0:{ DestroyPolyn(pa); DestroyPolyn(pb); a=0; break; }您的课课课课~课重新课default: printf("\n !\n"); } } } }2 哈夫曼课/课课器2.1 述概本课程课课用于建立哈夫曼课~课其课行课课、课课以及打印。

一元稀疏多项式计算器实习报告[1]

一元稀疏多项式计算器实习报告[1]

一元稀疏多项式计算器实习报告[1]实习报告题目:设计一个一元稀疏多项式计算器班级: 姓名学号_________完成日期:__一、课程题目一元稀疏多项式计算器二、需求分析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利用链表实现队列的构造。

每次输入一项的系数和指数,可以输出构造的一元多项式3、测试数据:(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.三、概要设计1. 有序表的抽象数据类型定义为:ADT List{数据对象:D={ai | ai ∈R,i=1,2,…,n,n ≧0}数据关系:R1={| ai-1, a i ∈D, ai-1,基本操作:InitList()操作结果:构造一个空的有序表L 。

DestroyList(L)初始条件:有序表L 已存在。

元稀疏多项式计算器实验报告c编写,附源代码(1)

元稀疏多项式计算器实验报告c编写,附源代码(1)

元稀疏多项式计算器实验报告c编写,附源代码(1)实验报告:元稀疏多项式计算器引言:本次实验是运用C语言编写一个元稀疏多项式计算器,该计算器可以实现多项式的加法、减法、乘法、求导、积分、求值等操作。

本次实验旨在通过编写实践,加深对多项式计算的理解和程序设计能力。

一、设计思路及实现方法1.1 多项式的表示方式多项式可以用数组来表示,数组的下标表示多项式的幂次,数组的内容表示该幂次项的系数。

例如多项式:2x^4 + 3x^2 + 5可以表示为数组:{0,0,3,0,2,5}。

1.2 多项式的操作函数及实现方法本次实验实现了以下多项式操作函数:1)add(多项式加法):将两个多项式相加并返回结果多项式。

2)subtract(多项式减法):将两个多项式相减并返回结果多项式。

3)multiply(多项式乘法):将两个多项式相乘并返回结果多项式。

4)differential(求导):求一个多项式的导数并返回结果多项式。

5)integral(积分):对一个多项式进行积分并返回结果多项式。

6)evaluate(求值):给定一个值,计算多项式在该值处的值并返回结果。

以上操作函数的实现方法都是通过循环遍历数组,并运用相应的多项式计算公式来计算。

二、程序设计及实验结果2.1 程序设计本次实验采用C语言编写完成,主函数的框架如下:int main(int argc, char const *argv[]) {// 输入多项式各项系数和幂次// 调用各个多项式计算函数// 输出计算结果return 0;}2.2 实验结果本次实验的实验结果如下:1)将多项式2x^3 + 3x^2 + 5x + 2与多项式3x^3 - 2x^2 + 4相加:输入:2 3 5 2 3 -2 0 4输出:5x^3 + x^2 + 5x + 62)将多项式2x^3 + 3x^2 + 5x + 2与多项式3x^3 - 2x^2 + 4相减:输入:2 3 5 2 3 -2 0 4输出:-1x^3 + 5x^2 + 5x - 23)将多项式2x^3 + 3x^2 + 5x + 2与多项式3x^3 - 2x^2 + 4相乘:输入:2 3 5 2 3 -2 0 4输出:6x^6 + 5x^5 + 4x^4 + 4x^3 + 26x^2 + 14x + 84)求多项式2x^3 + 3x^2 + 5x + 2的导数:输入:2 3 5 2输出:6x^2 + 6x + 55)对多项式2x^3 + 3x^2 + 5x + 2进行积分:输入:2 3 5 2输出:0.5x^4 + 1x^3 + 2.5x^2 + 2x + 06)计算多项式2x^3 + 3x^2 + 5x + 2在x=3处的值:输入:2 3 5 2 3输出:59以上实验结果均能正确输出。

(2023)一元稀疏多项式计算器实验报告c编写,附源代码(一)

(2023)一元稀疏多项式计算器实验报告c编写,附源代码(一)

(2023)一元稀疏多项式计算器实验报告c编写,附源代码(一)实验报告:(2023)一元稀疏多项式计算器实验目的本实验旨在编写一款一元稀疏多项式计算器,实现对两个多项式的加、减、乘、求导、求值等操作。

实验环境•操作系统:Windows 10•开发工具:Visual Studio Code•编程语言:C实验过程1. 首先定义多项式的结构体typedef struct PolyTerm {int coef;// 系数unsigned int power;// 指数struct PolyTerm* next;// 下一项}PolyTerm;typedef struct Poly {int degree;// 多项式最高次项PolyTerm* head;// 首项指针}Poly;2. 实现多项式的输入与输出void inputPoly(Poly* poly);// 输入多项式void outputPoly(Poly* poly);// 输出多项式3. 实现多项式的加、减、乘操作Poly* addPoly(Poly* p1, Poly* p2);// 多项式加法Poly* subPoly(Poly* p1, Poly* p2);// 多项式减法Poly* multPoly(Poly* p1, Poly* p2);// 多项式乘法4. 实现多项式求导void derivative(Poly* poly);// 多项式求导5. 实现多项式求值int evaluate(Poly* poly,int x);// 多项式求值6. 主函数的实现主函数通过简单的菜单方式,实现用户输入选项,选择需要进行的操作。

实验结果通过对多项式加、减、乘、求导、求值等操作的实现,成功完成了一元稀疏多项式计算器的编写,实现了对多项式运算的基本掌握。

实验总结在本次实验中,我们通过C语言实现了一元稀疏多项式计算器,并体验了多项式运算的具体操作。

实验报告(实验二:一元稀疏多项式计算器)

实验报告(实验二:一元稀疏多项式计算器)

云南大学软件学院实验报告指导教师:朱艳萍 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、程序比较复杂,算法思想也很难理清,需要多加锻炼。

课程设计报告(一元稀疏矩阵计算器)

课程设计报告(一元稀疏矩阵计算器)

目录一、课程题目 (3)二、设计目的 (3)三、需求分析 (3)四、总体设计 (3)五、详细设计 (2)六、实现部分 (3)七、程序测试 (3)八、设计总结 (12)一、课程题目一元稀疏多项式计算器二、设计目的掌握稀疏矩阵的相关运算。

掌握广义表的操作。

三、需求分析一元稀疏多项式简单计算器的基本功能是:输入并建立多项式;输出多项式,输出形式为整数序列:n,c1,e1,,c2,e2 ……cn,en,其中n是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序排列。

多项式a和b相加,建立多项式a+b多项式a和b相减,建立多项式a-b四、总体设计创建两个类,把一个作为另一个的友元类!两个类分别是listnode和polynomial!创建一个链表,包括指数,次数以及下一个结点信息,然后利用冒泡排序法进行排序,排完之后输出多项式!最后一个环节就是进行多项式的最原始运算,即加减运算!其中运用的内容包括链表知识,冒泡排序的知识!五、详细设计类listnode中包含friend class polynomial、double coef、int exp、listnode *next!类polynomial包含poly(); void printpoly();void bubblesort();polynomial operator+(polynomial &p1); polynomial operator-(polynomial &p1);在这个程序设计中,为了实现多项式的运算必须首先创建两个多项式,存储多项式的存储结构是链表,其结构如下:else if(p->exp<q->exp){double m;int n;m=p->coef;p->coef=q->coef;q->coef=m;n=p->exp;p->exp=q->exp;q->exp=n;s=q;q=q->next;}再就是实现多项式的加减法运算,在加减法运算中为了实现处理,设p、q分别指向单链表的两个多项式,比较p、q结点的指数项,由此得到下列运算规则:①若p->exp<q->exp,则结点p所指的结点应是“和多项式”中的一项,令指针p后移。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

软件综合实习报告课题名称一元稀疏多项式计算器姓名何天从学号3110757101班级网络11-1班院系信息科学与工程学院指导老师陈基漓王宇农坚起止日期2013.6.3~2013.6.21一元稀疏多项式计算器1、需求分析1.1 一元稀疏多项式简单计算器的功能1.1.1输入并建立多项式(系数为浮点数、指数为整数);1.1.2 输出多项式,类数学表达式【选作内容,已实现】:c1x^e1+c2x^e2+………cnx^en,【共有n项】(其中ci和ei分别是第i项的系数和指数,n是多项式的项数,序列按指数降序排列)1.1.3多项式a和b相加,建立多项式a+b;1.1.4多项式a和b相减,建立多项式a-b;1.1.5计算多项式a+b、a-b在x处的值;【选作内容,已实现】1.1.6 求多项式a、b、a+b、a-b的导函数;【选作内容,已实现】1.1.7多项式a和b相乘,建立乘积多项式ab;【选作内容,已实现】1.1.8系数值为1的非零次项的输出形式中略去系数1。

【选作,已实现】1.2 设计思路1.2.1定义线性表的动态分配顺序存储结构;1.2.2建立多项式存储结构,定义指针*next;1.2.3利用链表实现队列的构造。

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

多项式显示的格式为:c1x^e1+c2x^e2+…+cnx^en, 【共有n项】1.3 设计思路分析要解决多项式相加,必须要有多项式,所以必须首先建立两个多项式,在运用尾插法建立两条单链表,以单链表LinkList p和LinkList h分别表示两个一元多项式a和b,a+b的求和运算等同于单链表的插入问题(将单链表LinkList p中的结点插入到单链表LinkList h中,【实际实现中,为了方便运算其它操作,创建LinkList pe来临时储存结果。

】【实现插入】为了实现处理,设p、q分别指向单链表LinkList a和LinkList b的当前项,比较p、q结点的指数项,由此得到下列运算规则:①.若p->index < q->index,则结点p所指的结点应是“和多项式”中的一项,令指针p后移。

②.若p->index = q->index,则将两个结点中的系数相加,当和不为0时修改结点p的系数。

③.若p->index >q->index,则结点q所指的结点应是“和多项式”中的一项,将结点q插入在结点p之前,且令指针q在原来的链表上后移。

【实现求导数】相当与先把系数与指数相乘,在把指数减1,就得导数。

【注意,而求a+b的导数则是先调用a+b的方法,但到a+b的值后,在调用导数方法。

a-b方法相似。

】【实现相乘】用两层循环,外层以a为基准,依次与内层b的不同项分别相乘。

相乘的原理是:系数相乘,指数相加。

【注意,每次执行内层时,首先让表头指向b的首元素。

】2、概要设计2.1为了实现上述程序功能,需要定义单链表的抽象数据类型:typedef struct Node {float coef; //系数int index; //指数struct Node *next; //定义指向下一个节点的名称。

}LinkList;2.2本程序包含9个函数:2.2.1、int main()【主函数】2.2.2、void Insert(LinkList *p,LinkList *h) 【插入函数】2.2.3、LinkList *Creat_L(LinkList *head,int m) 【创建链表函数】2.2.4、void PRintf(LinkList *L) 【输出函数】2.2.5、LinkList *ADDlist(LinkList *pa,LinkList *pb) 【求和函数】2.2.6、LinkList *MinusList(LinkList *pa,LinkList *pb)【减法函数】2.2.7、float ValueLinkList(LinkList *pc,float x) 【求值函数】2.2.8、LinkList *Deri(LinkList *pa)【求导函数】2.2.9、LinkList *Multiply(LinkList *a,LinkList *b) 【乘积函数】2.3各函数间关系如下(注:虚线表示非主函数之间调用)3.详细设计源代码:#include<iostream.h>#include<malloc.h>#include<stdio.h>#include<stdlib.h>//╞╪╪╪╪╪╪╪╪╪╪╪╪【定义链表】╪╪╪╪╪╪╪╪╪╪╪╪╪╪╪╪╡typedef struct Node //typedef把Node定义成struct node类型//定义链表,是一个结构体{ float coef; //系数int index; //指数struct Node *next; //定义指向下一个节点的名称。

//【指针域,指向下一个系数不为0的子项】}LinkList;//╞╪╪╪╪╪╪╪╪╪╪╪╪【插入函数】╪╪╪╪╪╪╪╪╪╪╪╪╪╪╪╪╡void Insert(LinkList *p,LinkList *h) //把节点p插入到链表h中{ LinkList *q1,*q2; //同步指针int flag=0; //定义一个结束标志q1=h;if(p->coef==0) //系数为0的话释放结点free(p);else{ if(q1->next==NULL) //第一次把头指针与第一个节点连接{ q1->next=p; }else{ q2=q1->next;while(flag==0) //查找插入位置,当flag=1时,结果{ if(p->index<q2->index) //判断链表的q2节点与当然要插入的p的index的值{ if(q2->next==NULL) //如果当前q2是链尾,则用【尾插法】,把p接到q2后面{ q2->next=p;flag=1; //flag=1,循环结束,完成插入}else //否则,由于不知道p2—>next的index的值与p的大小,所以移动q1、q2向后移动在判断【这里的判断,是重新循环的,即从新比较p与后面的q2的指数。

】{ q1=q2; //同步指针q2=q2->next; //使q1、q2保持一个节点的距离} }else if(p->index>q2->index)//如果p的指数大于q2,则用【头插法】,把p插到链头{ p->next=q2;q1->next=p;flag=1; }else //指数相同的项,将系数相加{ q2->coef=p->coef+q2->coef; //将指数相同的p、q2的系数相加,并赋给q2 if(q2->coef==0) //系数为0的话释放结点{ q1->next=q2->next;free(q2); }flag=1; //flag=1,循环结束,完成插入free(p); } } } }}//╞╪╪╪╪╪╪╪╪╪╪【创建链表函数】╪╪╪╪╪╪╪╪╪╪╪╪╪╪╪╪╡LinkList *Creat_L(LinkList *head,int m) //创建一个链表//(CreateLinklist),头指针为head、项数为m的一元多项式{ int i;LinkList *q;head=(LinkList *)malloc(sizeof(LinkList)); //申请一块大小为sizeof(LinkList)的内存。

【(LinkList *)的作用:malloc返回值类型是 void* ,而head类型是linklist* ,不同类型指针无法互相赋值,为了解决这个语法限制,所以进行强制类型转换。

malloc返回值类型是一个void *指针类型的地址,我们不知道该地址存放的是什么内容,不能访问它。

所以需要在前面加(LinkList*)把它转换成LinkList类型的指针,这样程序就知道它存放的是什么内容了,就可以正确访问了。

】head->next=NULL; //令头指针的下一个节点为空for(i=1;i<=m;i++) //按输入的项数作为循环次数{ q=(LinkList *)malloc(sizeof(LinkList)); //建立新结点以接收数据 q->next=NULL;printf("●请输入第%d项:",i);scanf("%fx^%d",&q->coef,&q->index); /输入和系数Insert(q,head); //调用Insert函数,插入结点}return head;}//╞╪╪╪╪╪╪╪╪╪╪╪╪╪【输出函数】╪╪╪╪╪╪╪╪╪╪╪╪╪╪╡void PRintf(LinkList *L){ LinkList *p,*q;int i=0; //项数记数标记p=L->next;q=L->next;if(p==NULL)//若多项式为空,输出0,不要执行下面的while语句。

【条件也可写为!p】(当p=0,!p 为1,条件成立,执行内语句,否则相反){ printf("0\n");return; }while(q) //当q不为null时,一直循环{ if(q->coef==1) //实现输出是,如果系数为1,则省略printf("x^");elseprintf("%gx^",q->coef); //输出当然q指向的系数printf("%d",q->index); //输出当然q指向的指数q=q->next; //循环语句,指向下一个结点if(q!=NULL) //作用:输出加号,连接各项式【条件也可写为p】{ printf("+"); }}while(p)//实现计算多项式的项数。

【不能用q,因为q在上面的while中已经指向尾部】{ p=p->next;i++; }printf("【共有%d项】",i); //输出总项数}//╞╪╪╪╪╪╪╪╪╪╪╪╪【求和函数】╪╪╪╪╪╪╪╪╪╪╪╪╪╪╪╪╡LinkList *ADDlist(LinkList *pa,LinkList *pb) //求解并建立多项式a+b,返回其头指针{ LinkList *pc,*pd,*pe;pe=(LinkList *)malloc(sizeof(LinkList)); //创建pe用来储存a+b的值pe->next=NULL;for(pa=pa->next;pa;pa=pa->next)//把pa的一个一个地值赋给pd,在一个一个地把pd插入到pe中{ pd=(LinkList *)malloc(sizeof(LinkList));pd->coef=pa->coef;pd->index=pa->index;pd->next=NULL;Insert(pd,pe); //调用Insert函数,一个一个地把pd插入到pe中}/************************************************************************** 说明:上面的代码,功能是创建一个链表,另外储存求和后和结果,防止pa,即a的内容被改写。

相关文档
最新文档