数据库与数据结构实验含源代码.docx

数据库与数据结构实验含源代码.docx

《数据库与数据结构实验含源代码.docx》由会员分享，可在线阅读，更多相关《数据库与数据结构实验含源代码.docx（67页珍藏版）》请在冰豆网上搜索。

数据库与数据结构实验含源代码

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

一、需求分析

1．程序的功能：

（1）两个多项式以指数递增的顺序输入；（选做内容部分，多项式也可未按指数递增的顺序输入。

）

（2）设计的数据结构应有利于表示任意一元稀释多项式；

（3）输出原始多项式及两个多项式相加后的运算结果。

2．输入输出的要求：

分别输入一元多项式各项的系数和指数，系数以浮点数输入，指数以整型数输入。

输出为具体各个一元多项式的形式，如7+3*x+9*x^8+5*x^17。

3．测试数据：

（1）

，

（2）

，

（3）

，

二、概要设计

1．本程序所用的数据结构的定义：

本程序中主要用了单链表的线性结构，其数据结构的定义如下：

structlink

{

floatceof;//每项系数

intexp;//每项指数

link*next;//指针域

};

并构造了一个多项式类：

classPolynomial；类定义如下：

classPolynomial//多项式类定义

{

link*head;//头指针

public:

voidcreat（）;//输入每项系数和指数创建多项式

voidpaixu（）;//多项式按指数从小到大排序

voidshuchu（）;//输出多项式

voidaddtwo（link*ha,link*hb）;//将两个多项式相连构成一个新的多项式，再通过排序和除去系数为0项

//实现两个多项式相加

voidqingling（）;//将多项式中系数为0的项消去

link*gethead（）;//取多项式的头结点

};

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

主程序的具体代码如下：

#include"Polynomail.h"

usingnamespacestd;

voidmain（）

{

PolynomialA,B,C;

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

"<

A.creat（）;

A.qingling（）;

A.paixu（）;

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

"<

B.creat（）;

B.qingling（）;

B.paixu（）;

cout<<"多项式A为:

"<

A.shuchu（）;

cout<<"多项式B为:

"<

B.shuchu（）;

cout<<"A和B相加为:

"<

C.addtwo（A.gethead（）,B.gethead（））;

C.paixu（）;

C.qingling（）;

C.shuchu（）;

}

3．主程序流程如下：

三、详细设计

各模块算法如下：

1.创建多项式

voidPolynomial:

:

creat（）//输入每项系数和指数创建多项式

{

link*p,*q,*s;

cout<<"请依次输入每项系数和指数，以空格分开，指数<0,输入完成!

"<

floatc;

inte;

cin>>c>>e;//输入系数和指数

p=q=newlink;

p->next=NULL;

while（e>=0）

{

s=newlink;

s->ceof=c;

s->exp=e;

q->next=s;

q=s;

cin>>c>>e;

}

q->next=NULL;

head=p;

}

2.多项式每项按指数由小到大排序

voidPolynomial:

:

paixu（）//多项式按指数从小到大排序

{

link*p,*q;

floata;

intb;

p=head->next;

while（p!

=NULL）

{

q=p->next;

while（q!

=NULL）

{

if（p->exp>q->exp）//后面的某一项指数小于前面的某一项，将两

//项系数和指数值交换

{

a=p->ceof;

b=p->exp;

p->ceof=q->ceof;

p->exp=q->exp;

q->ceof=a;

q->exp=b;

q=q->next;

}

else

if（p->exp==q->exp）//两项指数相等，则系数相加，后面一项系数

//置为0

{

p->ceof=p->ceof+q->ceof;

q->ceof=0;

q=q->next;

}

elseq=q->next;

}

p=p->next;

}

}

3.将多项式中系数为0的项消去

voidPolynomial:

:

qingling（）//将多项式中系数为0的项消去

