[置顶] 二叉树的模板类实现

二叉树的定义
二叉树（Binary Tree）是n>0个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根节点和两棵不相交的分别被称为左子树和右子树组成。

·不存在度大于2的结点；
·左右子树是有序的，次序不能任意的颠倒。

二叉树的链表存储方式
二叉树的每个结点最多有两个孩子，所以设计一个数据域和两个指针域，我们称为二叉链表。

二叉链树的结点定义为

template<typename T>
struct BiTNode
{
    T data;
    BiTNode<T>   *lchild, *rchild;
    BiTNode(BiTNode<T>* pl = NULL, BiTNode<T>* pr = NULL)
    {
        lchild = pl;
        rchild = pr;
    }
};

为了方便介绍是如何生成一颗二叉树的，我们先来简单介绍一下三序遍历。
①前序遍历
先访问根节点，然后前序遍历左子树，再前序遍历右子树

前序遍历：ABDGHCEIF

②中序遍历
从根节点开始（先不访问），中序遍历根节点的左子树，然后访问根结点，最后中序遍历右子树。

中序遍历：GDHBAEICF

③后序遍历
从左到右先叶子结点后根结点的方式遍历左右子树，最后访问根结点。

后序遍历：GHDBIEFCA

接着看回代码

//二叉树
#ifndef BINARYTREE_H_
#define BINARYTREE_H_
using namespace std;
template<typename T>
struct BiTNode
{
    T data;
    BiTNode<T>   *lchild, *rchild;
    BiTNode(BiTNode<T>* pl = NULL, BiTNode<T>* pr = NULL)
    {
        lchild = pl;
        rchild = pr;
    }
};
template<typename T>
class BiTree
{
public:
    BiTree();
    //构造函数
    ~BiTree();
    //析构函数
    void PreOrderTraverse(BiTNode<T>* node);
    //前序遍历
    void InOrderTraverse(BiTNode<T>* node);
    //中序遍历
    void PostOrderTraverse(BiTNode<T>* node);
    //后序遍历
    BiTNode<T>* GetRoot();

private:
    BiTNode<T> *m_root;                   //根节点
    BiTNode<T> *createBiTree(T x[], int &n);           //二叉树的创建
    void Release(BiTNode<T>* root); //二叉树的删除
};
template<typename T>
BiTree<T>::BiTree()
{
    T ch[100];
    cin.getline(ch, 100);
    int num = 0;
    m_root = createBiTree(ch,num);
}
template<typename T>
BiTree<T>::~BiTree()
{
    Release(m_root);
}

template<typename T>
BiTNode<T>* BiTree<T>::createBiTree(T x[], int &n)
{
        T ch = x[n];
        n++;
        if (ch == '#')
        {
            return NULL;
        }
        else
        {
            BiTNode<T> *Node = new BiTNode<T>;
            Node->data = ch;
            Node->lchild = createBiTree(x,n);
            Node->rchild = createBiTree(x,n);
            return Node;
        }



}

template<class T>
void BiTree<T>::Release(BiTNode<T>* root)
{
    if (root != NULL)
    {

        Release(root->lchild);
        Release(root->rchild);
        delete root;
    }

}

template<class T>
void BiTree<T>::PreOrderTraverse(BiTNode<T>* node)
{

    if (node == NULL)
    {
        return;
    }
    else
    {
        cout << node->data;
        PreOrderTraverse(node->lchild);
        PreOrderTraverse(node->rchild);
    }
}
template<class T>
void BiTree<T>::InOrderTraverse(BiTNode<T>* node)
{
    if (node == NULL)
    {
        return;
    }
    else
    {
        InOrderTraverse(node->lchild);
        cout << node->data;
        InOrderTraverse(node->rchild);
    }
}
template<class T>
void BiTree<T>::PostOrderTraverse(BiTNode<T>* node)
{
    if (node == NULL)
    {
        return;
    }
    else
    {
        PostOrderTraverse(node->lchild);
        PostOrderTraverse(node->rchild);
        cout << node->data;
    }
}






template<class T>
BiTNode<T>* BiTree<T>::GetRoot()
{
    return m_root;
}

#endif