一元多项式求和问题的研究与实现

一元多项式求和问题的研究与实现

学生姓名：指导老师：

摘要在数学上，一个一元多项式可按升幂表示为：A(x)=a0+a1x+a2x2+……+anxn，它由n+1个系数唯一确定，一元多项式求和实质上是合并同类项的过程。在实际应用中，多项式的指数可能很高且变化很大，在表示多项式的线性表中就会存在很多零元素。因此，采用单链表来存储一个一元多项式的每一个非零项的系数和指数，即每一个非零项对应单链表中的一个结点，且单链表按指数递增有序排列，就可实现两个一元多项式求和问题。程序通过调试运行，能基本达到设计要求，解决问题。

关键词数据结构；一元多项式；单链表；结点

1 引言

一个一元多项式可按升幂表示为：A(x)=a0+a1x+a2x2+……+a n x n，它由n+1个系数唯一确定。因此，可以用一个线性表(a0，a1，a2，……，an)来表示，每一项的指数i隐含在其系数ai的序号里。若有A(x)= a0+a1x+a2x2+……+a n x n和B(x)=b0+b1x+b2x2+……+b m x m，一元多项式求和也就是求A(x)=A(x)+B(x)，这实质上是合并同类项的过程。

1.1 设计目的

设计合理数据结构表示一元多项式，并设计高效算法实现两个一元多项式相加。

1.2 设计要求

本课程设计要求用C++实现两个一元多项式的求和问题，用带头结点的单链表村存储多项式。基本功能要求如下：

1．输入并建立多项式，输入形式为整数序列n，x1，y1，x2，y2，……，x n，y n。其中n是多项式的项数，x i和y i分别是第i项的系数和指数。

2．输出多项式，按指数升序排列。

3．多项式A(x)和B(x)相加，建立多项式A(x)+B(x)，输出相加的多项式，形式为类数学表达式。

2 需求分析

2.1 输入形式和输入值的范围

从键盘依次输入两个多项式的项数，系数和指数。系数为任意整数，项数和指数为大于等于0的整数。

2.2 输出形式

从屏幕输出，显示用户输入的多项式，并显示两多项式相加后的多项式和值。2.3 时间性能分析

所谓时间性能是指实现基于某种存储结构的基本操作（即算法）的时间复杂度。

像取出线形表中第i个元素这样的按位置随机访问的操作，使用顺序表更快一些，时间性能为O(1)；相比之下，单链表中按位置访问只能从表头开始依次向后扫描，直到找到那个特定的位置，所需要的平均时间为O(n)。

在单链表中进行插入和删除操作不需要移动元素，在给出指向单链表中某个合适位置的指针后，插入和删除操作所需的时间仅为O(1)；而顺序表进行插入和删除操作需移动表长一半的元素，需要的平均时间为O(n)。

作为一般规律，若线性表需频繁查找却很少进行插入和删除操作，或其操作和“数据元素在线性表中的位置”密切相关时，宜采用顺序表作为存储结构；若线性表需频繁进行插入和删除操作，则宜采用单链表作为存储结构。

对于一元多项式求和问题，由于在实际应用中，多项式的指数可能很高且变化很大，一个较好的存储方法是只存非零元素。这样，一个一元多项式的每一个非零项可由系数和指数唯一表示。例如，S(x)=5+10x30+90x100就可以用线性表((5,0),(10,30)，(90,100))来表示。

如果采用顺序表存储，对于指数相差很多的两个一元多项式，相加会改变多项式的系数和指数。若相加的某两项的指数不等，则将两项分别加在结果中，将引起顺序表的插入；若某两项的指数相等，则系数相加，若相加结果为零，将引起顺序表的删除。因此采用顺序表可以实现两个一元多项相加，但并不可取。因此，经过分析，在时间性能比较上适宜采用单链表存储，则每一个非零项对应单链表中的一个结点，且单链表应按指数递增有序排列。

2.4 空间性能分析

所谓空间性能是指某种存储结构所占用的存储空间的大小。

