数据结构5-二叉树

#pragma once
#include <stack>
#include <queue>
using namespace std;


template<typename T>
struct BiTNode {
    BiTNode<T> *lChild;
    BiTNode<T> *rChild;
    T _data;
};

template<typenam T>
struct StackElem
{
    BiTNode<T> *p;
    int flag;
};
template<typename T>
void Visit(BiTNode<T> *c)
{
    cout << c->_data << " ";
}
template<typename T>
class BiTree {
protected:
    BiTNode<T> *_root;
private:
    void DestroyBiTree(BiTNode<T>* &t);
    void CreateBiTree(BiTNode<T> *&t);
public:
    BiTree() { _root = NULL; }
    ~BiTree() { DestroyBiTree(_root);}
    //二叉树的创建
    void CreateBiTreeFromFile(ifstream inf);
    void CreateBiTreeFromConsole();
    //常用的方法
    bool IsBiTreeEmpty()const { return !_root; }
    BiTNode<T>* Root()const { return _root; }
    T GetValue(BiTNode<T>* &t)const { return t->data; }
    void SetValue(BiTNode<T>* &t, T value) { t->data = value; }
    void GetChild(BiTNode<T>* p, BiTNode<T>* &left, BiTNode<T>* &right)const { left = p->lChild; right = p->rChild; }
    bool Sibling(BiTNode<T>*p,BiTNode<T>* &sib,bool &LR)const;
    BiTNode<T>* GetParent(BiTNode<T>* &t)const;
    int GetBiTreeDepth(BiTNode<T>* t)const;
    //非递归实现二叉树的遍历
    void PreOrderTraverse(void(*visit)(BiTNode<T>* &t))const;
    void InOrderTraverse(void(*visit)(BiTNode<T>* &t))const;
    void PostOrderTraverse(void(*visit)(BiTNode<T>* &t))const;
    void LevelOrderTraverse(void(*vistit)(BiTNode<T> *))const;
    //递归实现二叉树的遍历
    void OrderTraverse(BiTNode<T>* t,int mode,void (*visit)(BiTNode<T>*))const;

};
template<typename T>
void BiTree<T>::DestroyBiTree(BiTNode<T>* &t)
{
    if (t) {
        DestroyBiTree(t->lChild);
        DestroyBiTree(t->rChild);
        delete t; t = NULL;
    }
}
template<typename T>
void BiTree<T>::CreateBiTree(BiTNode<T>* &t)
{
    T ch;
    cin >> ch;
    if (ch == '#') {
        t = NULL;
    }
    else {
        t = new BiTNode<T>;
        t->_data = ch;
        CreateBiTree(t->lChild);
        CreateBiTree(t->rChild);
    }
}
template<typename T>
void BiTree<T>::CreateBiTreeFromFile(ifstream inf)
{
    T e;
    inf >> e;
    if (e == '#')
        return;
    _root = new BiTNode<T>;
    assert(_root != NULL);
    _root->_data = e;
    BiTree<T> left, right;
    left.CreateBiTreeFromFile(f);
    right.CreateBiTreeFromFile(f);
    _root->lChild = left._root; left._root = NULL;
    _root->rChild = right._root; right._root = NULL;
}
template<typename T>
void BiTree<T>::CreateBiTreeFromConsole()
{
    CreateBiTree(_root);
}
template<typename T>
bool BiTree<T>::Sibling(BiTNode<T>* p, BiTNode<T>*& sib, bool & LR) const
{
    BiTNode<T> *q = Parent(p);
    if (q == NULL)return false;
    if (q->lChild == p) {
        sib = q->rChild;
        LR = true;
    }
    else {
        sib = q->lChild;
        LR = false;
    }
    (sib != NULL) ? return true : return false;
}
template<typename T>
BiTNode<T>* BiTree<T>::GetParent(BiTNode<T>* &t)const
{
    if (t == _root)return NULL;
    queue<BiTNode<T>*> q;
    BiTNode<T>* p = NULL;
    q.push(_root);
    while (!q.empty()) {
        p = q.front(); q.pop();
        if ((p->lChild && (p->lChild == t || p->lChild->_data == t->_data)) || 
            (p->rChild && (p->rChild == t || p->rChild->_data == t->_data))) {
            return p;
        }
        if (p->lChild) {
            q.push(p->lChild);
        }
        if (p->rChild) {
            q.push(p->rChild);
        }
    }
    return NULL;
}
template<typename T>
int BiTree<T>::GetBiTreeDepth(BiTNode<T>* t)const
{
    if (t) {
        int l = GetBiTreeDepth(t->lChild);
        int r = GetBiTreeDepth(t->rChild);
        return l > r ? (l + 1) : (r + 1);
    }
    return 0;
}
template<typename T>
void BiTree<T>::PreOrderTraverse(void(*visit)(BiTNode<T>* &t))const
{
    stack<BiTNode<T>*> s;
    BiTNode<T> *t = _root;
    s.push(NULL);
    while (t) {
        while (t) {
            visit(t);
            s.push(t);
            t = t->lChild;
        }
        t = s.pop();
        t = t->rChild;
    }
    /*
    while(t){
        visit(t);
        if(t->rChild)s.push(t->rChild);
        if(t->lChild)t = t->lChild;
        else{
            t = s.top();
            s.pop();
        }
    }
    */
}
template<typename T>
void BiTree<T>::InOrderTraverse(void(*visit)(BiTNode<T>* &t))const
{
    stack<BiTNode<T>*> s;
    BiTNode<T> *t = _root;
    s.push(NULL);
    while (t) {
        while (t) {
            s.push(t);
            t = t->lChild;
        }
        t = s.pop();
        visit(t);
        t = t->rchild;
    }
    /*
    while(!(t == NULL && s.empty())){
        if(t->lChild)
        {
            t = t->lChild;
            s.push(t);
        }
        else{
            t = s.top();
            s.pop();
            visit(t);
            t = t->rChild;
        }
    }
    */
}
template<typename T>
void BiTree<T>::PostOrderTraverse(void(*visit)(BiTNode<T>* &t))const
{
    stack<StackElem<T>> s;
    StackElem<T> se;
    BiTNode<T> *t = _root;

    while (!(t == NULL && s.empty())) {
        while (t) {
            se.p = t; se.flag = 0;
            s.push(se);
            t = t->lChild;
        }
        se = s.top(); s.pop(); t = se.p;
        if (se.flag == 0) {
            se.flag = 1; s.push(se); t = t->rChild;
        }
        else {
            visit(t); t = NULL;
        }
    }
}
template<typename T>
void BiTree<T>::LevelOrderTraverse(void (*visit)(BiTNode<T>*))const
{
    queue<BiTNode<T> *> q;
    q.push(_root);
    BiTNode<T> *p = NULL;
    while (!q.empty()) {
        p = q.front(); q.pop();
        visit(p);
        if (p->lChild)q.push(p->lChild);
        if (p->rChild)q.push(p->rChild);
    }
}
template<typename T>
void BiTree<T>::OrderTraverse(BiTNode<T>* t, int mode, void(*visit)(BiTNode<T>*))const
{
    if (t) {
        if (mode == 0) {
            visit(t);
        }
        OrderTraverse(t->lChild, mode, visit);
        if (mode == 1) {
            visit(t);
        }
        OrderTraverse(t->rChild, mode, visit);
        if (mode == 2) {
            visit(t);
        }
    }
}