一元稀疏多项式的加法运算(数据结构实习)
一元稀疏多项计算器【加法和减法】

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:一元稀疏多项式加法运算[问题描述]设计一个求解一元稀疏多项式加法运算的程序。
[基本要求](1)输入并建立多项式。
(2)输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,…,c n,e n,其中n是多项式的项数,c i和e i分别是第i项的系数和指数,序列按指数降序排列。
(3)多项式a和b相加,建立多项式a+b[算法实现]#include<stdio.h>#include<stdlib.h>typedef struct Node{int cofe;//系数域int expn;//指数域struct Node *next;}LNode,*LinkList;void InitList(LinkList &L)//初始化{L=(LinkList)malloc(sizeof(LNode));if(!L)exit(0);L->next=NULL;}int Input(LinkList &L)//输入{LinkList p;int i=0;p=(LinkList)malloc(sizeof(LNode));L->next=p;printf("输入多项式的系数与指数,按“系数指数”格式,且指数按从小到大顺序输入,以(0 0)结束:\n");while(1){scanf("%d %d",&p->cofe,&p->expn);if((p->cofe)==0)break;p->next=(LinkList)malloc(sizeof(LNode));p=p->next;++i;}p->next=NULL;return i;}void Output(LinkList &L)//输出{LinkList p;p=L->next;printf("多项式为:\n");if((p->expn)==0)printf("%d",p->cofe);else if(p->expn==1)printf("%dx",p->cofe);else if((p->cofe)==1||(p->cofe)==-1){if((p->cofe)==1)printf("x^%d",p->expn);else if((p->cofe)==-1)printf("-x^%d",p->expn);}elseprintf("%dx^%d",p->cofe,p->expn);p=p->next;for(;(p->cofe!=0);p=p->next){if((p->expn==0)&&(p->cofe!=0)){if((p->cofe)>0)printf("+%d",p->cofe);else if((p->cofe)<0)printf("%d",p->cofe);}else if((p->expn==1)&&(p->cofe==1))printf("+x",p->cofe);else if((p->cofe)==1||(p->cofe)==-1){if((p->cofe)==1)printf("+x^%d",p->expn);else if((p->cofe)==-1)printf("-x^%d",p->expn);}else if((p->cofe)>0)printf("+%dx^%d",p->cofe,p->expn);else if((p->cofe)<0)printf("%dx^%d",p->cofe,p->expn);}printf("\n");}void Add(LinkList &L1,LinkList L2)//计算L1,L2的和,放入L1{LinkList p,q,per,r;//p为指向L1的指针,p2为指向L2的指针,per指向p的前驱,r 为中间变量int x;//存放和的结果p=L1->next;q=L2->next;per=L1;while((p!=NULL)&&(q!=NULL))if((p->expn)>(q->expn))//p的指数大于q的指数,将q插到p之前{r=q->next;q->next=p;//先让q的next指向p,并将q的next存入rper->next=q;per=q;q=r;//再让p的前驱的next指向q,此时,q就成为p 的前驱,所以令per=q,q(前驱)的next指向q原来的next}else if((p->expn)==(q->expn)){x=(p->cofe)+(q->cofe);//求和if(x!=0)//和不为0,代替原值,并将p做为先驱(为下次计算做准备){p->cofe=x;per=p;}else//和为0,释放p结点:将p前驱的next指向p的next,再释放p的空间即可{per->next=p->next;free(p);}p=per->next;r=q;q=q->next;free(r);//将q向后移一位}else if((p->expn)<(q->expn))//p的指数小于q的指数,将q插到p之后{per=p;p=p->next;}if(q!=NULL)//将q中多余的项(即指数在p中没有的)移入p的后面per->next=q;free(L2);//释放:L2}void main(){LinkList L1,L2;int i,j;printf("输入L1:");InitList(L1);i=Input(L1);printf("共%d项\n",i);Output(L1);printf("\n");printf("输入L2:");InitList(L2);j=Input(L2);printf("共%d项\n",j);Output(L2);printf("\n");Add(L1,L2);printf("L1与L2的和");Output(L1);printf("\n");}[实验结果]。
一元稀疏多项式的加法运算(数据结构实习)

