二叉树 前序遍历的非递归实现 中序遍历的非递归实现 后序遍历的非递归实现 创建二叉树

#ifndef _TREE_H
#define _TREE_H
template<class Type>
class BinTree;
template<class Type>
class BinTreeNode
{
friend BinTree<Type>;
BinTreeNode(Type d=Type(),BinTreeNode<Type>* l=NULL,BinTreeNode<Type>*r=NULL):data(d),leftChild(l),rightChild(r)
{}
~BinTreeNode()
{}
private:
Type data;
BinTreeNode<Type> *leftChild;
BinTreeNode<Type>* rightChild;
};
template<class Type>
class BinTree
{
public:
BinTree(Type ref)
{
    root=NULL;
    refval=ref;
}
void CreateTree()
{
    CreateTree(root);
}
void CreateTree(BinTreeNode<Type> *&t)
{
    Type Item;
    cin>>Item;
    if(Item==refval)
    t=NULL;
    else
    {
    t=new BinTreeNode<Type>(Item);
    CreateTree(t->leftChild);
    CreateTree(t->rightChild);
    }
}
void CreateTree(const Type *&str)
{
    CreateTree(root,str);
}
void CreateTree(BinTreeNode<Type> *&t,const Type* &str)//注意此处str传递引用
{
    if(*str==refval)
    t=NULL;
    else
    {
    t=new BinTreeNode<Type>(*str);
    CreateTree(t->leftChild,++str);
    CreateTree(t->rightChild,++str);
    }
}
~BinTree()
{
    destroyTree();
}
void destroyTree()
{
    destroyTree(root);
}
void destroyTree(BinTreeNode<Type> *&t)
{
    if(t!=NULL)
    {
        destroyTree(t->leftChild);
        destroyTree(t->rightChild);
        delete t;
        t=NULL;
    }
}
//
void PreOrder()const;
void PreOrder(BinTreeNode<Type>* t)const;
void PreOrder_1()const;
void PreOrder_1(BinTreeNode<Type> *t)const;
void InOrder()const;
void InOrder_1()const;
void InOrder(BinTreeNode<Type> *t)const;
void InOrder_1(BinTreeNode<Type> *t)const;
void PostOrder()const;
void PostOrder(BinTreeNode<Type> *t)const;
void PostOrder_1()const;
void PostOrder_1(BinTreeNode<Type> *t)const;
void leverOrder()const;
void leverOrder(BinTreeNode<Type>* t)const;

private:
BinTreeNode<Type> *root;
Type refval;
};
template<class Type>
void BinTree<Type>::PreOrder()const
{
    PreOrder(root);
}
template<class Type>
void BinTree<Type>::PreOrder(BinTreeNode<Type> *t)const//前序遍历的递归版本实现
{
    if(t!=NULL)
    {
        cout<<t->data<<"  ";
        PreOrder(t->leftChild);
        PreOrder(t->rightChild);
    }
}
template<class Type>
void BinTree<Type>::PreOrder_1()const
{
    PreOrder_1(root);
}
template<class Type>
void BinTree<Type>::PreOrder_1(BinTreeNode<Type> *t)const//前序遍历的非递归版本实现
{
    stack<BinTreeNode<Type>*  >st;
    if(t!=NULL)
    {
        st.push(t);
        while(!st.empty())
        {
            t=st.top();
            st.pop();
            cout<<t->data<<"  ";
            if(t->rightChild!=NULL)
            st.push(t->rightChild);
            if(t->leftChild!=NULL)
            st.push(t->leftChild);
        }
    }

}
template<class Type>
void BinTree<Type>::InOrder()const
{
    InOrder(root);
}
template<class Type>
void BinTree<Type>::InOrder(BinTreeNode<Type> *t)const//中序遍历的递归版本的实现
{
    if(t!=NULL)
    {
        InOrder(t->leftChild);
        cout<<t->data<<"  ";
        InOrder(t->rightChild);
    }
}
template<class Type>
void BinTree<Type>::InOrder_1()const
{
    InOrder_1(root);
}
template<class Type>
void BinTree<Type>::InOrder_1(BinTreeNode<Type> *t)const//中续遍历的非递归版本
{
    stack<BinTreeNode<Type>*  >st;
    do
    {
    while(t!=NULL)
    {
        st.push(t);
        t=t->leftChild;
    }
    if(!st.empty())
    {
        t=st.top();
        cout<<t->data<<"  ";
        st.pop();
        t=t->rightChild;
    }
    }while(!st.empty()||t!=NULL);
}
template<class Type>
void BinTree<Type>::PostOrder()const
{
PostOrder(root);
}
template<class Type>
void BinTree<Type>::PostOrder(BinTreeNode<Type> *t)const//后序遍历递归版本
{
if(t!=NULL)
{
    PostOrder(t->leftChild);
    PostOrder(t->rightChild);
    cout<<t->data<<"  ";
}
}
template<class Type>
void BinTree<Type>::PostOrder_1()const
{
PostOrder_1(root);
}

