数据结构二叉树的实验报告.docx

数据结构二叉树的实验报告.docx

《数据结构二叉树的实验报告.docx》由会员分享，可在线阅读，更多相关《数据结构二叉树的实验报告.docx（15页珍藏版）》请在冰豆网上搜索。

数据结构二叉树的实验报告

数据结构

实

验

报

告

1.实验目的和容：

掌握二叉树基本操作的实现方法

2.程序分析

2.1存储结构

链式存储

2．程序流程

2.3关键算法分析

算法一：

Create（BiNode*&R,Tdata[],inti,intn）

【1】算法功能：

创建二叉树

【2】算法基本思想：

利用顺序存储结构为输入，采用先建立根结点，再建立左右孩子的方法来递归建立二叉链表的二叉树

【3】算法空间时间复杂度分析：

O（n）

【4】代码逻辑：

如果位置小于数组的长度则

{创建根结点

将数组的值赋给刚才创建的结点的数据域

创建左子树，如果当前结点位置为i,则左孩子位置为2i

创建右子树，如果当前结点位置为i,则右孩子位置为2i+1

}

否则R为空

算法二：

CopyTree（BiNode*sR,BiNode*&dR）

）

【1】算法功能：

复制构造函数

【2】算法基本思想：

按照先创建根结点，再递归创建左右子树的方法来实现。

【3】算法空间时间复杂度分析：

O（n）

【4】代码逻辑:

如果源二叉树根结点不为空

则{

创建根结点

调用函数自身，创建左子树

调用函数自身，创建右子树

}

将该函数放在复制构造函数中调用，就可以实现复制构造函数

算法三：

PreOrder（BiNode*R）

【1】算法功能：

二叉树的前序遍历

【2】算法基本思想：

这个代码用的是优化算法，提前让当前结点出栈。

【3】算法空间时间复杂度分析：

O（n）

【4】代码逻辑（伪代码）

如果当前结点为非空，则

{

访问当前结点

当前结点入栈

将当前结点的左孩子作为当前结点}

如果为空

{

则栈顶结点出栈

则将该结点的右孩子作为当前结点

}

反复执行这两个过程，直到结点为空并且栈空

算法四：

InOrder（BiNode*R）

【1】算法功能：

二叉树的中序遍历

【2】算法基本思想：

递归

【3】算法空间时间复杂度分析：

未知

【4】代码逻辑：

如果R为非空：

则调用函数自身遍历左孩子

访问该结点

再调用自身访问该结点的右孩子

算法五：

LevelOrder（BiNode*R）

【1】算法功能：

二叉树的层序遍历

【2】算法基本思想：

【3】算法空间时间复杂度分析：

O（n）

【4】代码逻辑（伪代码）：

若根结点非空，入队

如果队列不空

{

对头元素出队

访问该元素

若该结点的左孩子为非空，则左孩子入队；

若该结点的右孩子为非空，则右孩子入队；

}

算法六：

Count（BiNode*R）

【1】算法功能：

计算结点的个数

【2】算法基本思想：

递归

【3】算法空间时间复杂度分析：

未知

【4】代码逻辑：

如果R不为空的话

{

调用函数自身计算左孩子的结点数

调用函数自身计算右孩子的结点数

}

template

intBiTree:

:

Count（BiNode*R）

{

if（R==NULL）return0;

else

{

intm=Count（R->lchild）;

intn=Count（R->rchild）;

returnm+n+1;

}

}

算法七：

Release（BiNode*R）

【1】算法功能：

释放动态存

【2】算法基本思想：

左右子树全部释放完毕后再释放该结点

【3】算法空间时间复杂度分析：

未知

【4】代码逻辑：

调用函数自身，释放左子树

调用函数自身，释放右子树

释放根结点

释放二叉树

template

voidBiTree:

:

Release（BiNode*R）

{

if（R!

=NULL）

{

Release（R->lchild）;

Release（R->rchild）;

deleteR;

}

}

template

BiTree:

:

~BiTree（）

{

Release（root）;

}

intmain（）

{

inta[10]={1,2,3,4,5,6,7,8,9,10};

BiTreeBTree（a,10）;

BiTreeTree（BTree）;

BTree.PreOrder（BTree.root）;

cout<

Tree.PreOrder（Tree.root）;

cout<

BTree.InOrder（BTree.root）;

cout<

Tree.InOrder（Tree.root）;

cout<

BTree.PostOrder（BTree.root）;

cout<

Tree.PostOrder（Tree.root）;

cout<

BTree.LevelOrder（BTree.root）;

cout<

Tree.LevelOrder（Tree.root）;

cout<

intm=BTree.Count（BTree.root）;

cout<

return0;

}