如果数据域占据的空间较小，则指针的结构性开销就占去了整个结点的大部分，因而从结点的存储密度上讲，顺序表的存储空间利用率较高。由于顺序表需要预分配一定长度的存储空间，如果事先不知道线性表的大致长度，则有可能对存储空间预分配得过大，致使存储空间得不到充分利用，造成浪费。若估计得过小，又将发生上溢而造成存储空间的再分配；而单链表不需要为其预分配空间，只要有内存空间可以分配，单链表中的元素个数就没有限制。

在此问题中，一个多项式虽然是由一个包括系数和指数的线性表唯一确定的，可是在实际应用中，多项式的指数往往很高且变化很大，项数也不确定，在线性表中，元素变化较大或者未知时，最好使用单链表实现。

3 概要设计

3.1 数据结构设计

为了实现任意多项式的加法，通过以上的时间性能和空间性能分析，选择单链表的结构体，结点结构如图3.1所示。

图3.1 一元多项式链表的结点结构

其中，valuea：系数域，存放非零项的系数；

valueb：指数域，存放非零项的指数；

next：指针域，存放指向下一结点的指针。

3.2 程序模块设计

根据以上对该一元多项式求和问题的功能要求和需求分析，到如图3.2所示的程序流程图。

图3.2 程序流程图

4 详细设计

4.1 菜单设计

简单明了的主菜单是程序成功运行的首要条件。在菜单函数中，调用了函数menuupdown()，该函数用来显示十五次短划线，用作菜单分隔符，使菜单清晰明了，易操作。其中主要的输出语句如下：

cout<<"\t\t\t┃\t\t\t\t┃"<

cout<<"\t\t\t┃\t1.输入一元多项式。\t┃"<

cout<<"\t\t\t┃\t2.输出一元多项式。\t┃"<

cout<<"\t\t\t┃\t3.两多项式相加。\t┃"<

cout<<"\t\t\t┃\t4.退出。\t\t┃"<

cout<<"\t\t\t┃\t\t\t\t┃"<

cout<<"\t\t\t";

cout<<"┗";

4.2 主模块设计

该课程设计的主模块就是解决求和问题。为运算方便，采用带头结点的单链表。先举例分析两个多项式求和的执行过程。

设两个工作指针p和q，分别指向两个单链表的开始结点。两个多项式求和实质上是对结点p的指数域和结点q的指数域进行比较，这会出现下列三种情况：

(1)若p->valuebvalueb，则结点p应为结果中的一个结点，将指针p后移。

示意如图4.1。

图4.1 第一种情况示意图

(2)若p->valueb>q->valueb，则结点q应为结果中的一个结点，将q插入到第一个单链表中结点p之前，再将指针q后移。示意如图4.2。

图4.2 第二种情况示意图

(3)若p->valueb=q->valueb，则p与q所指为同类项，将q的系数加到p的系数上。若相加结果不为0，则将指针p后移，删除结点q；若相加结果为0，则表明结果中无此项，删除结点p和结点q，并将指针p和指针q分别后移。示意如图4.3所示。

(a)相加系数不为零

(b)相加系数为零

图4.3 第三种情况示意图

算法用伪代码描述如下：

1.工作指针p、q初始化；

2.while（p存在且q存在）执行下列三种情形之一

2.1 如果p->valuebvalueb，则指针p后移;

2.2 如果p->valueb>q->valueb，则

2.2.1 将结点q插入到结点p之前；

2.2.2 指针q指向原指结点的下一个结点；

2.3 如果p->valueb=q->valueb，则

2.3.1 p->valuea=p->valuea+q->valuea；

2.3.2 如果p->valuea==0，则执行下列操作，否则，指针p后移;

2.3.2.1 删除结点p；

2.3.2.2 使指针p指向它原指结点的下一个结点；

2.3.3 删除结点q；

2.3.4 使指针q指向它原指结点的下一个结点；

3.如果q不为空，将结点q链接在第一个单链表的后面；

上述伪代码描述的算法还有一个问题：将结点q插到结点p之前和将结点p删除需要知道结点p的前驱结点的地址；将结点q删除也需要知道结点q的前驱结点的地址。所以，在每个单链表中应设两个工作指针。

4.3 类定义

1．用单链表存储多项式每一非零项，为该单链表建立item，其类定义如下：

class item

