题目：

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

示例 1:

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]

示例 2:

输入: preorder = [-1], inorder = [-1]
输出: [-1]

提示:

1 <= preorder.length <= 3000
inorder.length == preorder.length
-3000 <= preorder[i], inorder[i] <= 3000
preorder 和 inorder 均 无重复 元素
inorder 均出现在 preorder
preorder 保证为二叉树的前序遍历序列
inorder 保证为二叉树的中序遍历序列

代码：

中序与前序

class Solution {
public:
    TreeNode* traversal(vector<int>& preorder, int preBegin, int preEnd, vector<int>& inorder, int inBgein, int inEnd){
        //第一步
        if(preBegin == preEnd) return NULL;

        // 第二步，前序数组的第一个元素是根节点
        int rootVal = preorder[preBegin];
        TreeNode* root = new TreeNode(rootVal);

        //叶子节点
        if (preEnd - preBegin == 1) return root;

        //第三步， 寻找切割点
        int i;
        for (i = inBgein; i < inEnd; i++){
            if (inorder[i] == rootVal) break;
        }

        //第四步，切割中序
        int leftInBegin = inBgein;
        int leftInEnd = i;

        int rightInBegin = i + 1;
        int rightInEnd = inEnd;

        //第五步，切割前序
        int leftPreBegin = preBegin + 1;
        int leftPreEnd = preBegin + 1 + (i - inBgein);

        int rightPreBegin = preBegin + 1 + (i - inBgein);
        int rightPreEnd = preEnd;

         //第六步，递归
        root->left = traversal(preorder, leftPreBegin, leftPreEnd, inorder, leftInBegin, leftInEnd);
        root->right = traversal(preorder, rightPreBegin, rightPreEnd, inorder, rightInBegin, rightInEnd);

        return root; 

    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (inorder.size() == 0 || preorder.size() == 0) return NULL;

        // 参数坚持左闭右开的原则
        return traversal(preorder, 0, preorder.size(), inorder, 0, inorder.size());
    }
};

中序与后序

class Solution {
public:
   TreeNode* traversal(vector<int>& inorder, vector<int>& postorder){
        //第一步，如果数组长度为0，则是空节点。(或许是后序数组只有一个节点的时候)
        if (postorder.size()==0) return NULL;

        //第二步，后序遍历数组的最后一个元素，就是根节点
        int rootVal = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootVal);

        //叶子节点，返回
        if (postorder.size() == 1) return root;

        //第三步，找切割点
        int i;
        for (i = 0; i < inorder.size(); i++){
            if (inorder[i] == rootVal) break;
        }

        //第四步，切割中序数组(左闭右开)
        vector<int> leftInorder(inorder.begin(), inorder.begin() + i);
        vector<int> rightInorder(inorder.begin() + i + 1, inorder.end());
       
        //第五步，切割后序数组
        vector<int> leftPostorder(postorder.begin(), postorder.begin() + i); // 左后序序列
        vector<int> rightPostorder(postorder.begin() + i, postorder.end() - 1); // 右后序序列

        //第六步，递归
        root->left = traversal(leftInorder, leftPostorder);
        root->right = traversal(rightInorder, rightPostorder);

        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size() == 0 && postorder.size() == 0) return NULL;
        return traversal(inorder, postorder);
    }
};