C++数据结构之二叉树非递归操作

#include <iostream>

using namespace std;

const int MaxSize = 100;

template <typename T> //二叉树的结点结构

struct BiNode

{

T data;

BiNode<T> *lchild,*rchild;

BiNode<T> *btr;

int flag;

};

template <typename T>

class BiTree

{

private:

BiNode<T> *root;

BiNode<T> *Create();

void Release(BiNode<T> *root); //析构函数调用

public:

BiTree(); //构造函数，初始化一棵二叉树，其前序序列由键盘输入

~BiTree(); //析构函数，释放二叉链表中各结点的存储空间

BiNode<T> *GetRoot(); //获得指向根结点的指针

void PreOrder(BiNode<T> *root); //前序遍历二叉树

void InOrder(BiNode<T> *root); //中序遍历二叉树

void PostOrder(BiNode<T> *root); //后序遍历二叉树

void LevelOrder(BiNode<T> *root); //层序遍历二叉树

};

/*

*前置条件：无

*输 入：无

*功 能：调用Create()函数

*输 出：无

*后置条件：无

*/

template <typename T>

BiTree<T>::BiTree()

{

this->root = Create();

}

/*

*前置条件：空二叉树

*输 入：数据ch;

*功 能：初始化一棵二叉树,构造函数调用

*输 出：无

*后置条件：产生一棵二叉树

*/

template <typename T>

BiNode<T> *BiTree<T>::Create()

{

BiNode<T> *root;

T ch;

cin>>ch;

if(ch == '#')

root = NULL;

else{

root = new BiNode<T>; //生成一个结点

root->data = ch;

root->lchild = Create(); //递归建立左子树

root->rchild = Create(); //递归建立右子树

}

return root;

}

/*

*前置条件：二叉树已存在

*输 入：无

*功 能：获取指向二叉树根结点的指针

*输 出：指向二叉树根结点的指针

*后置条件：二叉树不变

*/

template <typename T>

BiNode<T> *BiTree<T>::GetRoot()

{

return root;

}

/*

*前置条件：二叉树已存在

*输 入：无

*功 能：释放二叉链表中各结点的存储空间

*输 出：无

*后置条件：二叉树不存在

*/

template<class T>

BiTree<T>::~BiTree(void)

{

Release(root);

}

/*

*前置条件：二叉树已存在

*输 入：无

*功 能：前序非递归遍历二叉树

*输 出：二叉树中结点的一个线性排列

*后置条件：二叉树不变

*/

template <typename T>

void BiTree<T>::PreOrder(BiNode<T> *root)

{

int top = -1;

BiNode<T> *Stack[MaxSize];

while(root != NULL || top != -1)

{

while(root != NULL)

{

cout<<root->data<<" ";

Stack[++top] = root;

root = root->lchild;

}

if(top != -1)

{

root = Stack[top--];

root = root->rchild;

}

}

}

/*

*前置条件：二叉树已存在

*输 入：无

*功 能：中序非递归遍历二叉树

*输 出：二叉树中结点的一个线性排列

*后置条件：二叉树不变

*/

template <typename T>

void BiTree<T>::InOrder(BiNode<T> *root)

{

int top = -1;

BiNode<T> *Stack[MaxSize];

while(root != NULL || top != -1)

{

while(root != NULL)

{

Stack[++top] = root;

root = root->lchild;

}

if(top != -1)

{

root = Stack[top--];

cout<<root->data<<" ";

root = root->rchild;

}

}

}

/*

*前置条件：二叉树已存在

*输 入：无

*功 能：后序非递归遍历二叉树

*输 出：二叉树中结点的一个线性排列

*后置条件：二叉树不变

*/

template <typename T>

void BiTree<T>::PostOrder(BiNode<T> *root)

{

int top = -1;

BiNode<T> Stack[MaxSize];

while(root != NULL || top != -1)

{

while(root != NULL)

{

top++;

Stack[top].btr = root;

Stack[top].flag = 0;

root = root->lchild;

}

while(top != -1 && Stack[top].flag == 1)

{

root = Stack[top--].btr;

cout<<root->data<<" ";

}

if(top != -1)

{

Stack[top].flag = 1;

root =Stack[top].btr;

root = root->rchild;

}

else

break;

}

}

/*

*前置条件：二叉树已存在

*输 入：无

*功 能：层序遍历二叉树

*输 出：二叉树中结点的一个线性排列

*后置条件：二叉树不变

*/

template <typename T>

void BiTree<T>::LevelOrder(BiNode<T> *root)

{

int front,rear;

front = rear = 0; //采用顺序队列，并假定不会发生上溢

BiNode<T> *Queue[MaxSize];

if(root == NULL)

return ;

Queue[++rear] = root;

while(front != rear)

{

BiNode<T> *btr;

btr = Queue[++front];

cout<<btr->data<<" ";

if(btr->lchild != NULL)

Queue[++rear] = btr->lchild;

if(btr->rchild != NULL)

Queue[++rear] = btr->rchild;

}

}

/*

*前置条件：二叉树已经存在

*输 入：无

*功 能：释放二叉树的存储空间，析构函数调用

*输 出：无

*后置条件：二叉树不存在

*/

template<class T>

void BiTree<T>::Release(BiNode<T>* root)

{

if (root != NULL){

Release(root->lchild); //释放左子树

Release(root->rchild); //释放右子树

delete root;

}

}

int main()

{

BiTree<char> bitree; //创建一棵树

BiNode<char> *binode;

binode = bitree.GetRoot(); //获取指向根结点的指针

cout<<"------前序非递归遍历------"<<endl;

bitree.PreOrder(binode);

cout<<endl;

cout<<"------中序非递归遍历------"<<endl;

bitree.InOrder(binode);

cout<<endl;

cout<<"------后序非递归遍历------"<<endl;

bitree.PostOrder(binode);

cout<<endl;

cout<<"------层序遍历------"<<endl;

bitree.LevelOrder(binode);

cout<<endl;

return 0;

}