二叉树前序中序后续线索树_二叉树的先序,中序,后序遍历以及线索二叉树的遍历...

二叉树的先序,中序,后序遍历以及线索二叉树的遍历

(2008-05-04 17:52:49)

标签：

杂谈

C++

二叉树的先序,中序,后序遍历以及线索二叉树的遍历

头文件

//*******************************************************************************

//二叉树中的数据类型为ElemType

//*******************************************************************************

// BinaryTree.h: interface for the CBinaryTree class.

//

//

#include //C++语言

#define OK 1

#define ERROR 0

class CBinaryTree

{

public:

CBinaryTree();

virtual ~CBinaryTree();

protected:

typedef int ElemType;

struct Node

{ //数据

ElemType data; //数据域信息

int lt; //前继指针标志

int rt; //后继指针标志

Node* lchild; //指向左孩子

Node* rchild; //指向右孩子

}*root,*head;

public:

int Create();

int PreOrderTraverse();

int MidOrderTraverse();

int LastOrderTraverse();

void LevelOrderTraverse();

int GetLeafCount();

int GetDepth();

int GetNodeCount();

int MidOrderTraverseThr();

void ChangeLeftRight();

void Destroy();

private: //重载以上函数,供以上函数调用

int Create(Node* &node);

int PreOrderTraverse(Node*node);

int MidOrderTraverse(Node*node);

int LastOrderTraverse(Node *node);

int GetLeafCount(Node*node);

void GetNodeCount(Node*node,int &count);

int GetDepth(Node*node);

void ChangeLeftRight(Node*node);

void Visit(Node*node);

void Destroy(Node*node);

};

// 实现文件

// BinaryTree.cpp: implementation of the CBinaryTree class.

#include "BinaryTree.h"

#include "Stack.h"

#include "Queue.h"

//

// Construction/Destruction

//

CBinaryTree::CBinaryTree()

{

root=NULL;

head=NULL;

}

CBinaryTree::~CBinaryTree()

{

Destroy();

}

int CBinaryTree::Create()

{ //创建一个二叉树

return Create(root);

//用户调用此函数，创建根结点，由此函数调用其内的

//CreateNode()创建除根结点外的其它所有结点

}

int CBinaryTree::PreOrderTraverse()

{ //先序遍历二叉树

return PreOrderTraverse(root);

}

int CBinaryTree::MidOrderTraverse()

{ //中序遍历二叉树

return MidOrderTraverse(root);

}

int CBinaryTree::LastOrderTraverse()

{ //后序遍历二叉树

return LastOrderTraverse(root);

}

void CBinaryTree::LevelOrderTraverse()

{ //借助于堆栈,完成二叉树的层次遍历

CQueue queue;

if(!root) return;

queue.InitQueue();

Node*p=root; //初始化

Visit(p);

queue.EnQueue((long)p);

//访问根结点，并将根结点地址入队

while(!queue.QueueEmpty())

{ //当队非空时重复执行下列操作

p=(Node*)queue.DeQueue(); //地址出队

if(p->lchild)

{

Visit(p->lchild);

queue.EnQueue((long)p->lchild); //处理左孩子

}

if (p->rchild)

{

Visit(p->rchild);

queue.EnQueue((long)p->rchild); //处理右孩子

}

}

}

int CBinaryTree::GetLeafCount()

{ //返回叶子结点数

return GetLeafCount(root);

}

int CBinaryTree::GetNodeCount()

{ //返回总结点数

int count=0;

GetNodeCount(root,count);

return count;

}

int CBinaryTree::GetDepth()

{ //返回二叉树的深度

return GetDepth(root);

}

void CBinaryTree::ChangeLeftRight()

{ //交换左右两孩子结点

if(root!=NULL)

ChangeLeftRight(root);

}

int CBinaryTree::Create(Node *&node)

{

int i;

cout<

不创建本结点):";

cin>>i;

if(i==0)

node=NULL;

else

{

if(!(node=new Node))

return ERROR;

node->data=i;

node->lt=0;

node->rt=0;

Create(node->lchild); //创建左子树

Create(node->rchild); //创建右子树

}

return OK;

}

int CBinaryTree::PreOrderTraverse(Node *node)

