实验一一元稀疏多项式表示及加法运算.docx

实验一一元稀疏多项式表示及加法运算.docx

《实验一一元稀疏多项式表示及加法运算.docx》由会员分享，可在线阅读，更多相关《实验一一元稀疏多项式表示及加法运算.docx（22页珍藏版）》请在冰豆网上搜索。

实验一一元稀疏多项式表示及加法运算

实验一一元稀疏多项式的表示及加法运算

一、需求分析

1.程序的功能:

●多项式以指数递增的顺序输入。

●设计的数据结构应有利于表示任意一元稀释多项式。

●输出原始多项式及运算结果。

●附加功能：

乱序输入计算表达式结果

2.输入输出要求：

●多项式以指数递增的方式输入

●输出原始多项式及其结果

3.测试数据

（1>

（2>0,

（3>

-1

附加功能测试数据：

（4>

二、概要设计

●所用数据结构定义：

structTerm{//多项式结点的定义

floatcoef。

//系数

intexp。

//指数

Term*link。

Term（floatc,inte,Term*next=NULL>{coef=c。

exp=e。

link=next。

}

Term*InsertAfter（floatc,inte>。

Term&operator-=（Term&t>{

if（t.exp==exp>coef-=t.coef。

return*this。

}

Term&operator+=（Term&t>{

if（t.exp==exp>coef+=t.coef。

return*this。

}

friendostream&operator<<（ostream&,constTerm&>。

}。

classPolynomal{//多项式的类定义

public:

Polynomal（>{//构造函数，建立空链表

first=newTerm（0,-1>。

first->link=first。

//必须链成环

}

~Polynomal（>{makeEmpty（>。

}

Polynomal（Polynomal&R>。

//复制构造函数

Polynomal&operator=（constPolynomal&R>。

//重载复制赋值操作符

voidinsert（floatc,inte,Polynomal&R>。

//对于二项式进行插入排序

Polynomalsort（>。

//对于多项式进行排序

Term*getHead（>const{returnfirst。

}

voidmakeEmpty（>。

private:

Term*first。

friendostream&operator<<（ostream&,constPolynomal&>。

friendistream&operator>>（istream&,Polynomal&>。

friendPolynomaloperator+（Polynomal&,Polynomal&>。

}。

●主程序的流程及各模块之间的层次关系：

1）主程序流程

2）模块之间层次关系

三、详细设计

1、插入一个结点

Term*Term:

:

InsertAfter（floatc,inte>{

//在当前由this指针指示的项（即调用此函数的对象>后面插入一个新项

link=newTerm（c,e,link>。

//创建一个新结点，自动链接

returnlink。

//插入到this结点后面

2、重载各运算符

<1）Polynomal&Polynomal:

:

operator=（constPolynomal&R>{

makeEmpty（>。

//先清空

first=newTerm（0,-1>。

Term*destptr=first,*srcptr=R.first->link。

while（srcptr!

=R.first>{

destptr->InsertAfter（srcptr->coef,srcptr->exp>。

srcptr=srcptr->link。

destptr=destptr->link。

}

destptr->link=first。

//必须链成环

return*this。

}

#伪代码

清空；

动态创建节点first；

创建节点指针*destptr指向first，创建节点指针*srcptr指向R.first->link；

WHILE

将R链表中的结点一次插入到first之后；

ENDWHILE

将*destptr连成环；

结束

<2）istream&operator>>（istream&in,Polynomal&x>{

Term*rear=x.first。

inte。

floatc。

//定义尾指针rear

while（1>{

cout<<"输入：

系数,指数<以、-1结束）:

"<

in>>c>>e。

if（c==0&&e==-1>break。

//用e小于控制输入结束

rear=rear->InsertAfter（c,e>。

//链接到rear所指结点后

}

returnin。

}

<3）ostream&operator<<（ostream&out,constPolynomal&x>{//输出到附加头结点的多项式链表x

Term*current=x.first->link。

cout<<"Thepolynomalis:

"<

boolh=true。

while（current!

=x.first>{

if（h==false&¤t->coef>0.0>out<<"+"。

h=false。

if（current->coef==0>{

out<<"0"。

current=current->link。

}

else{

out<<*current。

//调用term类的重载操作"<<"

current=current->link。

}

}

out<

returnout。

}

#伪代码

创建指针*current指向当前节点x.first->link；

设置标志位h

WHILE<遍历多项式>

IF<标志位h为假，当前指向节点指数为0>

打印符号+；

改变标志位；

ELSE

打印该节点；

指向下一个节点；

ENDIF

ENDWHILE

<4）Polynomaloperator+（Polynomal&A,Polynomal&B>{

Term*pa,*pb,*pc,*p,*last。

floattemp。

PolynomalC。

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->InsertAfter（temp,pa->exp>。

pa=pa->link。

pb=pb->link。

}

elseif（pa->expexp>{pc=pc->InsertAfter（pa->coef,pa->exp>。

//pa指数小

pa=pa->link。

}

else{pc=pc->InsertAfter（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->InsertAfter（p->coef,p->exp>。

p=p->link。

}

returnC。

}

