数据结构二叉树基本操作源代码.docx

数据结构二叉树基本操作源代码.docx

《数据结构二叉树基本操作源代码.docx》由会员分享，可在线阅读，更多相关《数据结构二叉树基本操作源代码.docx（27页珍藏版）》请在冰豆网上搜索。

数据结构二叉树基本操作源代码

数据结构二叉树基本操作

（1）.

//对二叉树的基本操作的类模板封装

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

#include

usingnamespacestd;

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

//定义二叉树的结点类型BTNode,其中包含数据域、左孩子，右孩子结点。

template

structBTNode

{

Tdata;//数据域

BTNode*lchild;//指向左子树的指针

BTNode*rchild;//指向右子树的指针

};

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

//CBinary的类模板

template

classBinaryTree

{

BTNode*BT;

public:

BinaryTree（）{BT=NULL;}//构造函数,将根结点置空

~BinaryTree（）{clear（BT）;}//调用Clear（）函数将二叉树销毁

voidClearBiTree（）{clear（BT）;BT=NULL;};//销毁一棵二叉树

voidCreateBiTree（Tend）;//创建一棵二叉树，end为空指针域标志

boolIsEmpty（）;//判断二叉树是否为空

intBiTreeDepth（）;//计算二叉树的深度

boolRootValue（T&e）;//若二叉树不为空用e返回根结点的值，函数返回true，否则函数返回false

BTNode*GetRoot（）;//二叉树不为空获取根结点指针，否则返回NULL

boolAssign（Te,Tvalue）;//找到二叉树中值为e的结点，并将其值修改为value。

TGetParent（Te）;//若二叉树不空且e是二叉树中的一个结点那么返回其双亲结点值

TGetLeftChild（Te）;//获取左孩子结点值

TGetRightChild（Te）;//获取右孩子结点值

TGetLeftSibling（Te）;//获取左兄弟的结点值

Trightsibling（BTNode*p,Te）;

TGetRightSibling（Te）;//获取右孩子的结点值

boolInsertChild（BTNode*p,BTNode*c,intRL）;//插入操作

boolDeleteChild（BTNode*p,intRL）;//删除操作

voidPreTraBiTree（）;//递归算法：

先序遍历二叉树

voidInTraBiTree（）;//递归算法：

中序遍历二叉树

voidPostTraBiTree（）;//递归算法：

后序遍历二叉树

voidPreTraBiTree_N（）;//非递归算法：

先序遍历二叉树

voidInTraBiTree_N（）;//非递归算法：

中序遍历二叉树

voidLevelTraBiTree（）;//利用队列层次遍历二叉树

intLeafCount（）;//计算叶子结点的个数

BTNode*SearchNode（Te）;//寻找到结点值为e的结点，返回指向结点的指针

voidDisplayBTreeShape（BTNode*bt,intlevel=1）;

};

//二叉树的树形显示算法

template

voidBinaryTree:

:

DisplayBTreeShape（BTNode*bt,intlevel）

{

if（bt）//空二叉树不显示

{DisplayBTreeShape（bt->rchild,level+1）;//显示右子树

cout<

for（inti=0;i

cout<<"";//确保在第level列显示节点

cout<data;//显示节点

DisplayBTreeShape（bt->lchild,level+1）;//显示左子树

}//if

}//DisplayBTree

template

staticintclear（BTNode*bt）

{//销毁一棵二叉树

if（bt）//根结点不空

{

clear（bt->lchild）;//递归调用Clear（）函数销毁左子树

clear（bt->rchild）;//递归调用Clear（）函数销毁右子树

cout<<"释放了指针"<

"<

deletebt;//释放当前访问的根结点

}

return0;

}

template

voidBinaryTree:

:

CreateBiTree（Tend）

{//创建一棵二叉树：

先序序列的顺序输入数据，end为结束的标志

cout<<"请按先序序列的顺序输入二叉树,-1为空指针域标志：

"<

BTNode*p;

Tx;

cin>>x;//输入根结点的数据

if（x==end）return;//end表示指针为空，说明树为空

p=newBTNode;//申请内存

if（!

p）

{

cout<<"申请内存失败！

"<

exit（-1）;//申请内存失败退出

}

p->data=x;

p->lchild=NULL;

p->rchild=NULL;

BT=p;//根结点

create（p,1,end）;//创建根结点左子树，1为标志，表示左子树

create（p,2,end）;//创建根结点右子树，2为标志，表示右子树

}

