二叉链表的实现（二叉树）

#include <iostream>
using namespace std;

template <class DataType>
struct BiNode {
    DataType data;
    BiNode<DataType>* lchild, * rchild;
};

template <class DataType>
class BiTree
{

private:
    BiNode<DataType>* root;    ///指向根节点的头指针
    BiNode<DataType>* Creat(BiNode<DataType>* bt);    ///构造函数调用
    void Release(BiNode<DataType>* bt);    ///析构函数调用
    void PreOrder(BiNode<DataType>* bt);    ///前序遍历函数调用
    void InOrder(BiNode<DataType>* bt);    ///中序遍历函数调用
    void PostOrder(BiNode<DataType>* bt);    ///后序遍历函数调用

public:
    BiTree() {   root = Creat(root);   } ///构造函数，建立一棵二叉树
    ~BiTree() {   Release(root);   }  ///析构函数，释放各节点的存储空间
    void PreOrder() {   PreOrder(root);   }  ///前序遍历二叉树
    void InOrder() {   InOrder(root);   }  ///中序遍历二叉树
    void PostOrder() {   PostOrder(root);   }  ///后序遍历二叉树
    void LeverOrder();   ///层序遍历二叉树

};

template <class DataType>
BiNode<DataType>* BiTree<DataType>::Creat(BiNode<DataType>* bt)     ///建立二叉树
{
    char ch;
    cin >> ch; ///输入信息，假设为字符
    if (ch == '#')
        bt = NULL; ///建立一棵空树
    else {
        bt = new BiNode;   bt->data = ch; ///生成一个节点，数据域为ch
        bt->lchild = Creat(bt->lchild); ///递归建立左子树
        bt->rchild = Creat(bt->rchild); /// 递归建立右子树
    }
    return bt;
}

template <class DataType>
void BiTree<DataType>::Release(BiNode<DataType>* bt)     ///释放二叉树
{
    if (bt) {
        Release(bt->lchild);   //释放左子树
        Release(bt->rchild);   ///释放右子树
        delete bt;   ///释放根节点
    }
}

template <class DataType>   ///前序遍历函数调用
void BiTree<DataType>::PreOrder(BiNode<DataType>* bt)
{
    if (bt == NULL) ///递归调用的结束条件
        return ;
    else {
        cout << bt->data; ///访问根节点bt的数据域
        PreOrder(bt->lchild);   ///前序递归遍历bt的左子树
        PreOrder(bt->rchild);   ///前序递归遍历bt的右子树
    }
}

template <class DataType>   ///中序遍历函数调用
void BiTree<DataType>::InOrder(BiNode<DataType>* bt)
{
    if (bt == NULL) ///递归调用的结束条件
        return ;
    else {
        InOrder(bt->lchild);   ///中序递归遍历bt的左子树
        cout << bt->data; ///访问根节点bt的数据域
        InOrder(bt->rchild);   ///中序递归遍历bt的右子树
    }
}

template <class DataType>   ///后序遍历函数调用
void BiTree<DataType>::PostOrder(BiNode<DataType>* bt)
{
    if (bt == NULL) ///递归调用的结束条件
        return ;
    else {
        PostOrder(bt->lchild);   ///后序递归遍历bt的左子树
        PostOrder(bt->rchild);   ///后序递归遍历bt的右子树
        cout << bt->data; ///访问根节点bt的数据域
    }
}

template <class DataType>   ///层序遍历函数调用
void BiTree<DataType>::LeverOrder()
{
    int front = -1,rear = -1; ///采用顺序队列，并假定不会发生上溢
    if (root == NULL)
        return ;   ///二叉树为空，算法结束
    Q[++rear] = root; ///根指针入队
    while (front != rear) { ///当队列非空时
        q = Q[++front]; ///出队
        cout << q->data;
        if (q->lchild)
            Q[++rear] = q->lchild;
        if (q->rchild)
            Q[++rear] = q->rchild;
    }
}

int main()
{

    return 0;
}