C++实现树的基本操作，界面友好，操作方便，运行流畅，运用模板

 Ⅰ.说明：

    1.采用左孩子右兄弟的方式，转化为二叉树来实现。

    2.树的后根遍历与二叉树的中根遍历即有联系又有区别，请读者注意分析体会。

Ⅱ.功能：

    1.创建树并写入数据

    2.先根遍历树

    3.计算树高

    4.后根遍历树

    5.层次遍历树

    6.搜索数据域为某值的结点

    7.删除数据域为某值的结点及其子树

    8.销毁树

Ⅲ.代码：

//.h文件

#ifndef TREE_H
#define TREE_H

#include<iostream>
#include<iomanip>
using namespace std;

template<typename T>       //树结点
struct Node            
{
    T data;
    Node<T> *left, *right;
    Node(const T& item);
};

template<typename T>        //树结点初始化
Node<T>::Node(const T& item)  
{
    data = item;
    left = NULL;
    right = NULL;
}

template<typename T>      //辅助队列，计算树高 Quefh：queue for high    
struct Quefh
{
    Node<T>* nodrs;       //node's adress
    int leve;             //level
    Quefh<T>* hnext;
    Quefh(Node<T>* nds, int lel, Quefh<T>* hnxt);
};

template<typename T>        //Quefh构造函数
Quefh<T>::Quefh(Node<T>* nds, int lel, Quefh<T>* hnxt)
{
    nodrs = nds;
    leve = lel;
    hnext = hnxt;
}

template<typename T>        //辅助队列，查找结点 Quefs：queue for search
struct Quefs                //此队列同时用于层次遍历   
{
    Node<T>* snodrs;        //Quefs::node's adress
    Quefs<T>* snext;
    Quefs(Node<T>* snds, Quefs<T>* snxt);
};

template<typename T>          //Quefs构造函数
Quefs<T>::Quefs(Node<T>* snds, Quefs<T>* snxt)
{
    snodrs = snds;
    snext = snxt;
}

template<typename T>           //辅助队列，删除结点 Quefd：queue for delete
struct Quefd                   //此队列同时在后根遍历中做临时堆栈
{
    T ddata;
    Quefd<T>* dnext;
    Quefd(const T& ddt, Quefd<T>* dnxt);
};

template<typename T>           //Quefd构造函数
Quefd<T>::Quefd(const T& ddt, Quefd<T>* dnxt)
{
    ddata = ddt;
    dnext = dnxt;
}

template<typename T>           //树类
class Tree
{
private:
    Node<T>* root;
    Quefh<T> *hhead, *htail;
    Quefs<T> *shead, *stail;
    Quefd<T> *dhead, *dtail,*top;
    int size;
    int hsize;
    int ssize;
    int dsize;
public:
    Tree();
    ~Tree();
    void Operate();
private:
    Node<T>* Creat(Node<T>* &rt);
    void Destory(Node <T>* t);
    void Addqh(Node<T>* pn, int levl);
    void Addqs(Node<T>* spn);  
    void Addqd(const T& dedata);
    void Outqh(Node<T>* &pn, int &levl);
    Node<T>* Outqs();
    void Delqh();
    void Delqs();
    void Delqd();
    int Couhg(Node<T>* t);
    Node<T>* GetFather(Node<T>* t, Node<T>* p);
    void Search(Node<T>* t, const T& item, bool& sign);
    void Del(Node<T>* t);
    void D_ShowAll(Quefd<T>* dheader);
    void FiRoTra(Node<T>* rt, int& ct);
    void MiRoTra(Node<T>* rt, int& ct);
    void LeveTra(Node<T>* t);
    void ShowAll(Quefs<T>* header);
    Node<T>* Push(Node<T>* t);
    void PopAll(int& ct);
};

template<typename T>           //类构造函数
Tree<T>::Tree()
{
    root = NULL;
    hhead = NULL;
    htail = NULL;
    shead = NULL;
    stail = NULL;
    dhead = NULL;
    dtail = NULL;
    top = NULL;
    size = 0;
    hsize = 0;
    ssize = 0;
    dsize = 0;
}

template<typename T>          //类析构函数
Tree<T>::~Tree()
{
    Destory(root);
}

template<typename T>             //Quefh入队一个结点
void Tree<T>::Addqh(Node<T>* pn, int levl)
{
    if (!hhead){ hhead = htail = new Quefh<T>(pn, levl, NULL); hsize = 1; }
    else
    {
        htail->hnext = new Quefh<T>(pn, levl, NULL);
        htail = htail->hnext;
        hsize++;
    }
}

template<typename T>             //Quefh出队一个结点
void Tree<T>::Outqh(Node<T>* &pn, int &levl)
{
    pn = hhead->nodrs;              
    levl = hhead->leve;
    Quefh<T>* itemph;
    itemph = hhead;
    hhead = hhead->hnext;
    delete itemph;
    hsize--;
}

template<typename T>           //清空队列Quefh
void Tree<T>::Delqh()
{
    while (hhead)
    {
        Quefh<T>* itemphd;
        itemphd = hhead; hhead = hhead->hnext; delete itemphd;
    }
}

template<typename T>             //Quefs入队一个结点
void Tree<T>::Addqs(Node<T>* spn)
{
    if (!shead){ shead = stail = new Quefs<T>(spn, NULL); ssize = 1; }
    else
    {
        stail->snext = new Quefs<T>(spn, NULL);
        st