{

link*p,*q;

p=head;

q=head->next;

while（q!

=NULL）

{

if（q->ceof==0）

{

p->next=q->next;

deleteq;

q=p->next;

}

else

{

p=p->next;

q=p->next;

}

}

}

4.输出多项式

voidPolynomial:

:

shuchu（）//输出多项式

{

link*p;

p=head->next;

if（p==NULL）cout<<"0";

else

{

while（p->next!

=NULL）

{

if（p->exp==0）{cout<ceof;}

else

if（p->exp==1）{cout<ceof<<"X";}

else

{cout<ceof<<"X^"<exp;}

p=p->next;

if（p->ceof>0）cout<<"+";

}

if（p->exp==0）//输出最后一项

{cout<ceof;

}

else

if（p->exp==1）cout<ceof<<"X";

else

cout<ceof<<"X^"<exp;

}

cout<

}

5.将两个多项式相连构成一个新的多项式，再通过排序和除去系数为0项，实现两个多项式相加

voidPolynomial:

:

addtwo（link*ha,link*hb）//将两个多项式相连构成一个新的多项式，再通过排序和除去系数为0项，实现两个多项式相加

{

link*a,*b,*c;

link*p;

a=ha->next;

p=b=newlink;

while（a!

=NULL）//将A复制进C

{

c=newlink;

c->ceof=a->ceof;

c->exp=a->exp;

c->next=NULL;

b->next=c;

b=b->next;

a=a->next;

}

a=hb->next;

while（a!

=NULL）//将B复制进C，接在A后面

{

c=newlink;

c->ceof=a->ceof;

c->exp=a->exp;

c->next=NULL;

b->next=c;

b=b->next;

a=a->next;

}

b=NULL;

head=p;

}

四、调试分析

1．调试中遇到的问题及对问题的解决方法：

在调试中，将A、B两个多项式输入输出都没有问题，但是当将A、B相加时，运行出错，程序必须终止。

而在编译过程中又没有报错。

通过在DEBUG过程中的调试步骤，找到了出错点—addtwo（link*ha,link*hb）。

程序无法运行的原因是函数中定义了指针变量，但是未分配内存空间。

添加语句：

p=b=newlink；后，问题得到解决。

2．算法的时间复杂度和空间复杂度：

时间复杂度：

①paixu：

②qingling:

③shuchu:

④addtwo:

空间复杂度：

由于程序中运用单链表的数据结构，并且各个部分所用的空间均较小，因此总体的空间复杂度也较小。

五、使用说明及测试结果

运行程序后，结果提示先输入多项式A，分别输入每一项的系数和指数，以空格隔开，当输入完毕后，输入后一项的指数小于0，则多项式A输入完成。

接着同样输入多项式B。

当多项式B输入结束后，屏幕则会显示多项式A和B，以及A和B相加后的多项式。

（在输入多项式时，不需要按照指数从低到高的顺序输入，运行结果会自动排列，将多项式以指数从低到高的顺序输出。

）

测试结果界面如下：

①

，

②

，

③

，

六、源程序（带注释）

#include

usingnamespacestd;

structlink

{

floatceof;//每项系数

intexp;//每项指数

link*next;//指针域

};

classPolynomial//多项式类定义

{

link*head;//头指针

public:

voidcreat（）;//输入每项系数和指数创建多项式

voidpaixu（）;//多项式按指数从小到大排序

voidshuchu（）;//输出多项式

voidaddtwo（link*ha,link*hb）;//将两个多项式相连构成一个新的多项式，再通过排序和除去系数为0项

//实现两个多项式相加

voidqingling（）;//将多项式中系数为0的项消去

link*gethead（）;//取多项式的头结点

};

link*Polynomial:

:

gethead（）

{

link*p=head;

returnp;

}

voidPolynomial:

:

creat（）//输入每项系数和指数创建多项式

