桂林理工大学-软件综合实习【一元稀疏多项式计算器】何天从
一元稀疏多项式的加法运算数据结构实习

实习一线性表、栈和队列及其应用——一元稀疏多项式的加法运算【问题描述】设计一个实现一元稀疏多项式相加运算的演示程序。
【基本要求】(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一元稀疏多项式计算器

(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一元稀疏多项式计算器-课程设计实验报告

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功能模块图为实现上述程序功能,用带表头结点的单链表存储多项式。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 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的内容被改写。