3.测试数据：

inta[10]={1,2,3,4,5};

12453

12453

42513

45231

12345

5

4.总结：

4.1:

这次实验大多用了递归的算法，比较好理解。

4.2:

新得体会：

在创建二叉树的过程中，在没有思路的时候可以巧妙的利用递归算法。

但是我的代码仍然应该改进，应该进一步简化，减少算法的时间复杂度和空间复杂度。

#include

usingnamespacestd;

templateclassBiNode

{

public:

Tdata;

BiNode*lchild;

BiNode*rchild;

};

templateclassBiTree

{

public:

BiNode*root;

BiTree（Tdata[],intn）;

BiTree（BiTree&r）;

voidPreOrder（BiNode*R）;

voidInOrder（BiNode*R）;

voidPostOrder（BiNode*R）;

voidLevelOrder（BiNode*R）;

intCount（BiNode*R）;

~BiTree（）;

private:

voidCreate（BiNode*&R,Tdata[],inti,intn）;

voidCopyTree（BiNode*sR,BiNode*&dR）;

voidRelease（BiNode*R）;

};

template

voidBiTree:

:

Create（BiNode*&R,Tdata[],inti,intn）

{

if（i<=n&&data[i-1]）

{

R=newBiNode;

R->data=data[i-1];

Create（R->lchild,data,2*i,n）;

Create（R->rchild,data,2*i+1,n）;

}

elseR=NULL;

}

template

BiTree:

:

BiTree（Tdata[],intn）

{

Create（root,data,1,n）;

}

template

voidBiTree:

:

CopyTree（BiNode*sR,BiNode*&dR）

{

if（sR==NULL）

dR=NULL;

else

{

dR=newBiNode;

dR->data=sR->data;

CopyTree（sR->lchild,dR->lchild）;

CopyTree（sR->rchild,dR->rchild）;

}

}

template

BiTree:

:

BiTree（BiTree&p）

{

CopyTree（p.root,this->root）;//this?

?

?

?

}

template

voidBiTree:

:

PreOrder（BiNode*R）

{

BiNode*S[100];

inttop=-1;

while（（top!

=-1）||（R!

=NULL））

{

if（R!

=NULL）

{

cout<data<<"";

S[++top]=R;

R=R->lchild;

}

else

{

R=S[top--];

R=R->rchild;

}

}

}

template

voidBiTree:

:

InOrder（BiNode*R）

{

if（R!

=NULL）

{

InOrder（R->lchild）;

cout<data<<"";

InOrder（R->rchild）;

}

}

template

voidBiTree:

:

PostOrder（BiNode*R）

{

if（R!

=NULL）

{

PostOrder（R->lchild）;

PostOrder（R->rchild）;

cout<data<<"";

}

}

template

voidBiTree:

:

LevelOrder（BiNode*R）

{

BiNode*queue[100];

intf=0,r=0;

if（R!

=NULL）

queue[++r]=R;

while（f!

=r）

{

BiNode*p=queue[++f];

cout<data<<"";

if（p->lchild!

=NULL）

queue[++r]=p->lchild;

if（p->rchild!

=NULL）

queue[++r]=p->rchild;

}

}

template

intBiTree:

:

Count（BiNode*R）

{

if（R==NULL）return0;

else

{

intm=Count（R->lchild）;

intn=Count（R->rchild）;

returnm+n+1;

}

}

template

voidBiTree:

:

Release（BiNode*R）

{

if（R!

=NULL）

{

Release（R->lchild）;

Release（R->rchild）;

deleteR;

}

}

template

BiTree:

:

~BiTree（）

{

Release（root）;

}

intmain（）

{

inta[5]={1,2,3,4,5};

BiTreeBTree（a,5）;

BiTreeTree（BTree）;

BTree.PreOrder（BTree.root）;

cout<

Tree.PreOrder（Tree.root）;

cout<

BTree.InOrder（BTree.root）;

cout<

BTree.PostOrder（BTree.root）;

cout<

BTree.LevelOrder（BTree.root）;

cout<

intm=BTree.Count（BTree.root）;

cout<

return0;

}