二叉树的模板类实现

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

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

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

二叉链树的结点定义为

templateT>
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_
#include 
using namespace std;

template<typename T>
struct BiTNode
{
    T data;
    BiTNode   *lchild, *rchild;
    BiTNode(BiTNode* pl = NULL, BiTNode* pr = NULL)
    {
        lchild = pl;
        rchild = pr;
    }
};
template<typename T>
class BiTree
{
public:
    BiTree();
    //构造函数
    ~BiTree();
    //析构函数
    void PreOrderTraverse(BiTNode* node);
    //前序遍历
    void InOrderTraverse(BiTNode* node);
    //中序遍历
    void PostOrderTraverse(BiTNode* node);
    //后序遍历
    void PrintNodeTraverse(BiTNode*node);
    //层次遍历
    BiTNode* GetRoot();

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

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



}

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

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

}

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

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

template<class T>
void BiTree::PrintNodeTraverse(BiTNode*node)
{
    vector*> vec;
    vec.push_back(node);
    int cur = 0;                     //保存的是之前所以层的结点数
    int last = 1;                    //加上待遍历层结点数后的总结点数
    while (cur//重置上一行结点数
        while (cur//做几次是由上一层的结点数决定的
        {
        cout << vec[cur]->data << " "; // 访问节点
            if (vec[cur]->lchild) // 当前访问节点的左节点不为空则压入
                vec.push_back(vec[cur]->lchild);
            if (vec[cur]->rchild) // 当前访问节点的右节点不为空则压入，注意左右节点的访问顺序不能颠倒
                vec.push_back(vec[cur]->rchild);
            cur++;
        }
        cout << endl;           //当cur=last时说明该层的结点已被遍历

    }
}



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

#endif