一元稀疏多项式计算器实习报告.docx

一元稀疏多项式计算器实习报告.docx

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

一元稀疏多项式计算器实习报告

一元稀疏多项式计算器实习报告[]

————————————————————————————————作者：

————————————————————————————————日期：

实习报告

题目：

设计一个一元稀疏多项式计算器

班级:

姓名学号__________完成日期：

__

一、课程题目

一元稀疏多项式计算器

二、需求分析

1、一元稀疏多项式简单计算器的功能是：

1.1输入并建立多项式；

1.2输出多项式，输出形式为整数序列：

n，c1,e1,c2,e2,………cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列；

1.3求多项式a、b的导函数；

1.4计算多项式在x处的值；

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

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

2、设计思路:

2.1定义线性表的动态分配顺序存储结构；

2.2建立多项式存储结构，定义指针*next

2.3利用链表实现队列的构造。

每次输入一项的系数和指数，可以输出构造的一元多项式

3、测试数据：

（1）、（2x+5x^8-3.1x^11）+（7-5x^8+11x^9）=（-3.1x^11+11x^9+2x+7）;

（2）、（6x^-3-x+4.4x^2-1.2x^9+1.2x^9）-（-6x^-3+5.4x^2-x^2+7.8x^15

）=（-7.8x^15-1.2x^9+12x^-3-x）;

（3）、（1+x+x^2+x^3+x^4+x^5）+（-x^3-x^4）=（1+x+x^2+x^5）;

（4）、（x+x^3）+（-x-x^3）=0;

（5）、（x+x^100）+（x^100+x^200）=（x+2x^100+x^200）;

（6）、（x+x^2+x^3）+0=x+x^2+x^3.

三、概要设计

1.有序表的抽象数据类型定义为：

