从前序与中序（后序与中序）遍历序列构造二叉树

基本思路：

前序 3 9 20 15 7
中序 9 3 15 20 7

前序的第一个元素为根节点，因为中序为左根右，所以通过中序的根节点3，知道左节点有1个，右节点有3个，通过左右节点的个数大小，再切割前序。

细节：1.索引统一好左闭右开区间

初始版本（复制数组）

class Solution {
     public TreeNode buildTree(int[] preorder, int[] inorder) {
        int n = preorder.length;
        if (n == 0) { // 空节点
            return null;
        }
        int leftSize = indexOf(inorder, preorder[0]); // 左子树的大小
        int[] pre1 = Arrays.copyOfRange(preorder, 1, 1 + leftSize);
        int[] pre2 = Arrays.copyOfRange(preorder, 1 + leftSize, n);
        int[] in1 = Arrays.copyOfRange(inorder, 0, leftSize);
        int[] in2 = Arrays.copyOfRange(inorder, 1 + leftSize, n);
        TreeNode root = new TreeNode(preorder[0]);
        root.left = buildTree(pre1, in1);
        root.right = buildTree(pre2, in2);
        return root;
    }

    // 返回 x 在 a 中的下标，保证 x 一定在 a 中
    private int indexOf(int[] a, int x) {
        for (int i = 0; ; i++) {
            if (a[i] == x) {
                return i;
            }
        }
    }
}

优化：
1.使用HashMap来保存中序遍历数组对于元素的下标
2.通过传入数组索引参数下标来实现复制数组的操作

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int n = preorder.length;
        Map index = new HashMap<>(n); // 预分配空间
        for (int i = 0; i < n; i++) {
            index.put(inorder[i], i);
        }
        TreeNode dfs = dfs(preorder, 0, n, 0, n, index);
        return dfs;
    }
    private TreeNode dfs(int[] preorder,int preleft,int preright, int inleft,int inright,Mapmap){
        if(preleft == preright){
            return null;
        }
        TreeNode root = new TreeNode(preorder[preleft]);
        int leftsize = map.get(preorder[preleft])-inleft;
        root.left = dfs(preorder,preleft+1,preleft+1+leftsize,inleft,inleft+leftsize,map);
        root.right = dfs(preorder,preleft+1+leftsize,preright,inleft+leftsize+1,inright,map);
        return root;
    }
}

class Solution {
    public TreeNode buildTree(int[] inorder,int[] postorder) {
        int n = postorder.length;
        Map index = new HashMap<>(n); // 预分配空间
        for (int i = 0; i < n; i++) {
            index.put(inorder[i], i);
        }

        TreeNode dfs = dfs(postorder, 0, n, 0, n, index);
        return dfs;
    }
    private TreeNode dfs(int[] postorder,int postleft,int postright, int inleft,int inright,Mapmap){
        
        if(postleft == postright){
            return null;
        }
        
        TreeNode root = new TreeNode(postorder[postright-1]);
        //左子树的长度
        int leftsize = map.get(postorder[postright-1])-inleft;
        root.left = dfs(postorder,postleft,postleft+leftsize,inleft,inleft+leftsize,map);
        root.right = dfs(postorder,postleft+leftsize,postright-1,inleft+leftsize+1,inright,map);
        return root;
    }
}