LeetCode 106: 从中序与后序遍历序列构造二叉树

题目:

根据一棵树的中序遍历与后序遍历构造二叉树。

Given inorder and postorder traversal of a tree, construct the binary tree.

注意:
你可以假设树中没有重复的元素。

Note:
You may assume that duplicates do not exist in the tree.

例如，给出

中序遍历 inorder = [9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]

返回如下的二叉树：

    3
   / \
  9  20
    /  \
   15   7

解题思路:

由两种遍历结果还原二叉树，是一种很经典的面试题型。其中中序遍历结果必须为已知才能还原二叉树。

本题为前序中序还原二叉树，回顾一下遍历顺序：

• 前序遍历：根结点 -> 左子结点 -> 右子结点

• 中序遍历：左子结点 -> 根结点 -> 右子结点

• 后序遍历：右子结点 -> 左子结点 -> 根结点

看中序遍历，找到根结点，一定可以分成左右子树。例如二叉树：

    3
   / \
  9  20
    /  \
   15   7

前序遍历 preorder = [3,9,20,15,7]
后序遍历 postorder = [9,15,7,20,3]

后序遍历倒数第一个结点 3 ，就是根结点，找到中序遍历中结点值为 3 的位置：

中序遍历 inorder = [9,3,15,20,7]
                     ^
以 3 为根结点划分两个左右子树：
    3
   / \
[9]  [15,20,7]

后序遍历倒数第二个结点 20，就是下一个子树的根结点，找到中序遍历中结点值为 20 的位置：

中序遍历 inorder ：
    3
   / \
 [9] [15,20,7]
         ^
以 20 为根结点划分两个左右子树：
    3
   / \
 [9] 20
    /  \
  [15] [7]

后序遍历倒数第三个结点 7，就是下一个子树的根结点，找到中序遍历中结点值为 7 的位置：

中序遍历 inorder ：
    3
   / \
 [9] 20
    /  \
  [15] [7]
        ^

结点 7 为叶子结点，不可再划分：
    3
   / \
 [9] 20
    /  \
  [15]  7

后序遍历倒数第四个结点 15，就是下一个子树的根结点，找到中序遍历中结点值为 15 的位置：

……

由此可知中序遍历必须为已知条件才可找出出每个子树的根结点。

递归解法:

Java:

class Solution {
    int[] postorder;
    int[] inorder;
    int index_post;
    HashMap<Integer, Integer> index_map = new HashMap<>();

    private TreeNode helper(int left, int right) {
        // 基线条件
        if (left > right)
            return null;
        // 按逆序逐个取后序遍历结果，并构造为根结点
        int root_val = postorder[index_post--];
        TreeNode root = new TreeNode(root_val);
        // 查找该根结点在中序遍历中的索引位置
        int index_in = index_map.get(root_val);
        // 构造递归
        root.right = helper(index_in + 1, right);
        root.left = helper(left, index_in - 1);
        return root;
    }
    public TreeNode buildTree(final int[] inorder, final int[] postorder) {
        this.inorder = inorder;
        this.postorder = postorder;
        this.index_post = postorder.length - 1;
        // 将中序遍历结果的结点值与索引位置映射
        for (int i = 0; i < inorder.length; i++)
            index_map.put(inorder[i], i);
        return helper(0, inorder.length - 1);
    }
}

Python:

class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
        def helper(left=0, right=len(inorder)-1) -> TreeNode:
            nonlocal index_post
            # 基线条件
            if left > right:
                return None
            # 按逆序逐个取后序遍历结果，并构造为根结点
            root_val = postorder[index_post]
            root = TreeNode(root_val)
            # 查找该根结点在中序遍历中的索引位置
            index_in = index_map[root_val]
            # 构造递归
            index_post -= 1
            root.right = helper(index_in+1, right)
            root.left = helper(left, index_in-1)
            return root

        index_post = len(inorder)-1
        # 将后序遍历结果的结点值与索引位置映射
        index_map = {val: index for index, val in enumerate(inorder)}
        return helper()