#伪代码

*Pa=二项式a的当前节点。

*pb=二项式b的当前节点。

新建二项式c；

WHILE<遍历二项式>

IF

IF<指数之和不为0>

系数相加后将插入节点到c尾部；

ENDIF

比较a,b的下一个节点

ELSEIF

将pa的当前节点复制到c尾部；

Pa后移；

ELSE

将Pb的当前节点复制到c尾部；

Pb后移；

ENDIF

ENDWHILE

IF

将未遍历空的那一个所在的二项式剩余部分复制到c尾部；

ENDIF

返回合成多项式

3、排序算法

<1）PolynomalPolynomal:

:

sort（>{

PolynomalR。

Term*p=first。

p=p->link。

while（p!

=first>{

insert（p->coef,p->exp,R>。

p=p->link。

}

returnR。

}

<2）voidPolynomal:

:

insert（floatc,inte,Polynomal&R>{

Term*q=R.first,*p=R.first->link,*r。

if（p==R.first>{

q->link=newTerm（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。

deleter。

break。

}

}

elseif（p->exp>e>//e小于当前结点的指数

{

q->link=newTerm（c,e>。

q=q->link。

q->link=p。

break。

}

else

{

p=p->link。

q=q->link。

}

}

if（p==R.first>//e大于R中每一项的指数，插在表尾

{

q->link=newTerm（c,e>。

q->link->link=p。

}

}

}

四、调试分析

1、调试中的问题

<1）在测试数据一时，出现带有常数项的多项式，常数项被构造为一次项，例如多项式

被输出为

解决办法：

在重载运算符+中，当pa的指数小时，将程序由{pc=pc->InsertAfter（pa->coef,pb->exp>。

pb=pb->link。

}改为{pc=pc->InsertAfter（pb->coef,pb->exp>。

pb=pb->link。

}即可；

<2）在调试问题二的过程中，出现的0被程序自动忽略，不能打印使得输出结果为

解决办法：

在重载输出运算符的程序模块中添加：

if（current->coef==0>{

out<<"0"。

current=current->link。

}

即可保证程序的输出正常，但是是以

作为输出的。

<3）由于程序的数据结构构造成一种环形链表，因而在编程侧时候比单链表更易出错，采取画图的方式容易解决问题。

2、分析算法的时间复杂度和空间复杂度

本实验所涉及算法基本采用顺序遍历方式，因而时间复杂度为o（m+n>，

空间复杂度为o（m+n>。

五、使用说明及测试结果

按照程序提示，依次输入多项式的各项，系数与指数以Enter隔开，整个多项式输入以0、-1结束。

如下图所示：

1、测试数据一

2、测试数据二

3、测试数据三

4、测试数据四

六、源程序带注释

#include

#include

usingnamespacestd。

structTerm{//多项式结点的定义

floatcoef。

//系数

intexp。

//指数

Term*link。

Term（floatc,inte,Term*next=NULL>{coef=c。

exp=e。

link=next。

}

Term*InsertAfter（floatc,inte>。

Term&operator-=（Term&t>{

if（t.exp==exp>coef-=t.coef。

return*this。

}

Term&operator+=（Term&t>{

if（t.exp==exp>coef+=t.coef。

return*this。

}

friendostream&operator<<（ostream&,constTerm&>。

}。

classPolynomal{//多项式的类定义

public:

Polynomal（>{//构造函数，建立空链表

first=newTerm（0,-1>。

first->link=first。

//必须链成环

}

~Polynomal（>{makeEmpty（>。

}

Polynomal（Polynomal&R>。

//复制构造函数

Polynomal&operator=（constPolynomal&R>。

//重载复制赋值操作符

voidinsert（floatc,inte,Polynomal&R>。

//对于二项式进行插入排序

Polynomalsort（>。

//对于多项式进行排序

Term*getHead（>const{returnfirst。

}

voidmakeEmpty（>。

private:

Term*first。

friendostream&operator<<（ostream&,constPolynomal&>。

friendistream&operator>>（istream&,Polynomal&>。

friendPolynomaloperator+（Polynomal&,Polynomal&>。

}。

