根据二叉树遍历结果构建二叉树

LeetCode105. 从前序与中序遍历序列构造二叉树

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int len = inorder.length;
        if(len == 0) return null;

        HashMap<Integer, Integer> rootIndMap = new HashMap<>();
        for (int i = 0; i < len; i++) {
            rootIndMap.put(inorder[i], i);
        }

        return myBuildTree(0, len - 1, 0, len - 1, rootIndMap, preorder);
    }

    /**
     * 前序遍历结果 [根节点，[左子树前序遍历的结果]，[右子树前序遍历的结果]]
     * 中序遍历结果 [[左子树中序遍历的结果]，根节点，[右子树中序遍历的结果]]
     *      区间左闭右闭
     * @param preBegin  前序遍历开始的索引 (根节点的位置)
     * @param preEnd    前序遍历结束的索引
     * @param inBegin   中序遍历开始的索引
     * @param inEnd     中序遍历结束的索引
     * @param rootIndMap    根节点在中序遍历结果中的索引，根节点索引 - 开始索引 = 左子树的大小
     * @param preorder  前序遍历的结果
     * @return
     */
    private TreeNode myBuildTree(int preBegin, int preEnd, int inBegin, int inEnd, HashMap<Integer, Integer> rootIndMap, int[] preorder) {
        if(preBegin > preEnd)
            return null;

        int val = preorder[preBegin];
        TreeNode root = new TreeNode(val);
        // 根结点在中序遍历结果数组中的位置
        Integer inRootInd = rootIndMap.get(val);

        int leftSize = inRootInd - inBegin;
        int leftBegin = preBegin + 1;
        int rightBegin = leftBegin + leftSize;

        root.left = myBuildTree(leftBegin, leftBegin + leftSize - 1, inBegin, inRootInd - 1, rootIndMap, preorder);
        root.right = myBuildTree(rightBegin, preEnd, inRootInd + 1, inEnd, rootIndMap, preorder);

        return root;
    }

LeetCode106. 从中序与后序遍历序列构造二叉树

    public TreeNode buildTree(int[] inorder, int[] postorder) {
        int len = inorder.length;
        if(len == 0) return null;

        HashMap<Integer, Integer> inRootIndMap = new HashMap<>();
        for (int i = 0; i < len; i++) {
            inRootIndMap.put(inorder[i], i);
        }

        return myBuildTree(0, len - 1, 0, len - 1, postorder, inRootIndMap);
    }

    /**
     *
     *      区间左闭右闭
     * @param inBegin
     * @param inEnd
     * @param postBegin
     * @param postEnd
     * @param postorder
     * @param inRootIndMap
     * @return
     */
    private TreeNode myBuildTree(int inBegin, int inEnd, int postBegin, int postEnd, int[] postorder, HashMap<Integer, Integer> inRootIndMap) {
        if(postBegin > postEnd)
            return null;

        int val = postorder[postEnd];
        TreeNode root = new TreeNode(val);

        int inRootInd = inRootIndMap.get(val);
        int rightSize = inEnd - inRootInd;
        int rightBegin = postEnd - rightSize;

        root.right = myBuildTree(inRootInd + 1, inEnd, rightBegin, postEnd - 1, postorder, inRootIndMap);
        root.left = myBuildTree(inBegin, inRootInd - 1, postBegin, rightBegin - 1, postorder, inRootIndMap);

        return root;
    }

LeetCode889. 根据前序和后序遍历构造二叉树

    public TreeNode constructFromPrePost(int[] pre, int[] post) {
        int len = post.length;
        if (len == 0) return null;

        HashMap<Integer, Integer> postRootIndMap = new HashMap<>();
        for (int i = 0; i < len; i++) {
            postRootIndMap.put(post[i], i);
        }

        return myBuildTree(0, len - 1, 0, len - 1, postRootIndMap, pre);
    }

    /**
     * 区间左闭右闭
     * @param preBegin
     * @param preEnd
     * @param postBegin
     * @param postEnd
     * @param postRootIndMap
     * @param pre
     * @return
     */
    private TreeNode myBuildTree(int preBegin, int preEnd, int postBegin, int postEnd, HashMap<Integer, Integer> postRootIndMap, int[] pre) {
        if (preBegin > preEnd || postBegin > postEnd)
            return null;

        int val = pre[preBegin];
        TreeNode root = new TreeNode(val);

        int preLeftBegin = preBegin + 1;

        if(preLeftBegin > preEnd)
            return root;

        Integer postLeftEnd = postRootIndMap.get(pre[preLeftBegin]);
        int leftSize = postLeftEnd - postBegin + 1;

        root.left = myBuildTree(preLeftBegin, preLeftBegin + leftSize - 1, postBegin, postLeftEnd, postRootIndMap, pre);
        root.right = myBuildTree(preLeftBegin + leftSize, preEnd, postLeftEnd + 1, postEnd - 1, postRootIndMap, pre);

        return root;
    }

小总结

这三道题的核心思想都是一样的，先在其中一种遍历结果中找到 根节点，再在另一种遍历结果中找到根节点对应的索引，通过根节点的索引和遍历结果开始或结束的索引，就能够得到 左子树或右子树的大小 以及它们对应遍历结果的 开始索引和结束索引，然后再根据遍历结果(通常用 前序遍历 或 后序遍历) 递归构造二叉树。