{

link*p,*q,*s;

cout<<"请依次输入每项系数和指数，以空格分开，指数<0,输入完成!

"<

floatc;

inte;

cin>>c>>e;//输入系数和指数

p=q=newlink;

p->next=NULL;

while（e>=0）

{

s=newlink;

s->ceof=c;

s->exp=e;

q->next=s;

q=s;

cin>>c>>e;

}

q->next=NULL;

head=p;

}

voidPolynomial:

:

paixu（）//多项式按指数从小到大排序

{

link*p,*q;

floata;

intb;

p=head->next;

while（p!

=NULL）

{

q=p->next;

while（q!

=NULL）

{

if（p->exp>q->exp）//后面的某一项指数小于前面的某一项，将两

//项系数和指数值交换

{

a=p->ceof;

b=p->exp;

p->ceof=q->ceof;

p->exp=q->exp;

q->ceof=a;

q->exp=b;

q=q->next;

}

else

if（p->exp==q->exp）//两项指数相等，则系数相加，后面一项系数

//置为0

{

p->ceof=p->ceof+q->ceof;

q->ceof=0;

q=q->next;

}

elseq=q->next;

}

p=p->next;

}

}

voidPolynomial:

:

qingling（）//将多项式中系数为0的项消去

{

link*p,*q;

p=head;

q=head->next;

while（q!

=NULL）

{

if（q->ceof==0）

{

p->next=q->next;

deleteq;

q=p->next;

}

else

{

p=p->next;

q=p->next;

}

}

}

voidPolynomial:

:

shuchu（）//输出多项式

{

link*p;

p=head->next;

if（p==NULL）cout<<"0";

else

{

while（p->next!

=NULL）

{

if（p->exp==0）{cout<ceof;}

else

if（p->exp==1）{cout<ceof<<"X";}

else

{cout<ceof<<"X^"<exp;}

p=p->next;

if（p->ceof>0）cout<<"+";

}

if（p->exp==0）//输出最后一项

{cout<ceof;

}

else

if（p->exp==1）cout<ceof<<"X";

else

cout<ceof<<"X^"<exp;

}

cout<

}

voidPolynomial:

:

addtwo（link*ha,link*hb）//将两个多项式相连构成一个新的多项式，再通过排序和除去系数为0项，实现两个多项式相加

{

link*a,*b,*c;

link*p;

a=ha->next;

p=b=newlink;

while（a!

=NULL）//将A复制进多项式C

{

c=newlink;

c->ceof=a->ceof;

c->exp=a->exp;

c->next=NULL;

b->next=c;

b=b->next;

a=a->next;

}

a=hb->next;

while（a!

=NULL）//将B复制进C，接在A后面

{

c=newlink;

c->ceof=a->ceof;

c->exp=a->exp;

c->next=NULL;

b->next=c;

b=b->next;

a=a->next;

}

b=NULL;

head=p;

}

#include"Polynomail.h"

usingnamespacestd;

voidmain（）

{

PolynomialA,B,C;

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

"<

A.creat（）;

A.qingling（）;

A.paixu（）;

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

"<

B.creat（）;

B.qingling（）;

B.paixu（）;

cout<<"多项式A为:

"<

A.shuchu（）;

cout<<"多项式B为:

"<

B.shuchu（）;

cout<<"A和B相加为:

"<

C.addtwo（A.gethead（）,B.gethead（））;

C.paixu（）;

C.qingling（）;

C.shuchu（）;

}

实验二四则混合运算表达式处理

一、需求分析

1．程序的功能：

（1）以逆波兰表示输入的算术表达式；

（2）输出表达式树的各种遍历形式；

（3）打印表达式树；

（4）删除表达式树。

2．输入输出的要求：

分别输入以逆波兰表示的算术表达式。

输出为表达式树的各种遍历形式，并且输出该表达式树的树形结构。

3．测试数据：

（1）

（2）

（3）

（4）

二、概要设计

1．本程序所用的数据结构的定义：