Term*Term:

:

InsertAfter（floatc,inte>{

//在当前由this指针指示的项（即调用此函数的对象>后面插入一个新项

link=newTerm（c,e,link>。

//创建一个新结点，自动链接

returnlink。

//插入到this结点后面

}

ostream&operator<<（ostream&out,constTerm&x>{//Term的友元函数：

输出一个项X的内容到输出流out中

if（x.coef==0.0>returnout。

//0系数项不输出

out<

switch（x.exp>{

case0:

break。

case1:

out<<"X"。

break。

default:

out<<"X^"<

break。

}

returnout。

}

voidPolynomal:

:

insert（floatc,inte,Polynomal&R>{

Term*q=R.first,*p=R.first->link,*r。

if（p==R.first>{

q->link=newTerm（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。

deleter。

break。

}

}

elseif（p->exp>e>//e小于当前结点的指数

{

q->link=newTerm（c,e>。

q=q->link。

q->link=p。

break。

}

else

{

p=p->link。

q=q->link。

}

}

if（p==R.first>//e大于R中每一项的指数，插在表尾

{

q->link=newTerm（c,e>。

q->link->link=p。

}

}

}

PolynomalPolynomal:

:

sort（>{

PolynomalR。

Term*p=first。

p=p->link。

while（p!

=first>{

insert（p->coef,p->exp,R>。

p=p->link。

}

returnR。

}

Polynomal:

:

Polynomal（Polynomal&R>{//复制构造函数：

用已有多项式初始化当前多项式对象

first=newTerm（0,-1>。

Term*destptr=first,*srcptr=R.first->link。

while（srcptr!

=R.first>{

destptr->InsertAfter（srcptr->coef,srcptr->exp>。

//在destptr所指结点后插入一新结点，再让destptr指到这个新结点

srcptr=srcptr->link。

destptr=destptr->link。

}

destptr->link=first。

//必须链成环

}

Polynomal&Polynomal:

:

operator=（constPolynomal&R>{

makeEmpty（>。

//先清空

first=newTerm（0,-1>。

Term*destptr=first,*srcptr=R.first->link。

while（srcptr!

=R.first>{

destptr->InsertAfter（srcptr->coef,srcptr->exp>。

srcptr=srcptr->link。

destptr=destptr->link。

}

destptr->link=first。

//必须链成环

return*this。

}

voidPolynomal:

:

makeEmpty（>{

Term*q。

while（first->link!

=first>{

q=first->link。

first->link=q->link。

deleteq。

}

}

istream&operator>>（istream&in,Polynomal&x>{

Term*rear=x.first。

inte。

floatc。

//定义尾指针rear

while（1>{

cout<<"输入：

系数,指数<以、-1结束）:

"<

in>>c>>e。

if（c==0&&e==-1>break。

//用e小于控制输入结束

rear=rear->InsertAfter（c,e>。

//链接到rear所指结点后

}

returnin。

}

ostream&operator<<（ostream&out,constPolynomal&x>{//输出到附加头结点的多项式链表x

Term*current=x.first->link。

cout<<"Thepolynomalis:

"<

boolh=true。

while（current!

=x.first>{

if（h==false&¤t->coef>0.0>out<<"+"。

h=false。

if（current->coef==0>{

out<<"0"。

current=current->link。

}

else{

out<<*current。

//调用term类的重载操作"<<"

current=current->link。

}

}

out<

returnout。

}

Polynomaloperator+（Polynomal&A,Polynomal&B>{

Term*pa,*pb,*pc,*p,*last。

floattemp。

PolynomalC。

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->InsertAfter（temp,pa->exp>。

pa=pa->link。

pb=pb->link。

}

elseif（pa->expexp>{pc=pc->InsertAfter（pa->coef,pa->exp>。

//pa指数小

pa=pa->link。

}

else{pc=pc->InsertAfter（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->InsertAfter（p->coef,p->exp>。

p=p->link。

}

returnC。

}

intmain（>{

PolynomalA,B。

cout<<"请输入多项式:

f（x>:

"<

cin>>A。

cout<<"请输入多项式:

g（x>:

"<

cin>>B。

cout<<"进行插入排序后的多项式"<

PolynomalA1=A.sort（>。

PolynomalB1=B.sort（>。

PolynomalC（A1>。

//将A1赋值给C

cout<<"f（x>="<

cout<<"g（x>="<

cout<<"C按f（x>构造后得到：

C="<

C=A1+B1。

cout<<"C=f（x>+g（x>"<

return0。

}