深度优先搜索

class Solution {

    public TreeNode buildTree(int[] inorder, int[] postorder) {

        return buildSonTree(inorder, 0, inorder.length, postorder, 0, postorder.length);
    }

    /**
     * 左闭右开区间
     * 将后序数组的最后一个元素作为根节点，然后找到中序数组中根节点的位置，将其一分为二
     * 然后根据左右子数组的长度，将后序数组也分成相等长度的左右子数组，继续递归分割（因为两个数组长度相等）
     * 定义分割方法，分别传入两个数组，和要分割数组的边界
     */
    public TreeNode buildSonTree(int[] inorder, int inLeft, int inRight, int[] postorder, int postLeft, int postRight){

        /**
         * 如果数组为空，或者只有一个元素，则该节点就是根节点
         */
        if (inRight - inLeft == 0){
            return null;
        }

        if (inRight - inLeft == 1){
            return new TreeNode(inorder[inLeft]);
        }

        /**
         * 否则记录下根节点的位置
         */
        int rootVal = postorder[postRight - 1];
        TreeNode root = new TreeNode(rootVal);

        int index = 0;

        for (int i = inLeft; i < inRight; i++) {

            if (inorder[i] == rootVal){

                index = i;
                break;
            }
        }

        /**
         * 然后传入新的数组边界，继续分割
         */
        root.left = buildSonTree(inorder, inLeft, index, postorder, postLeft, postLeft + index - inLeft);
        root.right = buildSonTree(inorder, index + 1, inRight, postorder, postLeft + index - inLeft, postRight - 1);

        return root;
    }
}

/**
 * 时间复杂度 O(n)
 * 空间复杂度 O(n)
 */

https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/