本程序中主要用了堆栈和二叉树的数据结构，构建了两个类—栈类和二叉树类，定义如下：

classstack//栈类

{

char*stacks;

inttop;//栈顶

intsz;

public:

stack（）

{

sz=max;

stacks=newchar[sz];

top=-1;

}

charstackpop（）;//压栈

voidstackpush（charx）;//出栈

};

structbitreenode

{

chardata;

bitreenode*lchild;

bitreenode*rchild;

};

classbitree//二叉树类

{

bitreenode*root;

public:

bitreenode*getRoot（）//取二叉树根节点

{

if（root!

=NULL）returnroot;

else

returnNULL;

};

bitreenode*create（stack&s）;//创建二叉树

voidpreorder（bitreenode*root）;//先序遍历

voidinorder（bitreenode*root）;//中序遍历

voidpostorder（bitreenode*root）;//后序遍历

voiddeltree（bitreenode*root,int&count）;//删除二叉树

voidoutput（bitreenode*root,intspace）;//输出二叉树

};

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

主程序的具体代码如下：

intmain（）

{

stacks;//栈对象

cout<<"请输入一个表达式字符串，以#结尾!

"<

chara;

inti=0,j=0,k;

cin>>a;

while（a!

='#'）

{

if（a>=97&&a<=122）//判断是否为字母

{

s.stackpush（'0'）;//字母为叶子节点，

s.stackpush（'0'）;//用压栈前先输入两个'0'字符

s.stackpush（a）;//表示左右孩子为空!

i++;

}

else

{

if（a==42||a==43||a==45||a==47）//输入为运算符，直接压栈

{

s.stackpush（a）;

j++;

}

}

cin>>a;

}

if（i!

=j+1）

{

cout<<"输入表达式有误!

"<

exit

（1）;

}

k=i+j;

bitreetree;//二叉树对象

tree.create（s）;//创建树

cout<<"先序遍历结果为:

"<

tree.preorder（tree.getRoot（））;

cout<

cout<<"中序遍历结果为:

"<

tree.inorder（tree.getRoot（））;

cout<

cout<<"后序遍历结果为:

"<

tree.postorder（tree.getRoot（））;

cout<

cout<<"打印二叉树结果为:

"<

tree.output（tree.getRoot（）,0）;

cout<

cout<<"删除二叉树?

（Y/N）"<

charb;

cin>>b;

if（b=='Y'||b=='y'）

{

tree.deltree（tree.getRoot（）,k）;

cout<<"二叉树已删除!

"<

}

else

{

cout<<"二叉树未删除!

"<

}

return0;

}

主程序流程如下：

三、详细设计

各模块算法如下：

1.压栈：

voidstack:

:

stackpush（charx）

{

if（top==max-1）cout<<"栈满!

"<

else

{

top++;

stacks[top]=x;//栈未满，则压栈

}

}

2.出栈：

charstack:

:

stackpop（）

{

if（top==-1）//如果栈为空

{

cout<<"栈为空!

"<

return0;

}

else

{

chara;

a=stacks[top];//弹出最上面的元素

top--;

returna;

}

}

3.建立二叉树：

bitreenode*bitree:

:

create（stack&s）

{

chara;

a=s.stackpop（）;

if（a!

='0'）

{

bitreenode*q=newbitreenode;

q->data=a;

q->rchild=create（s）;//输入是逆波兰表示法，

q->lchild=create（s）;//则先创建右子树，再创建左子树

root=q;

returnroot;

}

else

returnNULL;

}

4.先序遍历二叉树：

voidbitree:

:

preorder（bitreenode*root）

{

if（root!

=NULL）

{

cout<data<<"";

preorder（root->lchild）;

preorder（root->rchild）;

}

}

5.中序遍历二叉树：

voidbitree:

:

inorder（bitreenode*root）

{

if（root!

=NULL）

{

inorder（root->lchild）;

cout<data<<"";

inorder（root->rchild）;

}

}