ADTList{

数据对象：

D={ai|ai∈R,i=1,2,…,n,n≧0}

数据关系：

R1={|ai-1,ai∈D,ai-1,

基本操作：

InitList（）

操作结果：

构造一个空的有序表L。

DestroyList（L）

初始条件：

有序表L已存在。

操作结果：

销毁有序表L。

ListLength（L）

初始条件：

有序表L已存在。

操作结果：

返回有序表L的长度。

ClearList（L）

初始条件：

有序表L已存在。

操作结果：

清空链表内容。

Ins_before（N,N）

初始条件：

有序表L已存在。

操作结果：

插入节点到链表。

}ADTOrderedList

2.多项式的抽象数据类型定义为：

ADTPoly{

数据对象：

D={ai|ai为实数，i=1，2，…，n}

数据关系：

R1={}

基本操作：

CreatePoly（L,N）

初始条件：

N为节点，L为有序表。

操作结果：

将N插入多项式的适当位置。

GetPoly（L）

操作结果：

将用户输入转换为节点。

PrintPoly（L）

初始条件：

多项式L已存在。

操作结果：

显示多项式。

AddPoly（L_1,L_2,L_add）

初始条件：

多项式L_1,L_2,L_add已存在。

操作结果：

生成L_1,L_2之和的多项式L_add

DiffPoly（L,L_diff）

初始条件：

多项式L,L_diff已存在。

操作结果：

生成L的导数多项式L_add。

AlterPoly（L）

初始条件：

多项式L已存在。

操作结果：

将L多项式取相反数。

}ADTPoly、

三、详细设计

1、Constant.h

#ifndef__constant__

#define__constant__

#include

#include

#defineTURE1

#defineFALSE0

#defineOK1

#defineERROR0

#defineINFEASIBLE-1

#defineOVERFLOW-2

typedefintStatus;

#endif

2、Polynt.h

#include"constant.h"

typedefstructelemType{

floatcoef;//系数

intexpn;//指数

}ElemType;

typedefstructnode{

ElemTypedata;//指向结点元素的值

structnode*next;//后继

}Node,*Polyn;//结点类型，指针类型

typedefstruct{

Node*head;

Node*tail;

}List;

StatusMakeNode（Polyn&p,ElemTypee）;//分配由p指向的数据元素为e、后继为“空”的结点

StatusInitList（List&L）;//构造链表

StatusDestroyList（List&L）;//销毁线性表

voidInsert（List&L,Polyns）;//将s指向的结点插入L的最后一个结点

voidInsbefore（Polynp,Polynq）;

StatusCreatPolyn（List&polynomial,intm）;//创建一个一元多项式polynomial，并输入m项的指数和系数

voidPrintPolyn（ListL）;//打印输出一元多项式

voidAlterPoly（ListL）;//减法

voidAddPolyn（ListL1,ListL2,List&L3）;//多项式加法

3、Polyn.cpp

#include"Polynt.h"

StatusMakeNode（Polyn&p,ElemTypee）

{//分配由p指向的数据元素为e、后继为“空”的结点

p=（Polyn）malloc（sizeof（Node））;

p->data.coef=e.coef;

p->data.expn=e.expn;

p->next=NULL;

returnOK;

}

StatusInitList（List&L）

{//初始化链表

ElemTypee;

Polynp;

e.coef='';

e.expn='';

MakeNode（p,e）;

L.head=p;

L.tail=p;

returnOK;

}

StatusDestroyList（List&L）

{//销毁链表

Polynp,q;

if（L.head==L.tail）{free（L.head）;L.head=L.tail=NULL;returnOK;}

p=L.head->next;

while（!

p）{

q=p->next;

free（p）;

p=q;}

L.head=L.tail=NULL;

returnOK;

}

voidInsert（List&L,Polyns）

{

if（L.head->next==NULL）

{

L.head->next=s;

s->next=NULL;

L.tail=s;

}

else{

if（L.head->next!

=NULL&&s->data.expn>L.head->next->data.expn）

{s->next=L.head->next;L.head->next=s;return;}

if（L.tail->data.expn>s->data.expn）

{L.tail->next=s;L.tail=s;return;}

for（Polynp=L.head->next;p!

=NULL;p=p->next）

{

if（s->data.expn==p->data.expn）

{

p->data.coef+=s->data.coef;

free（s）;

return;

}

elseif（p->data.expn>s->data.expn&&p->next->data.expndata.expn）

{

s->next=p->next;p->next=s;

return;

}

}

}

}

StatusCreatPolyn（List&polynomial,intm）

{//创建一个一元多项式polynomial，并输入m项的指数和系数

ElemTypee;

Polynp;

for（inti=0;i

{

scanf（"%g,%d",&e.coef,&e.expn）;

MakeNode（p,e）;

Insert（polynomial,p）;}

polynomial.tail=p;

returnOK;

}

voidPrintPolyn（ListL）

{

Polynp;

if（L.head==L.tail）

printf（"0"）;

else

{

p=L.head->next;

while（p!

=NULL）

{

if（p==L.head->next）

{

if（p->data.coef>0）

{

if（p->data.expn!

=0）

{printf（"%gx^%d",p->data.coef,p->data.expn）;}

else{printf（"%g",p->data.coef）;}

}

elseif（p->data.coef<0）

{

if（p->data.expn!

=0）

{printf（"%gx^%d",p->data.coef,p->data.expn）;}

else{printf（"%g",p->data.coef）;}

}

else

{printf（""）;}

p=p->next;

}

elseif（p!

=L.head->next&&p!

=NULL）

{

if（p->data.coef>0）

{

if（p->data.expn!

=0）

{printf（"+%gx^%d",p->data.coef,p->data.expn）;}

else{printf（"+%g",p->data.coef）;}

}

elseif（p->data.coef<0）

{

if（p->data.expn!

=0）

{printf（"%gx^%d",p->data.coef,p->data.expn）;}

else{printf（"%g",p->data.coef）;}

}

else

{printf（""）;}

p=p->next;

}

else

return;

}

}

}

v