[LeetCode] 889. Construct Binary Tree from Preorder and Postorder Traversal

Given two integer arrays, preorder and postorder where preorder is the preorder traversal of a binary tree of distinct values and postorder is the postorder traversal of the same tree, reconstruct and return the binary tree.

If there exist multiple answers, you can return any of them.

Example 1:

Input: preorder = [1,2,4,5,3,6,7], postorder = [4,5,2,6,7,3,1]
Output: [1,2,3,4,5,6,7]

Example 2:

Input: preorder = [1], postorder = [1]
Output: [1]

Constraints:

• 1 <= preorder.length <= 30
• 1 <= preorder[i] <= preorder.length
• All the values of preorder are unique.
• postorder.length == preorder.length
• 1 <= postorder[i] <= postorder.length
• All the values of postorder are unique.
• It is guaranteed that preorder and postorder are the preorder traversal and postorder traversal of the same binary tree.

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

给定两个整数数组，preorder 和 postorder ，其中 preorder 是一个具有 无重复 值的二叉树的前序遍历，postorder 是同一棵树的后序遍历，重构并返回二叉树。

如果存在多个答案，您可以返回其中 任何 一个。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-postorder-traversal
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这道题跟105，106题类似，也是给你X序遍历的结果，请你返回原生的树。这道题给的是前序遍历和后序遍历，这里有几个特点需要强调

• 前序遍历的第一个节点/后序遍历的最后一个节点是根节点
• 在前序遍历中，节点的排列差不多是类似这样，[root, root.left......, root.right......]
• 在后序遍历中，节点的排列差不多是类似这样，[root.left......, root.right......, root]

在前序遍历中，由于第一个节点是根节点，所以前序遍历中第二个值一定来自于左子树，而且他是直接连接到根节点的左孩子。如果根节点是有左孩子的话，这个左孩子 root.left 会在后序遍历中左子树节点的最后一个被遍历到，这也就意味着在后序遍历结果里，这个节点之后的值都是来自于右子树了。我们依据这个信息来把左右子树分割开来。

这里我们利用一个 hashmap，记录后序遍历<节点，节点在 postorder 中的 index>，这样当我们找到例子中的节点2的时候，我们就知道了在后序遍历中从开头到 2 的这一段是左子树的节点；2 之后到 post.length - 2 这一段是右子树的节点。

时间O(n)

空间O(n)

Java实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode constructFromPrePost(int[] pre, int[] post) {
        // <postorder里每个元素, 下标>
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < post.length; i++) {
            map.put(post[i], i);
        }
        return helper(pre, 0, pre.length - 1, post, 0, post.length - 1, map);
    }

    private TreeNode helper(int[] preorder, int preStart, int preEnd, int[] postorder, int poStart, int poEnd,
            HashMap<Integer, Integer> map) {
        if (preStart > preEnd || poStart > poEnd) {
            return null;
        }
        TreeNode root = new TreeNode(preorder[preStart]);
        if (preStart + 1 <= preEnd) {
            // length of left subtree array
            int index = map.get(preorder[preStart + 1]) - poStart;
            root.left = helper(preorder, preStart + 1, preStart + 1 + index, postorder, poStart, poStart + index, map);
            root.right = helper(preorder, preStart + 1 + index + 1, preEnd, postorder, poStart + index + 1, poEnd - 1,
                    map);
        }
        return root;
    }
}

 

相关题目

105. Construct Binary Tree from Preorder and Inorder Traversal

106. Construct Binary Tree from Inorder and Postorder Traversal

889. Construct Binary Tree from Preorder and Postorder Traversal

1008. Construct Binary Search Tree from Preorder Traversal

LeetCode 题目总结