一元多项式计算程序报告.docx

一元多项式计算程序报告.docx

《一元多项式计算程序报告.docx》由会员分享，可在线阅读，更多相关《一元多项式计算程序报告.docx（24页珍藏版）》请在冰豆网上搜索。

一元多项式计算程序报告

合肥学院

课程设计题目：

（一元多项式计算问题）一元多项式计算。

要求：

能够按照指数降序排列建立并输出一元多项式；能够完成两个一元多项式的相加、相减，并将结果输入。

1、问题分析和任务定义

（1）.任务定义：

此程序需要完成如下的要求：

将多项式按照指数降序排列建立并输出，将两个一元多项式进行相加、相减操作，并将结果输入。

a：

输入并建立多项式；

b：

输出多项式，输出形式为表达式的形式，并且多项式的指数为降序；

c：

多项式a和b相加，建立多项式a+b；

d：

多项式a和b相减，建立多项式a-b。

e：

多项式的输出形式为类数学表达式。

（2）.问题分析：

本程序的关键点在于如何将输入的一元多项式按指数的降序进行排列，而难点就是将输入的两个一元多项式进行相加、相减操作。

实现本程序需要解决以下几个问题：

1、如何将输入的一元多项式按指数的降序进行排列；

2、如何确定要输入的多项式的项数；

3、如何将输入的两个一元多项式进行显示出来；

4、如何将输入的两个一元多项式进行相加操作；

5、如何将输入的两个一元多项式进行相减操作。

次程序是链表的应用，通过链表实现一元多项式的相加相减操作。

要对一元多项式进行表示：

一元多项式的表示在计算机内可以用链表来表示为了节省存储空间，我们只存储多项式中系数非0的项。

链表中的每一个节点存放多项式的一个系数非0项，它包含三个域，分别存放该项的系数、指数以及指向下一多项式项节点的指针。

下图1所示为该结点的结构：

图1结点的结构

创建一元多项式链表，对一元多项式的运算中会出现各种可能情况进行分析，实现一元多项式的相加、相减操作。

2、数据结构的选择和概要设计

本题设计要求能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加，相减，并将结果输入。

（1）数据结构的选用

A:

基于链表中的节点可以动态生成的特点，以及链表可以灵活的添加或删除节点的数据结构，为了实现任意多项式的加法，减法，因此选择单链表的结构体，它有一个系数，指数，下一个指针3个元属；例如，图2中的两个线性链表分别表示一元多项式

和一元多项式

。

从图中可见，每个结点表示多项式中的一项。

图2多项式表的单链存储结构

B：

本设计使用了以下数据结构：

structNode

{//结点类型

floatcoef;//系数

intexp;//指数

};

C：

设计本程序需用到九个模块，用到以下九个子函数如下：

1、CreateLink（Link&L,intn）;//创建含有n个链表类型结点的项，即创建一个n项多项式

2、PrintList（LinkL）;//输出链表

3、PolyAdd（Link&pc,Linkpa,Linkpb）;//将两个一元多项式相加

4、PolySubstract（Link&pc,Linkpa,Linkpb）;//将两个一元多项式相减

5、CopyLink（Link&pc,Linkpa）;//把一个链表的内容复制给另一个链表

6、JudgeIfExpSame（Linkpa,Linke）;/*判断指数是否与多项式中已存在的某项相同*/

7、DestroyLink（Link&L）;

8、Menu（）//菜单函数

9、main（）//主程序模块调用链一元多项式的各种基本操作模块。

（2）多项式的输入

采用尾插法的方式，输入多项式中一个项的系数和指数，就产生一个新的节点，建立起它的右指针，并用头节点指向它；为了判断一个多项式是否输入结束，在输入前先确定要输入的项数。

（3）两个多项式的加法

“和多项式”链表中的结点无需另生成，而应该从两个多项式的链表中摘取。

其运算规则如下：

假设指针qa和qb分别指向多项式A和多项式B中当前进行比较的某个结点，则比较两个结点中的指数项，有下列3种情况：

①指针qa所指结点的指数值<指针qb所指结点的指数值，则应摘取qa指针所指结点插入到“和多项式”链表中去；

②指针qa所指结点的指数值>指针qb所指结点的指数值，则应摘取指针qb所指结点插入到“和多项式”链表中去；

③指针qa所指结点的指数值=指针qb所指结点的指数值，则将两个结点中的系数相加，

若和数不为零，则修改qa所指结点的系数值，同时释放qb所指结点；反之，从多项式A的链表中删除相应结点，并释放指针qa和qb所指结点。

例如，由图2中的两个链表表示的多项式相加得到的“和多项式”链表如图3所示，图中的长方框表示已被释放的结点。

图3相加得到的和多项式

