根据前序遍历和中序遍历还原二叉树

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

#include<assert.h>
class Solution {
public:
    struct TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> in)
    {
        if (pre.empty() || in.empty()||pre.size()!=in.size())
               return NULL;
        int size = pre.size();
        vector<int> left_pre,left_in,right_pre,right_in;
        TreeNode* root = new TreeNode(pre[0]);
        int i = 0;
        for(;i<size;i++)
        {
         if(in[i] == pre[0])
            break;
        }

        if(i == size)
            assert(0);

        for(int j =0; j < i;j++)
        {
           left_in.push_back(in[j]);
           left_pre.push_back(pre[j+1]);
        }

        for(int j=i+1;j<size;++j)
        {
           right_in.push_back(in[j]);
           right_pre.push_back(pre[j]);
        }

        if(!left_in.empty())
        {
           root->left =  reConstructBinaryTree(left_pre,left_in);
        }
        if(!right_in.empty())
        {
            root->right = reConstructBinaryTree(right_pre, right_in);
        }
        return root;
    }



};

template<typename T>
struct BinaryTreeNode
{
    BinaryTreeNode(T data)
    : _data(data)
    , _pLeft(NULL)
    , _pRight(NULL)
    {}
    T _data;
    BinaryTreeNode<T>* _pLeft;
    BinaryTreeNode<T>* _pRight;
};

BinaryTree() :_proot(NULL){}
    BinaryTreeNode<T>* reConstructBinaryTree(char* prev, char * in, int len)
    {
        if (prev == NULL || in == NULL || len <= 0)
            return NULL;

        _proot = _reConstructBinaryTree(prev, prev + len - 1, in, in + len - 1);
        return _proot;
    }


BinaryTreeNode<T>* _reConstructBinaryTree(char* prev, \
        char* prev_end, char * in, char* in_end)
    {
        BinaryTreeNode<T>* root = new BinaryTreeNode<T>(prev[0]);
        if (prev == prev_end)
        {
            if (in == in_end&&*prev == *in)
                return root;
            else
                assert(0);
        }
        char* pin = in;

        while (pin <= in_end)//找到中序遍历的跟节点
        {
            if (*pin == *prev)
                break;
            else
            {
                pin++;
            }
        }

        if (pin == in_end&& *pin != *prev)
            assert(0);

        int leftlength = pin - in;
        char *leftprevend = prev + leftlength;
        if (leftlength > 0)//构建左子树
        {
            root->_pLeft = _reConstructBinaryTree(prev + 1, leftprevend, in, pin - 1);
        }
        if (leftlength < prev_end - prev)//构建右子树
        {
            root->_pRight = _reConstructBinaryTree(leftprevend + 1, prev_end, pin + 1, in_end);
        }

        return root;
    }

最后简单说一下思路，很简单。
1.前序的第一个是根
2.中序里找到根，前面的是左子树，后面的是右子树
3.递归的对左子树和右子树进行上述操作，
注意递归出口