template

staticintcreate（BTNode*p,intk,Tend）

{//静态函数，创建二叉树，k为创建左子树还是右子树的标志，end为空指针域的标志

BTNode*q;

Tx;

cin>>x;

if（x!

=end）

{//先序顺序输入数据

q=newBTNode;

q->data=x;

q->lchild=NULL;

q->rchild=NULL;

if（k==1）p->lchild=q;//q为左子树

if（k==2）p->rchild=q;//p为右子树

create（q,1,end）;//递归创建左子树

create（q,2,end）;//递归创建右子树

}

return0;

}

template

boolBinaryTree:

:

IsEmpty（）

{//判断二叉树是否为空

if（BT==NULL）returntrue;//树根结点为空，说明树为空

returnfalse;

}

template

intBinaryTree:

:

BiTreeDepth（）

{//利用递归算法计算树的深度

BTNode*bt=BT;//树根结点

intdepth=0;//开始的时候数的深度初始化为0

if（bt）//如果树不为空

Depth（bt,1,depth）;

returndepth;

}

template

staticintDepth（BTNode*p,intlevel,int&depth）

{//这个函数由BiTreeDepth（）函数调用完成树的深度的计算

//其中p是根结点，Level是层，depth用来返回树的深度

if（level>depth）depth=level;

if（p->lchild）Depth（p->lchild,level+1,depth）;//递归的遍历左子树，并且层数加1

if（p->rchild）Depth（p->rchild,level+1,depth）;//递归的遍历右子树，并且层数加1

return0;

}

template

boolBinaryTree:

:

RootValue（T&e）

{//若二叉树不为空用e返回根结点的值，函数返回true，否则函数返回false

if（BT!

=NULL）//判断二叉树是否为空

{

e=BT->data;//若不空，则将根结点的数据赋值给e

returntrue;//操作成功，返回true

}

returnfalse;//二叉树为空，返回false

}

template

BTNode*BinaryTree:

:

GetRoot（）

{//获取根信息

returnBT;//返回根结点的指针，若二叉树为空那么返回NULL

}

template

boolBinaryTree:

:

Assign（Te,Tvalue）

{//结点赋值

if（SearchNode（e）!

=NULL）

{

（SearchNode（e））->data=value;

returntrue;

}

returnfalse;

}

template

TBinaryTree:

:

GetParent（Te）

{//获取双亲信息

BTNode*Queue[200],*p;

intrear,front;

rear=front=0;

if（BT）

{

Queue[rear++]=BT;

while（rear!

=front）

{

p=Queue[front++];

if（p->lchild&&p->lchild->data==e||p->rchild&&p->rchild->data==e）

returnp->data;

else

{

if（p->lchild）Queue[rear++]=p->lchild;

if（p->rchild）Queue[rear++]=p->rchild;

}

}

}

returnNULL;

}

template

TBinaryTree:

:

GetRightChild（Te）

{//如果二叉树存在，e是二叉树中的一个结点，右子树存在那么返回右子树的结点值，否则返回0并提示右子树为空

BTNode*p=SearchNode（e）;

if（p->rchild）returnp->rchild->data;//右子树不空，返回右子树根结点的值

cout<<"结点"<

return0;

}

template

TBinaryTree:

:

GetLeftChild（Te）

{//如果二叉树存在，e是二叉树中的一个结点，左子树存在那么返回左子树的结点值，否则返回0并提示左子树为空

BTNode*p=SearchNode（e）;

if（p->lchild）returnp->lchild->data;

cout<<"结点"<

return0;

}

template

TBinaryTree:

:

GetLeftSibling（Te）

{//获取左兄弟信息

if（BT!

=NULL）

{

returnleftsibling（BT,e）;

}

else

{//二叉树为空

cout<<"二叉树为空！

"<

return0;

}

}

template

Tleftsibling（BTNode*p,Te）

