从前序与中序遍历中构造二叉树；从中序与后序遍历构造二叉树（力扣105和106）

模仿官方105答案，写出106题

//105题（官方）
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int prelen = preorder.length;
        int inlen = inorder.length;
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < inlen; i++){
            map.put(inorder[i], i);
        }
        return buildTree(preorder, 0, prelen-1, map, 0, inlen - 1);
    }
    private TreeNode buildTree(int[] preorder, int preLeft, int preRight, Map<Integer, Integer> map, int inLeft, int inRight){
        if(preLeft > preRight || inLeft > inRight){
            return null;
        }
        int rootVal = preorder[preLeft];
        TreeNode root = new TreeNode(rootVal);
        int preIndex = map.get(rootVal);
        
        //递归左子树
        //先序遍历中从左边界开始+1开始的（postIndex - inLeft ）个元素[preLeft + 1, preIndex - inLeft + preLeft]就对应了中序遍历中从左边界到根节点-1的元素[inLeft, postIndex - 1]
        root.left = buildTree(preorder, preLeft + 1, preIndex - inLeft + preLeft, map, inLeft, preIndex - 1);
        //递归右子树
        //先序遍历中从左边界后的（postIndex - inLeft ）的位置开始到右边界的元素[preIndex - inLeft + preLeft + 1, preRight]对应中序遍历中的从根节点+1 到右边界的元素[postIndex + 1, inRight]
        root.right = buildTree(preorder, preIndex - inLeft + preLeft + 1, preRight, map, preIndex + 1, inRight);
        return root;
    }
}

//106（模仿105题就写出来）
class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        int inlen = inorder.length;
        int postlen = postorder.length;
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < inlen; i++){
            map.put(inorder[i], i);
        }
        return buildTree(postorder, 0, postlen - 1, map, 0, inlen - 1);
    }
    private TreeNode buildTree(int[] postorder, int postLeft, int postRight, Map<Integer, Integer> map, int inLeft, int inRight){
        if(postLeft > postRight || inLeft > inRight){
            return null;
        }
        int rootVal = postorder[postRight];
        TreeNode root = new TreeNode(rootVal);
        int postIndex = map.get(rootVal);

        //递归左子树
        //后序遍历中从左边界开始的（postIndex - inLeft ）个元素[postLeft, postIndex - inLeft + postLeft - 1]就对应了中序遍历中从左边界到根节点-1的元素[inLeft, postIndex - 1]
        root.left = buildTree(postorder, postLeft, postIndex - inLeft + postLeft - 1, map, inLeft, postIndex - 1);

        //递归右子树
        //后续遍历中从左边界后的（postIndex - inLeft ）的位置开始到右边界-1的元素[postIndex - inLeft + postLeft, postRight - 1]对应中序遍历中的从根节点+1 到右边界的元素[postIndex + 1, inRight]
        root.right = buildTree(postorder, postIndex - inLeft + postLeft, postRight - 1, map, postIndex + 1,inRight );
        return root;
    }
}