{

private:

double valuea;

double valueb;

double corp;

item * next;

public:

item(double ax,double bx) { }

item( ) {

cin>>valuea>>valueb;

corp=0; next=NULL;

}

friend class operate;

};

在item类中，提供了如下成员函数：

(1) 函数声明：item(double ax,double bx) { }；

完成的功能：有参数构造函数，主要用于生成临时一元多项式的项和头指针。

(2) 函数声明：item( ) {

cin>>valuea>>valueb;

corp=0;

next=NULL;

}

完成的功能：无参数构造函数，主要用于生成一元多项式时使用。

(3) 函数声明：friend class operate；

完成的功能：为了能访问到类item的私有成员，operate应指定为item类的友元类。

2．为操作建立operate，其类定义如下：

class operate

{

private:

item * head,* record;

public:

operate();

item * gethead();

void creat();

item* addsame(item* atemp);

void show(item * show);

operate operator + (operate lasts);

};

在operate类中，提供了如下成员函数：

(1) 函数声明：operate( )；

完成的功能：无参数构造函数，用于生成链表头。

(2) 函数声明：item * gethead( )；

完成的功能：用于取出多项式的头地址。

(3) 函数声明：void creat( )；

完成的功能：声明creat函数，用于生成链表，即输入多项式。

(4) 函数声明：item* addsame(item* atemp)；

完成的功能：该函数主要将单个多项式中相同的项相加。

(5) 函数声明：void show(item * show)；

完成的功能：显示多项式。

(6) 函数声明：operate operator + (operate lasts)；

完成的功能：重载+符号用于多项式相加。

5 测试与分析

5.1 操作平台

运行该程序的操作平台分硬件和软件两方面。

1．硬件要求：此程序需在一台PC机上运行，拥有INTER或AMD的CPU即可。

2．软件要求：本程序能在Windows 9X/2000/XP/2003下运行。

5.2 错误调试分析

1．Call of non-function：调用尚未定义的函数，而正在被使用的函数则没有定义，是由于不正确的函数声明或者是函数名拼写错误所导致的。

2．Cannot modify a constant object：不能修改一个常量对象，对定义为常量的对象进行不合法的操作都将引起该错误。

3．Argument list syntax error：参数表出现语法错误，函数调用的一组参数之间没有以逗号隔开，并以一个右括号结束。

4．Extra parameter in call：调用函数时出现多余函数，调用一个函数时，其实际参数的个数多余函数定义中的参数个数。

5．For statement missing ）for：后面缺少“)”，在编制程序的时候，编译程序会发现控制表达式后面缺少右括号。

5.3 程序运行测试

1．菜单界面测试。开始程序执行，显示菜单功能界面，如图5.1。

图5.1 操作菜单截图

2．测试第一组数据(带同类项的两多项式相加)。按操作提示分别输入两多项式：

(1)2x3+5x2；

(2)4x3+17x2+6x。

运行界面如图5.2所示。

图5.2 输入多项式截图

选择2，输出多项式，如图5.3所示。

图5.3 输出多项式截图

选择3，操作界面输出两多项式相加后的表达式。如图5.4。

图5.4显示多项式和截图

3．测试第二组数据(系数为负数的两多项式相加)。

选择1，按操作提示分别输入两多项式：

(1)-3x8+10x11+9x13；

(2)-7x8+5x5。

运行界面如图5.5所示。

图5.5 输入截图选择2，输出多项式，如图5.6。

图5.6 输出截图选择3，输出多项式和，如图5.7。

图5.7 显示多项式和截图

6 结束语

经过半个多月的思考和设计，我基本完成了对一元多项式求和问题的研究与实现。虽然程序简短，操作简单，但它能很好地解决任意两个多项式的求和问题。

虽然在研究和解决问题，逐步完成程序的过程中，遇到了始料未及的困难，但通过自己努力查找资料，积极和其他同学交流，在对程序一次次修改和调试后，解决了很多程序运行出现的错误。在对所学的有限知识的理解和掌握下，并在老师的精心指导下，我终于基本完成了课程设计任务。通过两周的研究学习，动手实践，愈发深刻地体会到<<数据结构>>课程的重要性。该课程的学习效果直接影响到我对其它专业课的学习和今后业务的成长。算法是计算机科学的基石，一个好算法应该具有较短的执行时间并占用较少的辅助空间，是一个程序成功与否的决定性因素。

