剑指Offer系列-面试题6：重建二叉树

题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建出二叉树并输出它的头结点。

代码没有重新写，是15年秋数据结构的OJ题，徒手写的队列和二叉树的类。

#include <iostream>

using namespace std;
/***********************************Queue******************************/
template<class T>
struct LinkNode
{
    T data;
    LinkNode<T> *next;
    LinkNode(LinkNode<T> *top = NULL)
    {
        next = top;
    }
    LinkNode(T elem,LinkNode<T> *top = NULL)
    {
        data = elem;
        next = top;
    }
};

template<class T>
class Queue
{
private:
    LinkNode<T> *first,*rear;
public:
    Queue()
    {
        rear = first = new LinkNode<T>;
    }

    ~Queue()
    {
        makeEmpty();
    }

    bool EnQueue(const T& elem)
    {
        LinkNode<T>* newNode = new LinkNode<T>(elem);
        if(!newNode)
            return false;
        if(IsEmpty())
            first->next = rear = newNode;
        rear->next=newNode;
        rear=rear->next;
        return true;
    }

    bool DeQueue(T& elem)
    {
        LinkNode<T>* del;
        if(first==rear)
            return false;
        del=first->next;
        elem=del->data;
        first->next=del->next;
        if(first->next==NULL)
            rear=first;
        delete del;
        return true;
    }

    bool IsEmpty()
    {
        return (first == rear)? true:false;
    }

    void makeEmpty()
    {
        LinkNode<T> *p = first->next;
        if(!p)
            return;
        while(first->next)
        {
            first = p->next;
            delete p;
            p = first->next;
        }
    }

};
/*********************************BinaryTree***************************/
template<class T>
struct BinTreeNode
{
    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;
    }
};

template<class T>
class BinaryTree
{
private:
    BinTreeNode<T>* root;
    void destroy(BinTreeNode<T>* root)
    {
        if(root)
        {
            destroy(root->lchild);
            destroy(root->rchild);
            delete root;
        }
    }
public:
    BinaryTree()
    {
        root = NULL;
    }
    BinaryTree(BinTreeNode<T>* p)
    {
        root = p;
    }
    BinaryTree(T *elems, int n)         ///构造函数，层序输入，建立满二叉树
    {
        root = new BinTreeNode<T> [n];
        for(int i=0; i<n; i++)
        {
            root[i].data=elems[i];
            if(2*i+1<n)
            {
                root[i].lchild=&root[2*i+1];
            }
            else
            {
                root[i].lchild=NULL;
            }
            if(2*i+2<n)
            {
                root[i].rchild=&root[2*i+2];
            }
            else
            {
                root[i].rchild=NULL;
            }
        }
    }
    BinaryTree(BinaryTree<T>& a);
    ~BinaryTree()
    {
    }
    BinTreeNode<T> *visitRoot()
    {
        return root;
    }
    bool isEmpty()
    {
        return (root == NULL)?true:false;
    }
    BinTreeNode<T> *Parent(BinTreeNode<T>* current)
    {
        return (root == NULL || root == current)?NULL:Parent(root,current);
    }
    BinTreeNode<T> *LeftChild(BinTreeNode<T>* current)
    {
        return (current != NULL)?current->lchild:NULL;
    }
    BinTreeNode<T> *RightChild(BinTreeNode<T>* current)
    {
        return (current != NULL)?current->rightChild:NULL;
    }
    void PreOrder(BinTreeNode<T>* p = visitRoot())   ///递归前序遍历
    {
        if(p)
        {
            cout << p->data << " ";
            PreOrder(p->lchild);
            PreOrder(p->rchild);
        }
    }
    void InOrder(BinTreeNode<T>* p = visitRoot())   ///递归中序遍历
    {
        if(p)
        {
            InOrder(p->lchild);
            cout << p->data << " ";
            InOrder(p->rchild);
        }
    }
    void PostOrder(BinTreeNode<T>* p = visitRoot())   ///递归后序遍历
    {
        if(p)
        {
            PostOrder(p->lchild);
            PostOrder(p->rchild);
            cout << p->data << " ";
        }
    }
    void LevelOrder(BinTreeNode<T>* p) ///非递归层序遍历
    {
        Queue<BinTreeNode<T>*> q;
        BinTreeNode<T>* pre = root;
        q.EnQueue(pre);
        cout << pre->data << " ";
        while(!q.IsEmpty())
        {
            q.DeQueue(pre);
            if(pre->lchild != NULL)
            {
                q.EnQueue(pre->lchild);
                cout << pre->lchild->data << " ";
            }
            if(pre->rchild != NULL)
            {
                q.EnQueue(pre->rchild);
                cout << pre->rchild->data << " ";
            }
        }
    }


};

template <class T>
BinTreeNode<T> *CreateBinTree(T* VLR, T* LVR, int n)   ///根据前序和中序递归重建二叉树
{
    if(n == 0)
        return NULL;
    int k = 0;
    while(VLR[0] != LVR[k])
        k++;
    BinTreeNode<T> *t = new BinTreeNode<T>(VLR[0]);
    t->lchild = CreateBinTree(VLR+1,LVR,k);
    t->rchild = CreateBinTree(VLR+k+1,LVR+k+1,n-k-1);
    return t;
}

int main()
{
    int n = 8;
    int a[8] = {1,2,4,7,3,5,6,8};   ///前序序列
    int b[8] = {4,7,2,1,5,3,8,6};   ///中序序列

    BinTreeNode<int> *p = CreateBinTree(a,b,n);
    BinaryTree<int> tree(p);
    tree.LevelOrder(p);     ///层序输出
    cout << endl;
    tree.PostOrder(p);      ///后序输出

    return 0;
}