数据结构——二叉树建树与遍历

从mooc上看到一张很好的图，说明了前序遍历，中序遍历，后序遍历之间的关系。

二叉树定义

template<class T>
class BinTreeNode
{
public:
    T data;
    BinTreeNode<T> *lchild, *rchild;
    BinTreeNode():lchild(NULL),rchild(NULL) {}
    BinTreeNode(T x, BinTreeNode<T> *l = NULL, BinTreeNode<T> *r = NULL)
        :data(x), lchild(l),rchild(r) {}
};

先序遍历

如果二叉树不为空，访问根节点，前序遍历左子树，前序遍历右子树，如上图×号。

//先序遍历
    void PreOrderTree(BinTreeNode<T> *root)
    {
        if(root != NULL)
        {
            cout<<root->data<<" ";
            PreOrderTree(root->lchild);
            PreOrderTree(root->rchild);
        }
    }

中序遍历

如果二叉树不为空，中序遍历左子树，访问根节点，中序遍历右子树，如上图星号。

//中序遍历
    void InOrderTree(BinTreeNode<T> *root)
    {
        if(root != NULL)
        {
            InOrderTree(root->lchild);
            cout<<root->data<<" ";
            InOrderTree(root->rchild);
        }
    }

后序遍历

如果二叉树不为空，后序遍历左子树，后序遍历右子树，访问根节点，如上图三角号。

//后序遍历
    void PostOrderTree(BinTreeNode<T> *root)
    {
        if(root != NULL)
        {
            PostOrderTree(root->lchild);
            PostOrderTree(root->rchild);
            cout<<root->data<<" ";
        }
    }

层序遍历

    void LevelOrderTree(BinTreeNode<T> *root)
    {
        queue<BinTreeNode<T> *> qu;
        qu.push(root);
        while(!qu.empty())
        {
            root = qu.front();
            cout<<root->data<<" ";
            if(root->lchild) qu.push(root->lchild);
            if(root->rchild) qu.push(root->rchild);
            qu.pop();
        }
        cout<<endl;
    }

顺序建树

    void CreatBinTree(BinTreeNode<T>* &root, T *dat,int di,int num) 
    //顺序数组建树
    {
        if(di>num)
            return;
        if(dat[di] != 0)
        {
            root = new BinTreeNode<T>(dat[di]);
            if(di*2 <= num)
                CreatBinTree(root->lchild, dat, di*2, num);
            if((di*2 +1) <= num)
                CreatBinTree(root->rchild, dat, di*2+1, num);
        }
        return;
    }

先序中序建树

    void CreatBinTree(BinTreeNode<T>* &root, T *pre, T *in, int lenth) 
    //先序中序建树
    {
        if(lenth<=0)
            return;
        root = new BinTreeNode<T>(pre[0]);
        int i = 0;
        while(i<lenth)
        {
            if(pre[0]==in[i]) break;
            i++;
        }
        CreatBinTree(root->lchild, pre+1, in, i);
        CreatBinTree(root->rchild, pre+i+1, in+i+1, lenth-i-1);
    }

层序中序建树

    void CreatBinTree(BinTreeNode<T>* &root, vector<T> in, 
                vector<T> leve, int inl, int inr) //层序中序建树
    {
        if(leve.size() == 0)
            return;
        root = new BinTreeNode<T>(leve[0]);
        int k;
        for(k=inl; k<inr; k++)
        {
            if(leve[0] == in[k])
                break;
        }
        vector<int> lleve;
        vector<int> rleve;
        for(unsigned int i=1; i<leve.size(); i++)
        {
            bool isleft = false;
            for(int j=inl; j<k; j++)
            {
                if(leve[i] == in[j])
                {
                    isleft = true;
                    break;
                }
            }

            if(isleft)
                lleve.push_back(leve[i]);
            else
                rleve.push_back(leve[i]);
        }
        CreatBinTree(root->lchild, in, lleve, inl, k-1);
        CreatBinTree(root->rchild, in, rleve, k+1, inr);
    }