{

if(node!=NULL)

{

cout<data<

if(PreOrderTraverse(node->lchild)) //遍历左子树

if(PreOrderTraverse(node->rchild)) //遍历右子树

return 1;

return 0;

}

else

return 1;

}

int CBinaryTree::MidOrderTraverse(Node *node)

{

if(node!=NULL)

{

if(MidOrderTraverse(node->lchild))//遍历左子树

cout<data<

if(MidOrderTraverse(node->rchild))//遍历右子树

return 1;

return 0;

}

else

return 1;

}

int CBinaryTree::LastOrderTraverse(Node *node)

{

if(node!=NULL)

{

if(LastOrderTraverse(node->lchild)) //遍历左子树

if(LastOrderTraverse(node->rchild)) //遍历右子树

{

cout<data<

return 1;

}

return 0;

}

else

return 1;

}

int CBinaryTree::MidOrderTraverseThr()

{ //中序线索化二叉树

if(head!=NULL)

delete head;

head=new Node;

if(head==NULL)

return 0;

int i=0;

Node*pre=NULL,*cur=NULL;

long *temp=new long[GetNodeCount()];

head->lt=0; //无前驱,有左孩子

head->rt=1; //有后继,无右孩子

head->rchild=head;

if(root==NULL)

head->lchild=head;

else

{

head->lchild=root;

pre=head;

cur=root;

for(;i>0 || cur!=NULL;)

{

for(;cur!=NULL;temp[i]=(long)cur,i++,cur=cur->lchild);

if(i>0)

{

cur=(Node*)temp[--i];

cout<data<

if(cur->lchild==NULL)

{

cur->lt=1;

cur->lchild=pre;

}

if(pre->rchild==NULL)

{

pre->rt=1;

pre->rchild=cur;

}

pre=cur;

cur=cur->rchild;

}

}

pre->rchild=head;

pre->rt=1;

head->rchild=pre;

}

delete temp;

return 1;

}

void CBinaryTree::GetNodeCount(Node *node,int &count)

{

if(node!=NULL)

count++;

else

return;

GetNodeCount(node->lchild,count);//统计左子树个数

GetNodeCount(node->rchild,count);//统计右子树个数

}

int CBinaryTree::GetDepth(Node *node)

{

int d=0,depthr=0,depthl=0;

if (node==NULL)

return 0; // 如果是空树，则其深度为 0

else

{

depthl=GetDepth(node->lchild); //求node

的左子树的深度

depthr=GetDepth(node->rchild); //求node

的右子树的深度

return depthl>=depthr?1+depthl:1+depthr;

}

}

int CBinaryTree::GetLeafCount(Node *node)

{

int n,m;

if(node==NULL)

return 0; // 如果二叉树是空树，则返回 0

else if((node->lchild==NULL) &&

(node->rchild==NULL))

return 1; //

如果二叉树的左孩子和右孩子均为空，则返回

1

else // 如果二叉树的左孩子或右孩子不为空

{

n=GetLeafCount(node->lchild); //

求左子树的叶子结点数目

m=GetLeafCount(node->rchild); //

求右子树的叶子结点数目

return n+m; // 返回总的叶子结点数目

}

}

void CBinaryTree::ChangeLeftRight(Node *node)

{

if(node!=NULL)

{

ChangeLeftRight(node->lchild);

ChangeLeftRight(node->rchild);

Node*temp=node->lchild;

node->lchild=node->rchild;

node->rchild=temp;

}

}

void CBinaryTree::Visit(Node *node)

{ //访问结点

cout<data<

}

void CBinaryTree::Destroy()

{ //销毁二叉树

Destroy(root);

root=NULL;

if(head)

delete head;

head=NULL;

}

void CBinaryTree::Destroy(Node *node)

{

if(node!=NULL)

{

Destroy(node->lchild);

Destroy(node->rchild);

delete node;

node=NULL;

}

}

分享：

喜欢

0

赠金笔

加载中，请稍候......

评论加载中，请稍候...

发评论

登录名： 密码： 找回密码 注册记住登录状态

昵   称：

评论并转载此博文

发评论

以上网友发言只代表其个人观点，不代表新浪网的观点或立场。

后一篇 >游戏名称