因为对专业知识没有很深的认识，加之课程设计时间较短，所以设计的程序还有许多不尽如人意的地方，其中难免有一些是错误的或者是不合理的，望老师批评指导。

在以后的学习中，我还应该不断的完善自己的知识体系结构，注意理论与实践的结合，学以致用，达到了学习的真正目的！

参考文献

[1] 王红梅，胡明，王涛. 数据结构(C++版)[M]. 北京：清华大学出版社，2005

[2] 王红梅等. 数据结构(C++版)学习辅导与实验指导[M]. 北京：清华大学出版社，2005

[3] 钱能. C++ 程序设计教程[M]. 北京：清华大学出版社，2006

[4] 李春葆.数据结构[M].北京：清华大学出版社，2002

附录：一元多项式求和主要源程序清单

// 程序名称：一元多项式求和问题的研究与实现

// 程序功能：采用C++语言,实现任意两一元多项式求和。

// 程序作者：梁艳君

// 最后修改日期：2008-9-12

#include

#include

void menuupdown(); //声明菜单的某个部分

class item

{

private:

double valuea; //声明系数

double valueb; //声明指数

double corp; //在做和是只是是否计算过

item * next; //指向下一个元素的地址

public:

item(double ax,double bx) //有参数构造函数，主要用于生成临时一元多项式的项和头指针{

valuea=ax;

valueb=bx;

corp=0;

next=NULL;

}

item() //无参数构造函数，主要用于生成一元多项式时使用

{

cin>>valuea>>valueb;

corp=0;

next=NULL;

}

friend class operate; //声明类operate为类item的友元类

};

void introduce()

{

cout<

cout<

}

//end of class item

//---------------------------------------------------------------

//begin of class operate

class operate

{

private:

item * head,* record; //定义head指向头指针，定义record记录链表最后指针位置，并用于链接链表

public:

operate(); //声明operate函数，用于生成链表头

item * gethead(); //取出多项式的头地址

void creat(); //声明creat函数，用于生成链表，即输入多项式

item* addsame(item* atemp); //声明函数，主要将单个多项式中相同的项相加

void show(item * show); //声明函数，显示多项式

operate operator + (operate lasts); //声明函数，重载+符号用于多项式相加

};

//end of class operate

//---------------------------------------------------------------

//begin of function operate() in class operate

operate::operate() //caozuo构造函数实现过程

{

head= new item(0,0); //使head指向头结点

record=head; //record初始化指向头指针

}

//end of function operate in class operate

//---------------------------------------------------------------

//begin of function gethead() in class operate

item * operate::gethead() //gethead函数实现过程

{

return head; //返回头指针

}

//end of function gethead() in class operate

//---------------------------------------------------------------

//begin of function creat() in class operate

void operate::creat() //creat函数实现过程

{

int i,j;

cout<<"请输入多项式项数:"<

::menuupdown(); //显示一长串---------

cout<

cin>>j;

for(i=1;i<=j;i++)

{ // 依次输入m个非零项

cout<<"输入第"<

item * p=new item;

record->next=p; //以下两句是使链表相连

record=p;

}

}

//end of function creat() in class operate

//---------------------------------------------------------------

//begin of function addsame in class operate

item* operate::addsame(item* atemp)

{

item * h=atemp; //声明的h指针，指向待检查的项

item * h1=atemp; //声明h1指针，指向被比较的项

item * htemp; //用作删除项

while(h1->next) //使被检查项指针在h（待检查项）循环完毕后循环

{

htemp=h1;

if(h->next) //若果h-next不为空，那么指向下一项

h=h->next;

else

h->next=NULL;

while(h->valueb==h1->valueb&&htemp->next) //比较"待检查的项"系数与"被检查项"系数是否相等

{

h1->valuea=h1->valuea+h->valuea; //相等的话使之相加，并把结果放到被检查项处

if(h->next) //如果待检查项的下一项不为空，那么指向，即删除待检查项

{

htemp->next=h->next;

h=h->next;

}

else

{

htemp->next=NULL;

h->next=NULL;

}

}

if(h1->next)

h1=h1->next;

else

h1->next=NULL;

}

return atemp;

}