上述多项式的相加过程归并两个有序表的过程极其类似，不同之处仅在于，后者在比较数据元素时只出现两种情况。

因此，多项式相加的过程也完全可以利用线性链表的基本操作来完成。

（4）两个多项式的减法

两个多项式的减法实现，是从2个多项式的尾部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相减；相减的和不为0的话，用尾插法建立一个新的节点。

p的系数小于q的系数的话，就应该复制q接点到多项式中。

p的系数大于q的系数的话，就应该复制p接点到多项式中，并且建立的接点的系数为原来的相反数；当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生。

当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生，并且建立的接点的系数为原来的相反数。

（5）程序流程图:

一元多项式相减流程图如图4：

图4多项式相减流程图

一元多项式相加流程图如图5：

图5相加流程图

3、详细设计和编码

（1）、算法思想

（1）输入并建立多项式——CreateLink（）

（2）输出多项式，输出形式为整数序列，序列按指数降序排列——PrintList（）

（3）多项式a和b相加，建立多项式a+b，输出相加的多项式——PolyAdd（）

（4）多项式a和b相减，建立多项式a-b，输出相减的多项式——PolySubstract（）用带表头结点的单链表存储多项式。

此程序需要完成如下的要求：

将多项式按照指数降序排列建立并输出，将两个一元多项式进行相加、相减操作，并将结果输入。

（2）、算法描述

1、定义结点类型

用floatcofe表示一元多项式的系数，intexp表示一元多项式的指数创建链表的结点类型。

structNode

{floatcoef;//结点类型

intexp;

};

2、定义链表的类型

structLNode

{polynomialdata;//链表类型

LNode*next;

};

3、创建含有n个链表类型结点的项，即创建一个n项多项式，用函数voidCreateLink（Link&L,intn）表示，创建头结点（L->data）.exp=-1;创建多项式没有成功，递归调用重新创建CreateLink（L,n）;

4、用函数intJudgeIfExpSame（LinkL,Linke）判断指数是否与多项式中已存在的某项相同，如果输入的一元多项式有重复的指数需重新输入。

5输出链表用函数voidPrintList（LinkL）表示，这个部分根据项系数的不同分为项的系数大于0的5种情况和项的系数小于0的5种情况。

6、链表内容的复制：

把一个链表的内容复制给另一个链表用函数voidCopyLink（Link&pc,Linkpa）表示。

8、将多项式按照指数降序排列建立并输出，本程序用冒泡排序的方法将多项式的指数从大到小的顺序进行排列voidpaixu（Linkhead1）

对链表进行排序过程中用循环来确定链表的长度

while（head1!

=NULL）{

n++;

head1=head1->next;

}

将链表中的元素按照从大到小的顺序排列

if（（p->data）.exp<（q->data）.exp）{

（m->data）.coef=（p->data）.coef;

（m->data）.exp=（p->data）.exp;

（p->data）.coef=（q->data）.coef;

（p->data）.exp=（q->data）.exp;

（q->data）.coef=（m->data）.coef;

（q->data）.exp=（m->data）.exp;

}

9、将两个一元多项式相加用函数voidPolyAdd（Link&pc,Linkpa,Linkpb）表示

“和多项式”链表中的结点无需另生成，而应该从两个多项式的链表中摘取。

其运算规则如下：

假设指针qa和qb分别指向多项式A和多项式B中当前进行比较的某个结点，则比较两个结点中的指数项，有下列3种情况：

①指针qa所指结点的指数值<指针qb所指结点的指数值，则应摘取qa指针所指结点插入到“和多项式”链表中去；

②指针qa所指结点的指数值>指针qb所指结点的指数值，则应摘取指针qb所指结点插入到“和多项式”链表中去；

③指针qa所指结点的指数值=指针qb所指结点的指数值，则将两个结点中的系数相加，

若和数不为零，则修改qa所指结点的系数值，同时释放qb所指结点；反之，从多项式A的链表中删除相应结点，并释放指针qa和qb所指结点。

10、将两个多项式相减

10、将两个一元多项式相减用函数voidPolySubstract（Link&pc,Linkpa,Linkpb）表示，两个多项式的减法实现，是从2个多项式的尾部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相减；相减的和不为0的话，用尾插法建立一个新的节点。

p的系数小于q的系数的话，就应该复制q接点到多项式中。

p的系数大于q的系数的话，就应该复制p接点到多项式中，并且建立的接点的系数为原来的相反数；当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生。

当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生，并且建立的接点的系数为原来的相反数。

4、上机调试

1、语法错误及修改：

编译中出现的语法问题主要在于子函数和变量的定义，括号的配对，关键字和函数名称的书写，以及一些库函数的规范使用。

这些问题均可以根据编译器的警告提示，对应的将其解决。

2、逻辑问题修改和调整：