typedef enum{L,R}Tag;

template<class Type>
struct STNode
{
    BinTreeNode<Type>* node;
    Tag                tag;
};
template<class Type>
void BinTree<Type>::PostOrder_1(BinTreeNode<Type> *t)const//后序遍历的非递归版本实现
{
stack<STNode<Type> >st;
STNode<Type>  tm;
    do
    {
        while(t!=NULL)
        {
            tm.tag=L;
            tm.node=t;
            st.push(tm);
            t=t->leftChild;
        }
        if(!st.empty())
        {
            tm=st.top();
            if(tm.tag==L)
            {
                st.pop();
                tm.tag=R;
                st.push(tm);
                t=tm.node->rightChild;
            }
            else
            {    
                while(tm.tag==R&&!st.empty())
                {    
                    st.pop();
                    cout<<tm.node->data<<"  ";
                    if(!st.empty())
                    {
                    tm=st.top();
                    t=tm.node->rightChild;
                    }
                }
                if(!st.empty())
                {
                tm=st.top();
                tm.tag=R;
                st.pop();
                st.push(tm);
                }
            }
        }


    }while(!st.empty());

}

template<class Type>
void BinTree<Type>::leverOrder()const
{
    leverOrder(root);
}
template<class Type>
void BinTree<Type>::leverOrder(BinTreeNode<Type>* t)const//层次遍历
{
    queue<BinTreeNode<Type>*  > Q;
    if(t!=NULL)
    {
        Q.push(t);
    }
    while(!Q.empty())
    {
        t=Q.front();
        cout<<t->data<<"  ";
        Q.pop();
        if(t->leftChild!=NULL)
        Q.push(t->leftChild);
        if(t->rightChild!=NULL)
        Q.push(t->rightChild);
    }
    
}

template<class Type>
int BinTree<Type>::size()
{
    size(root);
}
template<class Type>
int BinTree<Type>::size(BinTreeNode<Type>* t)
{
    if(t==NULL)
    return 0;
    else
    {
        return size(t->leftChild)+size(t->rightChild)+1;
    }
}
template<class Type>
int BinTree<Type>::height()
{
    height(root);
}
template<class Type>
int BinTree<Type>::height(BinTreeNode<Type>* t)
{
    if(t==NULL)
    return 0;
    else
    {
        int left_H=height(t->leftChild);
        int right_H=height(t->rightChild);
        return (left_H>right_H?left_H:right_H)+1;
    }
}
template<class Type>
BinTreeNode<Type>* BinTree<Type>::Find(Type key)
{
    Find(root,key);
}
template<class Type>
BinTreeNode<Type>* BinTree<Type>::Find(BinTreeNode<Type>* t,Type key)
{
BinTreeNode<Type>*p;
    if(t!=NULL)
    {
        if(t->data==key)
        return t;
        else
         p=Find(t->leftChild,key);
        if(p==NULL)
        return Find(t->rightChild,key);
    }
    else
    return NULL;
}
template<class Type>
BinTreeNode<Type>* BinTree<Type>::Parent(Type key)
{
    Parent(root,key);
}
template<class Type>
BinTreeNode<Type>* BinTree<Type>::Parent(BinTreeNode<Type> *t,Type key)
{
    if(t==NULL)
    return t;
        BinTreeNode<Type>*p=Find(key);
        if(p==NULL||p==t)
        return NULL;
        if(t->leftChild==p||t->rightChild==p)
        return t;
        p=Parent(t->leftChild,key);
        if(p!=NULL)
        return p;
        else
        return Parent(t->rightChild,key);
}
#endif

#endif

#endif