{

Tq=0;

if（p==NULL）return0;

else

{

if（p->rchild）

{

if（p->rchild->data==e）

{

if（p->lchild）returnp->lchild->data;

else

returnNULL;

}

}

q=leftsibling（p->lchild,e）;

if（q）returnq;

q=leftsibling（p->rchild,e）;

if（q）returnq;

}

return0;

}

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

template

TBinaryTree:

:

GetRightSibling（Te）

{//获取右兄弟信息

if（BT!

=NULL）

{

returnrightsibling（BT,e）;

}

else

{//二叉树为空

cout<<"二叉树为空！

"<

return0;

}

}

template

TBinaryTree:

:

rightsibling（BTNode*p,Te）

{

BTNode*q=SearchNode（e）;

BTNode*pp;

if（q）

{

pp=SearchNode（GetParent（e））;

if（pp）

{

if（pp->rchild）returnpp->rchild->data;

elsereturn0;

}

elsereturn0;

}

return0;

}

template

boolBinaryTree:

:

InsertChild（BTNode*p,BTNode*c,intLR）

{//插入孩子

if（p）

{

if（LR==0）

{

c->rchild=p->lchild;

p->lchild=c;

}

else

{

c->rchild=p->rchild;

p->rchild=c;

}

returntrue;

}

returnfalse;//p为空

}

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

template

boolBinaryTree:

:

DeleteChild（BTNode*p,intRL）

{//删除结点

if（p）

{

if（RL==0）

{

clear（p->lchild）;//释放p右子树的所有结点空间

p->lchild=NULL;

}

else

{

clear（p->rchild）;

p->rchild=NULL;

}

returntrue;//删除成功

}

returnfalse;//p为空

}

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

template

voidBinaryTree:

:

PreTraBiTree（）

{//先序遍历二叉树

cout<<"----------------------------------------------"<

cout<<"先序遍历二叉树:

";

BTNode*p;

p=BT;//根结点

PreTraverse（p）;//从根结点开始先序遍历二叉树

cout<

cout<<"----------------------------------------------"<

}

template

staticintPreTraverse（BTNode*p）

{

if（p!

=NULL）

{

cout<data<<'';//输出结点上的数据

PreTraverse（p->lchild）;//递归的调用前序遍历左子树

PreTraverse（p->rchild）;//递归的调用前序遍历右子树

}

return0;

}

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

template

voidBinaryTree:

:

InTraBiTree（）

{//中序遍历二叉树

cout<<"----------------------------------------------"<

cout<<"中序遍历二叉树:

";

BTNode*p;

p=BT;//根结点

InTraverse（p）;//从根结点开始中序遍历二叉树

cout<

cout<<"----------------------------------------------"<

}

template

staticintInTraverse（BTNode*p）

{

if（p!

=NULL）

{

InTraverse（p->lchild）;//递归的调用中序遍历左子树

cout<data<<'';//输出结点上的数据

InTraverse（p->rchild）;//递归的调用中序遍历右子树

}

return0;

}

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

template

voidBinaryTree:

:

PostTraBiTree（）

{//后序遍历二叉树

cout<<"----------------------------------------------"<

cout<<"后序遍历二叉树:

";

BTNode*p;

p=BT;//根结点

PostTraverse（p）;//从根结点开始遍历二叉树

cout<

cout<<"----------------------------------------------"<

}

template

staticintPostTraverse（BTNode*p）

{

if（p!

=NULL）

{

PostTraverse（p->lchild）;//递归调用后序遍历左子树

PostTraverse（p->rchild）;//递归调用后序遍历右子树

cout<data<<'';//输出结点上的数据

}

return0;

}

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

template

voidBinaryTree:

:

PreTraBiTree_N（）

{//

cout<<"----------------------------------------------"<

cout<<"先序（非递归）遍历二叉树得：

";

BTNode*Stack[200];//利用指针数组作为栈

inttop=0;

BTNode*p=BT;//将根结点的指针赋值给p

while（p!

=NULL||top!

=0）

{

while（p!

=NULL）

{

cout<data<<"";

Stack[top++]=p->rchild;

p=p->lchild;

}

if（top!

=0）

{

p=Stack[--top];

}

}

cout<<"\n----------------------------------------------"<

}

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

template

voidBinaryTree:

:

InTraBiTree_N（