由于一元多项式的计算中，在输入多项式的系数和一元多项式的指数是会有多种情况，所以设计过程中经常出现各种没有考虑到的情况，通过查找课本和资料最终比较全面的囊括了一元多项式会出现的各种情况。

3、经验体会：

在开始看到程序题目的时候会以为一元多项式的加减会很简单，可是在课程设计的过程中发现程序的编写并不是开始想象的那么简单，在这过程也中遇到了难题，比如题目的要求中要对一元多项式的指数进行排序实现从大到小的循序进行输入，所以在对指数的排序中运行经常出错，最终用冒泡排序的方法解决了这个问题。

5、测试结果及其分析

菜单界面如图6：

图6菜单界面

创建要运算的两个一元多项式如图7：

图7创建要运算的两个一元多项式

显示输入的两个多项式如图8:

图8显示输入的两个多项式

将两个一元多项式相加如图9：

图9将两个一元多项式相加

将两个一元多项式相减如图10：

图10多项式相减

销毁创建的两个多项式如图11：

图11销毁创建的两个多项式

6、用户使用说明

本程序运行后出现菜单界面，根据菜单提示进行操作。

在创建多项式多项式的时候根据提示先确定要输入的多项式的项数，再依次输入各项的系数和指数，值得注意的时候在输入指数的时候输入的指数一定不能小于0，当指数小于0的时候会提示出“你输入有误，指数不允许为负！

”重新输入；在输入的项数中如果出现前面已经输入过的系数时会出现提示重新输入。

7、参考文献

[1]郑莉，董渊，张瑞丰　C++语言程序设计（第3版）　　清华大学出版社

[2]王昆仑，李红　　数据结构与算法　　中国铁道出版社

8、附录（源程序）

#include

usingnamespacestd;

structNode

{

floatcoef;//结点类型

intexp;

};

typedefNodepolynomial;

structLNode

{

polynomialdata;//链表类型

LNode*next;

};

typedefLNode*Link;

voidCreateLink（Link&L,intn）;

voidPrintList（LinkL）;

voidPolyAdd（Link&pc,Linkpa,Linkpb）;

voidPolySubstract（Link&pc,Linkpa,Linkpb）;

voidCopyLink（Link&pc,Linkpa）;

intJudgeIfExpSame（Linkpa,Linke）;

voidDestroyLink（Link&L）;

intCompareIfNum（inti）;

voidDestroyLink（Link&L）

{

Linkp;

p=L->next;

while（p）

{

L->next=p->next;

deletep;

p=L->next;

}

deleteL;

L=NULL;

}

//创建含有n个链表类型结点的项，即创建一个n项多项式

voidCreateLink（Link&L,intn）

{

if（L!

=NULL）

{

DestroyLink（L）;

}

Linkp,q,newp;

L=newLNode;

L->next=NULL;

（L->data）.exp=-1;//创建头结点

p=L;

for（inti=1;i<=n;i++）

{

newp=newLNode;

cout<<"请输入第"<

"<

cout<<"系数:

";

cin>>（newp->data）.coef;

cout<<"指数:

";

cin>>（newp->data）.exp;

if（newp->data.exp<0）

{cout<<"您输入有误，指数不允许为负值!

"<

deletenewp;

i--;

continue;

}

newp->next=NULL;

p=L;

if（newp->data.coef==0）

{

cout<<"系数为零，重新输入!

"<

deletenewp;

i--;

continue;

}

while（（p->next!

=NULL）&&（（p->next->data）.exp>（newp->data）.exp））

{

p=p->next;//p指向指数最小的那一个

}

q=p->next;

if（!

JudgeIfExpSame（L,newp））

{p->next=newp;

newp->next=q;

}

else

{

cout<<"输入的该项指数与多项式中已存在的某项相同,请重新创建一个正确的多项"<

deletenewp;

DestroyLink（L）;

CreateLink（L,n）;//创建多项式没有成功，递归调用重新创建

break;

}

}

}

/*判断指数是否与多项式中已存在的某项相同*/

intJudgeIfExpSame（LinkL,Linke）

{

Linkp;

p=L->next;

while（p!

=NULL&&（e->data.exp!

=p->data.exp））

p=p->next;

if（p==NULL）return0;

elsereturn1;

}

/*输出链表*/

voidPrintList（LinkL）