//end of function addsame in class operate

//---------------------------------------------------------------

//begin of function show in class operate

void operate::show(item * show)

{

int i=0;

if(show->next) //忽略头指针

show=show->next;

//具体显示过程

while(show)

{

if(i>0&&show->valuea>0) //如果不是第一项，那么在前面加上+符号cout<<"+";

if(show->valuea==1) //如果系数为1

if(show->valueb==1) //如果指数为1

cout<<"X";

else

cout<<"X^"<valueb;

else

if(show->valueb==1)

cout<valuea<<"X";

else

cout<valuea<<"X^"<valueb;

show=show->next;

i=i+1;

}

cout<

}

//end of function show in class operate

//---------------------------------------------------------------

//begin of function operator + in class operate

operate operate::operator + (operate lasts)

{

item * last=lasts.gethead(); //声明last指向被加对象的头指针

if(last->next)

last=last->next;

operate answer; //声明定义临时answer对象，用于保存相加结果item * p=answer.gethead(); //p用于操作结果链

item * headlast=last; //headlast用于操作被加链表

operate thistemp=*this;

item * headfirst=thistemp.gethead(); //取出加号前的链表的头地址

if(headfirst->next)

headfirst=headfirst->next;

item * record=p; //record用于链接结果链表

//相加过程，两层循环遍历所有加数

while(headfirst)

{

double answertemp=0;

int flag=0;

while(headlast)

{

if(headlast->valueb==headfirst->valueb) //如果两项指数相等

{

if(flag==0) //如果是第一次执行

{

answertemp=headlast->valuea+headfirst->valuea;

flag=1;

}

else

{

answertemp=answertemp+headlast->valuea;

}

headlast->corp=1; //记录第二多项式项已相加

}

headlast=headlast->next;

}

if(answertemp!=0) //若果相加过，即两式中有相同指数的项存在{

item * temp=new item(answertemp,headfirst->valueb);

record->next=temp;

record=temp;

}

else

{

item * temp=new item(headfirst->valuea,headfirst->valueb);

record->next=temp;

record=temp;

}

headlast=last;

headfirst=headfirst->next;

}

headlast=last;

while(headlast) //再次在第二多项式里遍历，找corp为零的项，即此项未相加过{

if(headlast->corp==0)

{

item * temp=new item(headlast->valuea,headlast->valueb);

record->next=temp;

record=temp;

}

if(headlast->next)

headlast=headlast->next;

else

headlast=NULL;

}

return answer;

}

//end of function operator + in class operate

//---------------------------------------------------------------

//begin of function menuupdown in global

void menuupdown() //显示15次━，用作菜单

{ int i;

for(i=0;i<15;i++)

cout<<"━";

}

//end of function menuupdown in global

//---------------------------------------------------------------

//begin of function menu in global

void menu() //菜单函数

{

int i;

for(i=0;i<2;i++)

cout<

introduce();

for(i=0;i<2;i++)

cout<

cout<<"\t\t\t";

cout<<"┏";

menuupdown();

cout<<"┓"<

cout<<"\t\t\t┃\t\t\t\t┃"<

cout<<"\t\t\t┃\t1.输入一元多项式。\t┃"<

cout<<"\t\t\t┃\t2.输出一元多项式。\t┃"<

cout<<"\t\t\t┃\t3.两多项式相加。\t┃"<

cout<<"\t\t\t┃\t4.退出。\t\t┃"<

cout<<"\t\t\t┃\t\t\t\t┃"<

cout<<"\t\t\t";

cout<<"┗";

menuupdown();

cout<<"┛"<

}

//end of function menu in global

//---------------------------------------------------------------

//begin of function main in global

void main()

{

char inputchoose,YesOrNo; //声明两变量，分别保存选项，是否退出int select=0; //标示是否已创建对象，如果已创建，则会赋值为1 operate news1; //声明第一个操作多项式

operate news2; //声明第二个操作多项式

operate answeradd; //声明，用于相加后保存结果

item * heada;

item * headb;

do

{