实习一线性表、栈和队列及其应用——一元稀疏多项式的加法运算【问题描述】设计一个实现一元稀疏多项式相加运算的演示程序。
【基本要求】(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指针;然后定义两个指针,第一个指针指向第一个多项式,第二个指针指向第二个多项式。
数据结构实习报告——一元稀疏多项式运算器的设计

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

实验一 一元稀疏多项式的表示及加法运算一、 需求分析1.程序的功能: ● 多项式以指数递增的顺序输入。
● 设计的数据结构应有利于表示任意一元稀释多项式。
● 输出原始多项式及运算结果。
● 附加功能:乱序输入计算表达式结果 2. 输入输出要求: ● 多项式以指数递增的方式输入 ● 输出原始多项式及其结果 3.测试数据(1)1785937x x x +++ , 879228x x x -+ (2)0 , 879228x x x -+(3)87109228x x x -+ , -1附加功能测试数据:(4) 53658672x x x x +--,268x x --二、 概要设计●所用数据结构定义:struc t Term{ //多项式结点的定义float coef; //系数 int exp;//指数Term * link; Term(float c,int e,Term * next=NULL){coef=c;exp=e;link=next;} Term *Inser t Afte r (float c,int e); Term & opera t or -=(Term & t){if (t.exp==exp) coef-=t.coef;retur n *this ;} Term & opera t or +=(Term & t){if (t.exp==exp) coef+=t.coef;retur n *this ;} frien d ostre a m & opera t or <<(ostre a m &,const Term&); };class Polyn o mal{//多项式的类定义 publi c : Polyn o mal(){ //构造函数,建立空链表first =new Term(0,-1);first->link=first;//必须链成环}~Polyno mal(){makeEm pty();}Polyno mal(Polyno mal & R); //复制构造函数Polyno mal & operat or=(constPolyno mal & R); //重载复制赋值操作符void insert(floatc,int e,Polyno mal& R);//对于二项式进行插入排序 Polyno mal sort();//对于多项式进行排序Term * getHea d() const{return first;}void makeEm pty();privat e:Term * first;friend ostrea m & operat or<<(ostrea m &,constPolyno mal&);friend istrea m & operat or>>(istrea m &,Polyno mal&);friend Polyno mal operat or+(Polyno mal&,Polyno mal&);};主程序的流程及各模块之间的层次关系:1)主程序流程2)模块之间层次关系三、详细设计1、插入一个结点Term* Term::Insert After(floatc,int e){//在当前由this指针指示的项(即调用此函数的对象)后面插入一个新项link=new Term(c,e,link); //创建一个新结点,自动链接return link; //插入到this结点后面2、重载各运算符(1)Polyno mal & Polyno mal::operat or =(constPolyno mal & R){makeEm pty(); //先清空first=new Term(0,-1);Term *destpt r=first,*srcptr=R.first->link;while(srcptr!=R.first){destpt r->Insert After(srcptr->coef,srcptr->exp);srcptr=srcptr->link;destpt r=destpt r->link;}destpt r->link=first;//必须链成环return *this;}#伪代码清空;动态创建节点f irst;创建节点指针*destpt r指向fi rst,创建节点指针*srcptr指向R.first->link;WHILE(R链未遍历结束)将R链表中的结点一次插入到fir st之后;ENDWHI LE将*destpt r连成环;结束(2)istrea m& operat or>>(istrea m& in,Polyno mal& x){Term *rear=x.first;int e;floatc; //定义尾指针rearwhile(1){cout<<"输入:系数,指数(以、-1结束):"<<endl;in>>c>>e;if(c==0&&e==-1)break;//用e小于控制输入结束rear=rear->Insert After(c,e); //链接到rear所指结点后}return in;}(3)ostrea m & operat or<<(ostrea m& out,constPolyno mal & x){ //输出到附加头结点的多项式链表xTerm *curren t=x.first->link;cout<<"The polyno mal is:"<<endl;bool h=true;while(curren t!=x.first){if(h==false&¤ t->coef>0.0)out<<"+";h=false;if(curren t->coef==0){out<<"0";curren t=curren t->link;}else{out<<*curren t; //调用term类的重载操作"<<"curren t=curren t->link;}}out<<endl;return out;}#伪代码创建指针*curren t指向当前节点x.first->link;设置标志位hWHILE<遍历多项式>IF<标志位h为假,当前指向节点指数为0>打印符号+;改变标志位;ELSE打印该节点;指向下一个节点;ENDIFENDWHI LE(4)Polyno mal operat or+(Polyno mal& A,Polyno mal& B){Term *pa,*pb,*pc,*p,*last;floattemp;Polyno mal C;pc=C.first;pa=A.first->link;pb=B.first->link;while(pa!=A.first&&pb!=B.first){ //两两比较if(pa->exp==pb->exp){ //对应项指数相等temp=pa->coef+pb->coef; //系数相加if(fabs(temp)!=0)pc=pc->Insert After(temp,pa->exp);pa=pa->link ;pb=pb->link;}else if(pa->exp<pb->exp){pc=pc->Insert After(pa->coef,pa->exp); //pa指数小pa=pa->link;}else{pc=pc->Insert After (pb->coef,pb->exp);pb=pb->link;} //pb指数小,加入ah 链}if(pa!=A.first){p=pa;last=A.first;}else{p=pb;last=B.first;}while(p!=last){pc=pc->Insert After (p->coef,p->exp );p=p->link;}return C;}#伪代码*Pa=二项式a的当前节点;*pb=二项式b的当前节点;新建二项式c;WHILE<遍历二项式>IF<pa,pb的指数相等>IF<指数之和不为0>系数相加后将插入节点到c尾部;ENDIF比较a,b的下一个节点ELSEIF<pa的指数小于pb的>将pa的当前节点复制到c尾部;Pa后移;ELSE将Pb的当前节点复制到c尾部;Pb后移;ENDIFENDWHI LEIF<pa,pb中某一多项式未遍历结束>将未遍历空的那一个所在的二项式剩余部分复制到c尾部;ENDIF返回合成多项式3、排序算法(1)Polyno mal Polyno mal::sort(){Polyno mal R;Term *p=first;p=p->link;while(p!=first){insert(p->coef,p->exp,R);p=p->link;}return R;}(2)void Polyno mal::insert(floatc, int e, Polyno mal &R){Term *q=R.first,*p=R.first->link, *r;if(p==R.first) {q->link=new Term(c,e);//c为空q->link->link=R.first;}else{while(p!=R.first){if(p->exp==e)//指数相等{p->coef+=c;if(p->coef!=0)break;if(p->coef==0){q->link=p->link;r=p;p=p->link;delete r;break;}}else if(p->exp>e)//e小于当前结点的指数{q->link=new Term(c,e);q=q->link;q->link=p;break ;}else { p=p->link; q=q->link;}} if (p==R.first ) //e 大于R 中每一项的指数,插在表尾 { q->link=new Term(c,e); q->link->link=p;}}}四、 调试分析1、调试中的问题(1)在测试数据一时,出现带有常数项的多项式,常数项被构造为一次项,例如多项式1785937x x x +++被输出为1785937x x x x +++解决办法:在重载运算符+中,当pa 的指数小时,将程序由{pc=pc->Inser t Afte r (pa->coef,pb->exp);pb=pb->link;}改为{pc=pc->Inser t Afte r (pb->coef,pb->exp);pb=pb->link;}即可; (2)在调试问题二的过程中,出现的0被程序自动忽略,不能打印使得输出结果为879228x x x -++ 解决办法:在重载输出运算符的程序模块中添加: if(curre n t->coef==0){ out<<"0"; curre n t=curre n t->link; }即可保证程序的输出正常,但是是以作8792280x x x -++为输出的。
一元稀疏多项式加法运算

一元稀疏多项式加法运算一、需求分析1.程序的功能设计一个简单的一元稀疏多项式加法运算器。
一元稀疏多项式简单计算器的基本功能包括:(1).按照指数升序次序,输入并建立多项式A与B。
(2).计算多项式A与B的和,即建立多项式A+B。
(3).按照指数升序次序,输出多项式A、B、A+B。
2.输入输出的要求输入多项式时可以按任意次序输入各项的数据,不必按指数有序;在算法中实现建立按指数有序的多项式。
多项式的输出形式采用图形界面,通过调整指数应该出现的坐标位置来表示指数形式,如X+2X2-3X100的形式。
3.测试数据(1).(x+3x6-8.6x11)+(6-3x6+21x9)=6+x+21x9-8.6x11(2).(3x-3-x+4.1x2-1.2x9)+(―3x―3-5.1x2 +7.8x12)=-x-x2-1.2x9+7.8x12(3).(x+x3)+(―x―x3)=0(4).(x+x100)+(x100+x200)=(x+2x100+x200)(5).(x+x2+x3)+0=x+x2+x3二、概要设计1. 输入多项式,建立多项式链表首先创建带头结点的单链表;然后按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项:“系数、指数对”,每输入一个子项就建立一个结点,并将其插入到多项式链表的表尾,如此重复,直至遇到输入结束标志的时候停止,最后生成按指数递增有序的链表。
2. 多项式相加多项式加法规则:对于两个多项式中指数相同的子项,其系数相加,若系数的和非零,则构成“和多项式”中的一项;对于指数不同的项,直接构成“和多项式”中的一项。
3. 多项式的输出可以在文本界面下,采用类似于数学表达式的方式输出多项式,如多项式A可显示为:A=3+6X∧3-2X∧8+12X∧20三、详细设计1. 数据类型定义可描述如下:typedef struct pnode{float coef; /*系数域*/int exp; /*指数域*/struct pnode *next; /*指针域,指向下一个系数不为的子项*/}PolyNode, *PolyLink;PolyLink A,B,C; /*单链表存储的多项式A、B、C*/2.输入多项式,建立多项式链表首先创建带头结点的单链表;然后按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项:“系数、指数对”,必须按照升序输入,每输入一个子项就建立一个结点,并将其插入到多项式链表的表尾,如此重复,直至遇到输入结束标志的时候停止,最后生成按指数递增有序的链表。
数据结构实习报告——一元稀疏多项式运算器的设计

数据结构实习报告班级 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。
多项式链表生成的函数:函数的返回值应该为定义的结构体类型,不需要设置参数。
函数内部,需要有多项式指数和系数的输入,直至输入的系数为零时结束,将每一对输入的指数和系数保存到新结点中,并将结点插入到链表中。
数据结构实验多项式加法

数据结构实验报告实验名称:多项式加减法学号:19姓名:林强实验日期:一、实验目的通过实现多项式的加减法,对链表有更深入的了解二、实验具体内容1、实验题目1:(1)题目设计一个一元稀疏多项式简单的加减法计算器实现要求:一元稀疏多项式简单计算器的基本功能是:(1)输入并建立多项式:8517A+x+x=;+73x9)(x798xB-+x=822x)(x(2)输出多项式(3)多项式A和B相加,建立多项式C=A+B,并输出相加的结果多项式C(4)选作:多项式A和B相减,建立多项式C=A-B,并输出相加的结果多项式D (2)分析1:本程序的任务是实现两个多项式的加法其中多项式的系数为浮点型,指数为整数,输出的结果也为系数和指数。
(1)输入的形式和输入值的范围:输入多项式的系数a和未知数X的指数b,当a和b都为零时,输入结束。
输入值的范围:a为实数,b为整数。
(2)输出形式:输出多项式的系数和多项式未知数X的指数即(a,b)形式。
(3)程序所能达到的功能,实现两个多项式的加法,并输出最后的结果2:整个程序运行期间实行动态创建节点,一边输入数据,一边创建节点当将全部数据输入到单链表中后再调用多项式加法这个函数,并一边实现多项式的相加,一边释放节点,有效防止了在程序反复运行过程中可能出现系统空间不够分配的现象(3)实验代码typedef int Status;#define OVERFLOW -1#define null 0typedef struct Lnode{float coef; //存储项系数int expn;//存储项指数struct Lnode *next;}Lnode,*LinkList;typedef LinkList polynomial;Status InitList_L(LinkList &L) {//初始化头节点L=(LinkList)malloc(sizeof(Lnode));if(!L)return(-1);L->next=null;return 1;}void AddPolyn(polynomial pa, polynomial pb){ //实现两个多项式相加的算法float x;polynomial qa;polynomial qb;polynomial s;polynomial u;qa=pa->next; qb=pb->next; s=pa;while(qa&&qb){if(qa->expn<qb->expn){s=qa;qa=qa->next;}else if(qa->expn==qb->expn){x=qa->coef+qb->coef; if(x!=0){qa->coef=x;s=qa;qa=qa->next;u=qb;qb=qb->next;free(u);}else{s->next=qa->next;free(qa);qa=s->next;u=qb;qb=qb->next;free(u);}}else if(qa->expn>qb->expn){u=qb->next;s->next=qb;s=qb;qb->next=qa;qb=u;}}if(qb)qa->next=qb;free(pb);void main(){float a;int b;polynomial L1;polynomial L2;LinkList q;LinkList p;LinkList m;LinkList n;InitList_L(L1);q=L1;InitList_L(L2);p=L2;cout<<"请输入数据:"<<endl;for(;;){cin>>a;cin>>b;if(a==0&&b==0)break;m=new Lnode;m->coef=a;m->expn=b;q->next=m;q=m;q->next=null;}//循环输入第一个多项式的系数与指数for(;;){cin>>a;cin>>b;if(a==0&&b==0)break;n=new Lnode;n->coef=a;n->expn=b;p->next=n;p=n;p->next=null;}//循环输入第二个多项式的系数与指数AddPolyn(L1,L2);//调用多项式相加的算法while((L1->next)!=null){cout<<"("<<L1->next->coef<<","<<L1->next->expn<<")"<<" ";L1=L1->next;}//输出计算结果}三、实验小结通过编写多项加法这个程序,我将自己所学到的创建链表,初始化链表和多项式加法算法都应用了一次,这使我们不仅仅只是理论化的学习书本上的知识,而是将学习到的理论知识应用到实际的操作中来增强我们的实际操作能力,这使我增加了实际操作经验,也使我通过实际操作来认识到自己在程序编写上的不足从而增强了我的实际编写程序的能力。
数据结构实验报告-一元多项式的加法运算

问题描述:设Pn (x)和Qm(x)分别两个一元多项式。
试编写程序实现一元多项式的加法运算。
一、需求分析:1、本程序需要基于线性表的基本操作来实现一元多项式的加法,也可以用数组实现。
2、两个多项式都有键盘输入相应的系数和指数。
3、//第一个多项式为9x15+ 7x8+5x3+3x输入4 //表示第一个多项式的项数9, 15(回车) //表示9x157, 8 (回车)5, 3 (回车)3, 1 (回车)输出9x^15+ 7x^8+5x^3+3x^1//第二个多项式为 -7x8+6x3+2输入3 //表示第二个多项式的项数6, 3(回车) //表示9x15-7, 8(回车)2, 0 (回车)输出-7x^8+ 6x^3+2x^0求和结果9x^15+11x^3+3x^1+ 2x^0二、概要设计:抽象数据类型为实现上述程序的功能,应以整数存储用户的输入,以及计算的结果。
实现多项式的运算,利用数组的方式需开辟一个二维数组,利用链表的方式须创造两个链表。
算法的基本思想数组实现:定义一个结构体数组,p存储系数,q存储指数。
分别输出两次输入的多项式。
将两次输入的多项式的指数按从大到小的顺序进行排列,同时相应的系数要进行交换。
输出时如果进行判断。
如果当前该项与下一项的的系数相同,将两项系数相加后输出,并跳过下一项。
如果不相等,直接输出。
输出时需注意的问题:当系数为0时,该项不输出当系数为负数时,不要再在前面输出+。
程序的流程程序由三个模块组成:输入模块:完成两个多项式的输入。
处理模块:将多项式按其指数大小进行排列。
输出模块:输出合并后的多项式。
三、详细设计算法的具体步骤:数组方法:struct code{int p,q;}a[1000],b[1000];//结构体数组,可以用二维数组代//替for(i=0;i<n;i++){for(j=i+1;j<n;j++){if(a[j].q>a[i].q) {temp=a[j].q;//指数排序a[j].q=a[i].q;a[i].q=temp;temp=a[j].p;//系数跟着变化a[j].p=a[i].p;a[i].p=temp;}}//对输入的指数进行排序,相应的系数跟着变化cout<<a[0].p<<"x^"<<a[0].q; //先输出第一项if(a[i].p>0)else if(a[i].p<0)cout<<a[i].p<<"x^"<<a[i].q;cout<<'+'<<a[i].p<<"x^"<<a[i].q;//完成运算符和其他项的输//出,然后类似于上面,对第二个多项式进行相应的操作。
一元稀疏多项式计算器实验报告(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表示指向下一个多项式结点的指针)。
一元多项式相加 数据结构实验报告

南昌航空大学实验报告课程名称:数据结构实验名称:实验二线性表的链式存储结构班级:080611 学生姓名:学号:08指导教师评定:签名:题目:设计并实现以下算法:给出用单链表存储多项式的结构,利用后接法生成多项式的单链表结构,实现两个多项式相加的运算,并就地逆置相加后的多项式链式。
一、需求分析1.用户可以根据自己的需求分别输入两个一元多项式,并且能够实现输入的一元多项式的显示。
2.能够完成两个一元多项式的相加功能,而且还能显示相加后的逆置的一元多项式。
3.程序执行的命令包括:(1)构造链表A (2)构造链表B (3)两个链表的相加(4)求链表的长度(5)打印(显示)已有的链表(6)将已相加的链表进行逆序排列二、概要设计⒈为实现上述算法,需要线性表的抽象数据类型:ADT Polynomial {数据对象:D={a i:|a i∈TermSet,i=1…n,n≥0TermSet 中的每个元素包含一个表示系数的实数和表示指数的整数} 数据关系:R1={<a i-1,a i>|a i-1,a i∈D,且a i-1中的指数值< a i中的指数值i=2,…n≥0}基本操作:initlink(& L)操作结果:构造一个空的链表L。
Creatlink(&L,n)操作结果:输入n项的系数和指数,建立一个非空的一元多项式L。
LinkLength(L)初始条件:链表L已经存在。
操作结果:返回一元多项式L中的项数。
Displaylink(L)初始条件:链表L已经存在。
操作结果:打印输出一元多项式L。
Addpolyn(A,B,&C)初始条件:一元多项式A和B已存在。
操作结果:完成多项式相加运算,即:C=A+B,并且带回C。
subtracypolyn(&La,&Lb,)初始条件:一元多项式La和Lb已存在。
操作结果:完成多项式的相减运算La=La+Lb,并且销毁多项式Lb。
数据结构一元稀疏多项式

要求完成如下功能:(1)输入并建立多项式——creatpolyn()(2)输出多项式,输出形式为整数序列,序列按指数升序排列——printpolyn() (3)多项式a和b相加,建立多项式a+b,输出相加的多项式——addpolyn() (4)多项式a和b相减,建立多项式a-b,输出相减的多项式——subpolyn()用带表头结点的单链表存储多项式。
课程设计学生姓名:学号:专业班级:课程名称:数据结构学年学期:指导教师:目录1.需求分析说明 (1)2.概要设计说明 (3)3.详细设计说明 (5)4.调试分析 (10)5.用户使用说明 (11)6.课程设计总结 (12)7.测试结果 (13)8.参考书目 (16)9. 附录 (17)1 需求分析说明1.程序所能达到的功能是(1)输入并建立多项式——creatpolyn()(2)输出多项式,输出形式为整数序列,序列按指数升序排列——printpolyn() (3)多项式a和b相加,建立多项式a+b,输出相加的多项式——addpolyn()(4)多项式a和b相减,建立多项式a-b,输出相减的多项式——subpolyn()用带表头结点的单链表存储多项式。
2.输入的形式和输入值的范围:本系统要输入的数据主要是有多项式中每项的系数和指数,可以把它们定义为整形数据,既可以为整数也可以为非负整数,即有符号的整形数据,由于整形数据在内存里占用两个字节,所以它的取值范围为-32768—32767。
其次还有就是选择功能时,要输入的功能号,它们是字符型数据,取值范围是ASS||表中的字符。
例如输入的格式如下:请输入a的项数:3请输入第一项的系数与指数:2,1请输入第二项的系数和指数:5,8请输入第三项的系数和指数:-3.1,11请输入b的项数:3请输入第一项的系数和指数:7,0请输入第一项的系数和指数:5,8请输入第三项的系数和指数:11,9******************************************************************多项式操作程序* A:输出多项式a B:输出多项式b ** C:输出a+b D:输出a-b ** F:退出程序 *********************************************************************请选择操作:Ca+b=2x+5x8-3.1x11+7-5x8+11x9请选择操作:Da-b=2x+5x8-3.1x11-7+5x8-11x93.输出的形式:本系统要输出的是把创建好的第一个多项式和第二个多项式按指数升序排列,并把进行运算后的结果也按指数升序排列输出,输出形式如上面所示。
代码:天津理工大学数据结构实验——一元稀疏多项式的加减

#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct Node{int xishu;int zhishu;struct Node *pNext;}NODE, *PNODE;PNODE create_list(void);PNODE compute(PNODE,PNODE);void traverse_list(PNODE);int length_list(PNODE);void delsame(PNODE);void sort_list(PNODE);void main(){int a;PNODE pHead1=NULL;PNODE pHead2=NULL;PNODE pHead3=NULL;pHead1= create_list();pHead2= create_list();sort_list(pHead1);sort_list(pHead2);delsame(pHead1);delsame(pHead2);printf("请选择运算方法(1、加法;2、减法)");scanf("%d",&a);pHead3= compute(a,pHead1,pHead2);traverse_list(pHead1);traverse_list(pHead2);traverse_list(pHead3);}PNODE create_list(void){int len;int i;int val1;int val2;PNODE pNew;PNODE pHead;PNODE pTail;pHead=(PNODE)malloc(sizeof(NODE));pTail=pHead;pTail->pNext=NULL;if(NULL== pHead){printf("分配失败\n");exit(-1);}printf("项数:");scanf("%d",&len);for(i=0;i<len;++i){printf("系数,指数%d:",i+1);scanf("%d,%d",&val1,&val2);pNew=(PNODE)malloc(sizeof(NODE));if(NULL== pNew){printf("分配失败\n");exit(-1);}pNew->xishu=val1;pNew->zhishu=val2;pTail->pNext=pNew;pNew->pNext=NULL;pTail=pNew;}return pHead;}void traverse_list(PNODE pHead){PNODE p;p=pHead->pNext;while (NULL != p){if(p->zhishu==0 && p->xishu!=0){printf("%d",p->xishu);p=p->pNext;}else if(p->xishu==1){printf("X^%d",p->zhishu);p=p->pNext;}else if(p->xishu==0)p=p->pNext;else{printf("%dX^%d",p->xishu,p->zhishu);p=p->pNext;}if(p!=NULL&&p->xishu>=0)printf(" +");elseprintf(" ");}printf("\n");return;}PNODE compute(int a,PNODE pHead1,PNODE pHead2) {PNODE p,q,pNew,pHead,pTail,r;int i,len=0;pHead=(PNODE)malloc(sizeof(NODE));pTail=pHead;pTail->pNext=NULL;q=pHead2->pNext;while(p!=NULL&&q!=NULL){if(p->zhishu==q->zhishu){if((p->xishu+q->xishu)!=0){pNew=(PNODE)malloc(sizeof(NODE));if(a==1)pNew->xishu=p->xishu+q->xishu;else if(a==2)pNew->xishu=p->xishu-q->xishu;pNew->zhishu=p->zhishu;pTail->pNext=pNew;pNew->pNext=NULL;pTail=pNew;}p=p->pNext;q=q->pNext;}else if(p->zhishu>q->zhishu){pNew=(PNODE)malloc(sizeof(NODE));pNew->xishu=q->xishu;pNew->zhishu=q->zhishu;pTail->pNext=pNew;pNew->pNext=NULL;pTail=pNew;q=q->pNext;}else if(p->zhishu<q->zhishu){pNew=(PNODE)malloc(sizeof(NODE));pNew->xishu=p->xishu;pNew->zhishu=p->zhishu;pTail->pNext=pNew;pNew->pNext=NULL;pTail=pNew;}}if(p==NULL&&q!=NULL){r=q;while(NULL!=r){len++;r=r->pNext;}for(i=0;i<len;i++){pNew=(PNODE)malloc(sizeof(NODE));pNew->xishu=q->xishu;pNew->zhishu=q->zhishu;pTail->pNext=pNew;pNew->pNext=NULL;pTail=pNew;q=q->pNext;}return pHead;}else if(p!=NULL&&q==NULL){r=p;while(NULL!=r){len++;r=r->pNext;}for(i=0;i<len;i++){pNew=(PNODE)malloc(sizeof(NODE));pNew->xishu=p->xishu;pNew->zhishu=p->zhishu;pTail->pNext=pNew;pNew->pNext=NULL;pTail=pNew;}return pHead; }elsereturn pHead;}void sort_list(PNODE pHead){int i,j,t,k;PNODE p,q;int len;len=length_list(pHead);for(i=0,p=pHead->pNext;i<len-1;++i,p=p->pNext) {for(j=i+1,q=p->pNext;j<len;++j,q=q->pNext){if(p->zhishu > q->zhishu){t=p->zhishu;k=p->xishu;p->zhishu=q->zhishu;p->xishu=q->xishu;q->zhishu=t;q->xishu=k;}}}return;}void delsame(PNODE pHead){int a;PNODE p,q,r;p=pHead->pNext;while(p!=NULL){a=p->zhishu;loop:for(q=p;q->pNext!=NULL;q=q->pNext) {if(q->pNext->zhishu==a){r=q->pNext;q->xishu=q->xishu+r->xishu;q->pNext=r->pNext;free(r);goto loop;}}p=p->pNext;}}int length_list(PNODE pHead){int len=0;PNODE p=pHead;while(NULL!=p->pNext){len++;p=p->pNext;}return len;}。
一元稀疏多项式的表示及加法运算

一元稀疏多项式的表示及加法运算一、需求分析1.程序的功能(1).按照指数升序顺序,输入并建立多项式M与N。
(2).计算多项式M与N的和(3).输出多项式M、N、M+N。
2.输入输出的要求多项式按指数递增顺序输入;设计的数据结构应有利于表示任意一元稀释多项式;多项式的输出采用数学多项式的表示形式。
3.测试数据(1)7+3x+9x8+5x17, 8x+22x7-9x8(2) 0, 8x+22x7-9x8(3)8x10+22x7-9x8 , -1二、概要设计1.通过建立链表来实现多项式的输入在多项式输入之前,要先定义一个带有头结点的单链表,紧接着以指数递增的顺序输入多项式中系数不为零的项,其中每一项对应一个结点,每项对应的结点依次插入直至遇到结束标志,这样结完成了多项式的输入。
2. 两个多项式相加两个多项式中如果指数相同则系数相加,构成和多项式的一项;如果指数不同,则直接构成和多项式的一项。
3. 多项式的输出采用数学多项式的表达方式三、详细设计1.定义数据类型:typedef struct pnode{float coef; //系数int exp; //指数struct pnode *next; //指针,指向下一个系数不为的子项}PNode, *PLink;PLink M,N,P; //多项式M、N、P2.通过建立链表来实现多项式的输入在多项式输入之前,要先定义一个带有头结点的单链表,先输入多项式项数,紧接着以指数递增的顺序输入多项式中系数不为零的项,其中每一项对应一个结点,每项对应的结点依次插入,当项数达到时结束,这样完成了多项式的输入。
PNode *createList(PNode *p) //建立多项式链表{float a;int b;int c;int d;p=new PNode;PNode *nNode;PNode *kNode=p;if(p==NULL){return NULL;}else{p->next=NULL;cout<<"请输入多项式项数"<<endl;cin>>d;cout<<"请输入系数和指数"<<endl;for(c=0;c<d;c++){cin>>a>>b;nNode=new PNode;if(nNode==NULL){return p;}nNode->coef=a;nNode->exp=b;kNode->next=nNode;kNode=nNode;}nNode->next=NULL;}return p;}3. 两个多项式相加两个多项式中如果指数相同则系数相加,构成和多项式的一项;如果指数不同,则直接构成和多项式的一项。
数据结构实验-一元多项式的加法运算

一元多项式加法一、实验目的通过实现多项式加法,对链表有更深入的了解二、实验内容问题描述:设计一个一元稀疏多项式简单的加法计算器实现要求:一元稀疏多项式简单计算器的基本功能是:(1)输入并建立多项式:1785937)(x x x x A +++=;879228)(x x x x B -+=(2)输出多项式(3)多项式A 和B 相加,建立多项式C =A +B ,并输出相加的结果多项式C(4)选作:多项式A 和B 相减,建立多项式C =A -B ,并输出相减的结果多项式D 方法说明:(1)多项式的输入与存储用带表头结点的单链表存储多项式,链表中的每个节点分别存储多项式各项的系数和指数,即每从键盘输入多项式的一对数(系数,指数),可对应建立链表的一个结点。
每个节点的结构为:建立两个链表,其中pa 和pb 分别为它们的头指针:pb结果链表Pa(或者是Pc)Pc(2)多项式数据类型的定义struct tagNode{float coef;int exp;struct tagNode *next;typedef struct tagNode Node;typedef struct tagNode* pNode;(3)主要算法①创建两个链表,分别存放多项式1和多项式2,这两个链表中的节点是按指数降序或者升序排列的②多项式相加,下面给出多项式相加的部分实现/*下面的函数实现两个多项式的相加,要相加的链表分别由pa和pb指向(其中,pa,pb都是分配了空间的头结点)。
相加的结果直接由pa指向的链表保存,即是在pa链表中添加或删除(当系数因为相加为0的情况下)一些结点,构成结果。
相加的链表中指数按从小到大的顺序排列好的,是升序链表。
*/void add_poly(Node *pa,Node *pb){Node *p=pa->pNext;//链表1,将来的结果也放在此Node *q=pb->pNext;//链表2Node *pre=pa;Node *u;//临时用float x;while (p!=NULL && q!=NULL)//当两个链表都不为空{if (p->exp<q->exp)//比较链表1跟链表2当前节点的指数大小,链表1也是存放结果的地方{pre=p;p=p->pNext;//p指向要比较的下一个结点。
实习一 线性表及其应用 (题目:一元稀疏多项式的加法运算 )

实习一线性表及其应用(题目:一元稀疏多项式的加法运算)一、需求分析1.输入并建立两个多项式;2.多项式a与b相加,建立和多项式c;3.输出多项式abc。
输出格式:比如多项式a为:A(x)=c1xe1+c2xe2+…+ cmxem,其中,ci和ei分别为第i项的系数和指数,且各项按指数的升幂排列,即0≤e1<e2<…<em。
多项式bc类似输出。
4测试数据(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)实习一线性表及其应用题目:一元稀疏多项式的加法运算实习时间:2012/9/20.10.12一、需求分析1.输入并建立两个多项式;2.多项式a与b相加,建立和多项式c;3.输出多项式abc。
输出格式:比如多项式a为:A(x)=c1xe1+c2xe2+…+ cmxem,其中,ci和ei分别为第i项的系数和指数,且各项按指数的升幂排列,即0≤e1<e2<…<em。
多项式bc类似输出。
4测试数据(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)存储结构用带头结点的单链表存储多项式。
三个多项式链表中都只存储非零系数项。
若多项式a与b中指数相等的两项相加后,系数为零,则在和多项式c中不存储该指数项。
(2)主要算法基本思想按照链表的基本操作,初始化三个链表,在两个链表中按指数由小到大分别插入a和b的多项式(系数和指数),将多项式a的链表复制给多项式c的链表,再调用求和函数(b的链表和c的链表相加),将求和的结果插入到c的链表中(作为多项式c)最后输出多项式a,b,c三个多项式。
一元多项式的加减求导运算算法(数据结构算法)

if(expo1==0)
{
i=1;
cout<<coef1;
}
else if(expo1==1)
{
i=1;
if(coef1==1)
cout<<"X";
else if(coef1==-1)
cout<<"-X";
else
cout<<coef1<<"X";
}
else
{
i=1;
if(coef1==1) cout<<"XA"<<expo1;
temp=h;
h->next =NULL;〃头结点
cout<<"多项式"<<o<<"的项数:";cin»num;
for(i nt i=1;i<=nu m;i++)
{
cout<<"请输入第"<<i<<"项"<<endl; cout<<"系数:";
cin> >coef1;
cout<<"指数:";
cin> >expo1; data=new polyno de; data->coef=coef1;
(2)计算多项式A与B的和,即建立多项式A+B
(3)按照指数升序次序,输出多项式AB、A+B
(4)计算多项式A与B的差,即建立多项式A-B;
(5)计算多项式A的导函数A,。
一元稀疏多项式的加法运算[整理版]
![一元稀疏多项式的加法运算[整理版]](https://img.taocdn.com/s3/m/21ea7811e97101f69e3143323968011ca300f797.png)
一元稀疏多项式的加法运算一、需求分析1、要求用带头结点的单链表存储两个多项式,然后进行多项式加法运算,存入另一个单链表中。
2、从键盘输入多项式a的项数,然后分别输入每项的系数和指数;类此输入多项式b。
3、测试数据:(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)、主要算法基本思想先输入多项式的项数j,建立一个循环,分别进行链表的插入操作,插入时就是建立空结点存入系数和指数后再插入链表中。
在插入的同时要比较与原链表中指数项的大小,从而建立由低次方到高次方的存储链表。
在多项式相加时,将多项式a先存入多项式c中,此时c中的指数是升序排列,再将b中系数与指数存入,存入的方法是:指数比较寻找插入结点,指数相等时,进行系数相加操作,其他是建立一个空结点,存入b的系数与指数载插入c中。
至于输入过程,多项式a、b、c均可输出,由于存储的按指数升序存的,所以不必进行查找了,只需要按一个个结点顺序输出即可。
#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct{float coef;int expn;}count;typedef struct Node{float coef;//系数int expn;//指数struct Node *next;}LinkList;void ListInitiate(LinkList **head)//链表初始化{if((*head=(LinkList *)malloc(sizeof(LinkList)))==NULL)exit(0);(*head)->next=NULL;}void ListInsert(LinkList *head,count L)//链表插入操作{LinkList *p,*q;p=head;while(p->next!=NULL)//从系数由小到大排序的角度寻找插入结点{if(p->next->expn>L.expn)break;p=p->next;}if((q=(LinkList *)malloc(sizeof(LinkList)))==NULL)exit(0);q->coef=L.coef;q->expn=L.expn;q->next=p->next;p->next=q;}int print(LinkList *head)//输出{LinkList *p;p=head->next;if(p==NULL)//多项式为零时直接输出{printf("0\n");exit(0);}while(p->coef==1&&p->expn>0)//指数不为零时系数为1时的输出{printf("x^%d",p->expn);p=p->next;if(p==NULL)return 0;else printf("+");}while(p->next){printf("%gx^%d",p->coef,p->expn);p=p->next;if(p->coef>0)printf("+");}printf("%gx^%d",p->coef,p->expn);return 1;}void Add(LinkList *a,LinkList *b,LinkList *c)//多项式a、b相加等于多项式c {LinkList *p,*q,*s,*k;s=c;p=a->next;while(p!=NULL)//先将a存入c中{if((q=(LinkList *)malloc(sizeof(LinkList)))==NULL)exit(0);q->coef=p->coef;q->expn=p->expn;q->next=NULL;c->next=q;c=c->next;p=p->next;}c=s;p=b->next;while(p!=NULL)//将b存入c中{while((c->next!=NULL)&&(p->expn)>((c->next)->expn))//寻找插入结点{c=c->next;}if(c->next==NULL)//从最后插入{if((q=(LinkList *)malloc(sizeof(LinkList)))==NULL)exit(0);q->coef=p->coef;q->expn=p->expn;q->next=c->next;c->next=q;}else if(p->expn==c->next->expn) //指数相等时系数相加{s=c;c=c->next;c->coef=c->coef+p->coef;if(c->coef==0){k=c;c=s;c->next=c->next->next;free(k);}}else if(p->expn>c->expn&&c->next!=NULL)//普通插入{if((q=(LinkList *)malloc(sizeof(LinkList)))==NULL)exit(0);q->coef=p->coef;q->expn=p->expn;q->next=c->next;c->next=q;}p=p->next;}}void main()//主函数{LinkList *a,*b,*c;count L;int i,j;ListInitiate(&a);ListInitiate(&b);ListInitiate(&c);printf("请输入a的项数:");scanf("%d",&j);for(i=0;i<j;i++){printf("输入a的第%d项系数:",i+1);scanf("%g",&L.coef);printf("输入a的第%d项指数:",i+1);scanf("%d",&L.expn);ListInsert(a,L);}printf("输入b的项数:");scanf("%d",&j);for(i=0;i<j;i++){printf("输入b的第%d项系数:",i+1);scanf("%g",&L.coef);printf("输入b的第%d项指数:",i+1);scanf("%d",&L.expn);ListInsert(b,L);}Add(a,b,c);printf("输入的多项式a为:\n");print(a);printf("\n");printf("输入的多项式b为:\n");print(b);printf("\n");printf("多项式a+b=c为:\n");print(c);printf("\n");}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实习一线性表、栈和队列及其应用——一元稀疏多项式的加法运算【问题描述】设计一个实现一元稀疏多项式相加运算的演示程序。
【基本要求】(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指针;然后定义两个指针,第一个指针指向第一个多项式,第二个指针指向第二个多项式。
然后比较两个多项式第一项的指数的大小,如果两个多项式的指数相同,则将他们的系数相加,指数不变;如果不同则比较他们指数的大小,并将指数小的放在第一项。
然后指向指数小的那一项的指针后移,它的指数去和刚才必然的那一项的指向相比较……直至两个多项式相加完。
其中如果某二项的系数相加后为0,则该项不输出。
相加时的程序如下:pnode * add(pnode *heada,pnode *headb) //多项式相加//{pnode *headc,*p,*q,*s,*r;float x;p=heada; //p指针指向第一个多项式的第一项// q=headb; //q指针指向第二个多项式的第一项// headc=(pnode *)malloc(sizeof(pnode)); //为两式相加的结果c申请内存//r=headc; //r指向结果//while(p!=NULL&&q!=NULL) //判断两个式子都合法//{if(p->e==q->e ) //指数相同时系数相加//{x=p->c+q->c;if(x!=0){s=(pnode *)malloc(sizeof(pnode));s->c=x;s->e=p->e;r->next=s;r=s;}q=q->next;p=p->next; //指向多项式的下一项//}else if(p->e>q->e) //多项式按升幂排序//{s=(pnode *)malloc(sizeof(pnode));s->c=q->c;s->e=q->e;r->next=s;r=s;q=q->next;else{s=(pnode *)malloc(sizeof(pnode));s->c=p->c;s->e=p->e;r->next=s;r=s;p=p->next;}}while(p!=NULL) //第一个式子不为0时的相加法则// {s=(pnode *)malloc(sizeof(pnode));s->c=p->c;s->e=p->e;r->next=s;r=s;p=p->next;}while(q!=NULL) //第二个式子不为0的相加法则// {s=(pnode *)malloc(sizeof(pnode));s->c=q->c;s->e=q->e;r->next=s;r=s;q=q->next;}r->next=NULL;headc=headc->next; //c的指向依次指向下一项//return headc; //返回两式相加的结果//}2.设计表示(1)函数调用关系图main->create()->create()->add()->display()->display()->display()(2)函数规格接口说明pnode * creat() /*此函数时用来创建多项式的*/void display(pnode *head) /*head为每个多项式的头指针*/pnode * add(pnode *heada,pnode *headb) /* heada headb为两个多项式的头指针*/(1)根据提示输入多项式每一项的指数和系数,结束该多项式的输入时系数和指数都应该输入0。
(2)可以输入任何指数型式的多项式。
4.详细设计(主要算法的细化)输出函数如下:void display(pnode *head) //多项式输出//{pnode *p;int one_time=1; p=head;while(p!=NULL) //判断头结点非空//{if(one_time==1){if(p->e==0) //当指数为0即X^o时只需要输出系数c// printf("%f",p->c);else if(p->c==1) //系数为1时输出X^ei//printf("x^%d",p->e);else if(p->c==-1 ) //系数为-1时输出-X^ei//printf("-x^%d",p->e);else if(p->c>0) //系数大于0时系数前面带“+”// printf("+%fx^%d",p->c,p->e);else if(p->c<0) //系数为副时原样输出//printf("%fx^%d",p->c,p->e);one_time=0;}else{if(p->e==0){if(p->c!=0)printf("+%f",p->c);}else if(p->c==1) //系数为1时输出X^ei//printf("+x^%d",p->e);else if(p->c==-1 ) //系数为-1时输出-X^ei//printf("-x^%d",p->e);else if(p->c>0) //系数大于0时系数前面带“+”printf("+%fx^%d",p->c,p->e);else if(p->c<0) //系数为副时原样输出//;printf("%fx^%d",p->c,p->e)}p=p->next;}printf("\n");}主函数如下:void main(){pnode * a,*b,*c; //定义三个多项式//printf("input the first:\n"); //输入第一个多项式//a=creat(); //调用创建函数,创建第一个多项式// printf("input the second:\n"); //输入第二个多项式//b=creat(); //调用创建函数,创建第二个多项式// c=add(a,b); //调用相加函数//printf("the first:");display(a); //输出第一个多项式//printf("the second:");display(b); //输出第二个多项式//printf("sum is:");display(c); //输出两多项式相加的结果//}相加部分见算法设计部分。
三.调试分析1.调试遇到的主要问题以及解决方案:a刚写程序时输出时没有分系数大于0和小于0分,输出的形式都为printf(“%fX^%d”, p->c,p->e ),结果两个多项式相加时当某相邻两项时,中间的加号没有表示出来。
所以我就将系数分为大于0和小于0来分,输出形式为if(p->c>0)printf("+%fx^%d",p->c,p->e);else if(p->c<0)printf("%fx^%d",p->c,p->e);b 刚开始多项式输入时没有按升幂的形式输入,结果运行的结果怎么都不对,然后将它按升幂的形式输入后就可以了。
c 刚开始时没有考虑结束多项式的输入时该则么弄,结果运行时一直都在输入第一个多项式,怎么都结束不了,直到将结束位的系数和指数都设置为0时才解决了这个问题。
2.时间和空间复杂度的分析:时间复杂度为:O(n)空间复杂度为:O(n)3 改进设想A 由于两个多项式的某两项相加为0时是不输出数的,所以当两个多项式相加为0时,结果什么都不输出为空值,一直想办法改进,却没有什么结果,所以想在这方面改进一下;B 由于多项式的系数为正时,输出的形式中带有一个“+”,所以当多项式的第一项的系数为正值时总会带有一个“+”,觉得很别扭。
但如果输出形式中不带“+”,结果中两个不同项之间有没有“+”,与偶以很苦恼。