{

Linkp;

if（L==NULL||L->next==NULL）

cout<<"该一元多项式为空！

"<

else

{

p=L->next;

//项的系数大于0的5种情况

if（（p->data）.coef>0）

{

if（（p->data）.exp==0）

cout<<（p->data）.coef;

elseif（（p->data）.coef==1&&（p->data）.exp==1）

cout<<"x";

elseif（（p->data）.coef==1&&（p->data）.exp!

=1）

cout<<"x^"<<（p->data）.exp;

elseif（（p->data）.exp==1&&（p->data）.coef!

=1）

cout<<（p->data）.coef<<"x";

elsecout<<（p->data）.coef<<"x^"<<（p->data）.exp;

}

//项的系数小于0的5种情况

if（（p->data）.coef<0）

{

if（（p->data）.exp==0）

cout<<（p->data）.coef;

elseif（p->data.coef==-1&&p->data.exp==1）

cout<<"-x";

elseif（p->data.coef==-1&&p->data.exp!

=1）

cout<<"-x^"<data.exp;

elseif（p->data.exp==1）

cout<data.coef<<"x";

elsecout<<（p->data）.coef<<"x^"<<（p->data）.exp;

}

p=p->next;

while（p!

=NULL）

{if（（p->data）.coef>0）

{if（（p->data）.exp==0）

cout<<"+"<<（p->data）.coef;

elseif（（p->data）.exp==1&&（p->data）.coef!

=1）

cout<<"+"<<（p->data）.coef<<"x";

elseif（（p->data）.exp==1&&（p->data）.coef==1）

cout<<"+"<<"x";

elseif（（p->data）.coef==1&&（p->data）.exp!

=1）

cout<<"+"<<"x^"<<（p->data）.exp;

elsecout<<"+"<<（p->data）.coef<<"x^"<<（p->data）.exp;

}

if（（p->data）.coef<0）

{

if（（p->data）.exp==0）

cout<<（p->data）.coef;

elseif（p->data.coef==-1&&p->data.exp==1）

cout<<"-x";

elseif（p->data.coef==-1&&p->data.exp!

=1）

cout<<"-x^"<data.exp;

elseif（p->data.exp==1）

cout<data.coef<<"x";

elsecout<<（p->data）.coef<<"x^"<<（p->data）.exp;

}

p=p->next;

}

}

cout<

}

/*把一个链表的内容复制给另一个链表*/

voidCopyLink（Link&pc,Linkpa）

{

Linkp,q,r;

pc=newLNode;

pc->next=NULL;

r=pc;

p=pa;

while（p->next!

=NULL）

{

q=newLNode;

q->data.coef=p->next->data.coef;

q->data.exp=p->next->data.exp;

r->next=q;

q->next=NULL;

r=q;

p=p->next;

}

}

//对链表进行排序

voidpaixu（Linkhead1）

{

Linkm,p1,p,q;

m=newLNode;

intn,i,j;

p1=head1;

while（head1!

=NULL）{//用循环来确定链表的长度

n++;

head1=head1->next;

}

head1=p1;

head1=head1->next;

for（p=head1;p!

=NULL;p=p->next）//冒泡排序

for（q=p->next;q!

=NULL;q=q->next）

if（（p->data）.exp<（q->data）.exp）{//将链表中的元素按照从大到小的顺序排列

（m->data）.coef=（p->data）.coef;

（m->data）.exp=（p->data）.exp;

（p->data）.coef=（q->data）.coef;

（p->data）.exp=（q->data）.exp;

（q->data）.coef=（m->data）.coef;

（q->data）.exp=（m->data）.exp;

}

head1=p1;

}

/*将两个一元多项式相加*/

voidPolyAdd（Link&pc,Linkpa,Linkpb）

{

Linkp1,p2,p,pd;

CopyLink（p1,pa）;

CopyLink（p2,pb）;

pc=newLNode;

pc->next=NULL;

p=pc;

p1=p1->next;

p2=p2->next;

while（p1!

=NULL&&p2!

=NULL）

{

if（p1->data.expdata.exp）

{

p->next=p1;

p=p->next;

p1=p1->next;

}

elseif（p1->data.exp>p2->data.exp）

{

p->next=p2;

p=p->next;

p2=p2->next;

}

else

{p1->data.coef=p1->data.coef+p2->data.coef;

if（p1->data.coef!

=0）

{

p->next=p1;

p=p->next;

p1=p1->next;

p2=p2->next;

}

else

{pd=p1;

p1=p1->next;

p2=p2->next;

deletepd;

}

}

}

if（p1!

=NULL）

{

p->next=p1;

}

if（p2!

=NULL）

{p->next=p2;

}

paixu（pc）;

}

/*将两个多项式相减*/

voidPolySubstract（Link&pc,Linkpa,Linkpb）

{

Linkp,pt;

CopyLink（pt,pb）;

p=pt;

while（p!

=NULL）

{

（p->data）.coef=（-（p->data）.coef）;

p=p->next;

}

PolyAdd（pc,pa,pt）;

DestroyLink（pt）;

}

//清屏函数

voidClear（）

{system（"pause"）;

system（"cls"）;

}

//菜单函数

voidMenu（）

{

cout<<"\t*\t\t*"<

cout<<