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

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

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

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

typedef enum{L,R}Tag;

template
struct STNode
{
    BinTreeNode* node;
    Tag                tag;
};
template
void BinTree::PostOrder_1(BinTreeNode *t)const//后序遍历的非递归版本实现
{
stack >st;
STNode  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<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
void BinTree::leverOrder()const
{
    leverOrder(root);
}
template
void BinTree::leverOrder(BinTreeNode* t)const//层次遍历
{
    queue*  > Q;
    if(t!=NULL)
    {
        Q.push(t);
    }
    while(!Q.empty())
    {
        t=Q.front();
        cout<data<<"  ";
        Q.pop();
        if(t->leftChild!=NULL)
        Q.push(t->leftChild);
        if(t->rightChild!=NULL)
        Q.push(t->rightChild);
    }
    
}

template
int BinTree::size()
{
    size(root);
}
template
int BinTree::size(BinTreeNode* t)
{
    if(t==NULL)
    return 0;
    else
    {
        return size(t->leftChild)+size(t->rightChild)+1;
    }
}
template
int BinTree::height()
{
    height(root);
}
template
int BinTree::height(BinTreeNode* 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
BinTreeNode* BinTree::Find(Type key)
{
    Find(root,key);
}
template
BinTreeNode* BinTree::Find(BinTreeNode* t,Type key)
{
BinTreeNode*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
BinTreeNode* BinTree::Parent(Type key)
{
    Parent(root,key);
}
template
BinTreeNode* BinTree::Parent(BinTreeNode *t,Type key)
{
    if(t==NULL)
    return t;
        BinTreeNode*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