LeetCode 106. 从中序与后序遍历序列构造二叉树 | Python_根据一棵树的中序遍历与后序遍历构造二叉树python

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

---

题目来源：力扣（LeetCode）
https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal

题目

---

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

注意:

• 你可以假设树中没有重复的元素。

例如，给出

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

返回如下的二叉树：

    3
   / \
  9  20
    /  \
   15   7
1
2
3
4
5

解题思路

---

思路：递归

这道题中，主要考察的是如何利用 中序遍历 和 后序遍历 的特性去构造二叉树。其中相似的题目有：

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

回到这道题，这里先说下 中序遍历 和 后序遍历 的特性：

中序遍历 的输出顺序：左子树 → 根节点 → 右子树；
后序遍历 的输出顺序：左子树 → 右子树 → 根节点。

现在题目中给出 中序遍历 和 后序遍历 两者的输出序列，那么我们就可以根据两者的特性去构造二叉树。具体的思路如下：

• 根据后序遍历的输出顺序，可以确定末尾元素就是根节点；
• 在中序遍历的输出顺序中，根节点左右的序列分别对应左子树和右子树的节点。那么根据后序遍历确定的根节点，在中序遍历的序列中找到根节点对应的位置，进而确定左右子树的节点；
• 当确定左右子树节点时，此时要确定两者在中序遍历和后续遍历序列中的边界；
• 然后递归构造左右子树；
• 递归返回根节点 root。

这里单纯文字可能会有些拗口难懂，这里画出图示来进行理解：

在后序遍历的序列中，找到根节点；
在中序遍历序列中定位根节点的位置，进而确定左右子树的节点；

前面的思路中，还提及到边界的问题。根据前面的图示，我们可以直观看出左右子树的节点。但转换成代码时，我们需要明确一个范围，在这里用的是用索引位置去确定对应的边界。

这里说明下如何用索引位置去确定边界：

后续的文字内容含义：
中序序列 表示中序遍历的输出序列；
后序序列 表示后序遍历的输出序列。

• 先定义变量：
  • in_left: 在中序序列中的左边界，初始化为 0；
  • in_right: 在中序序列中的右边界，初始化为序列末尾索引位置；
  • in_root: 在中序序列中根节点的位置；
  • post_left：在后序序列中的左边界，初始化为 0；
  • post_right：在后序序列中的右边界，初始化为序列末尾索引位置；
  • post_root：在后序序列中根节点的位置。
• 当确定根节点之后，中序序列中，左右子树的节点分别在根节点的左右两侧，由此确定两者在中序序列的边界：
  • 左子树边界：
    • in_left：左边界不变；
    • in_right：右边界这里将变为根节点前一位元素对应的索引位置，也就是 in_right = in_root - 1。
  • 右子树边界：
    • in_left：左边界这里变为根节点后一位元素对应的索引位置，即 in_left = in_root + 1；
    • in_right：右边界不变。
• 当中序序列中确定左右子树的边界后，这里还需要确定在后序序列中的边界。因为后序序列输出顺序为左右中，那么只要确定左子树节点的个数，这里就能确定左子树的边界，同样也能进一步确定右子树的边界。
• 先求左子树的节点个数，由中序序列可得：size_of_left = in_root - in_left；
• 确定后序序列左右子树的边界：
  • 左子树边界：
    • post_left：保持不变；
    • post_right：根据中序序列确定的左子树节点个数，那么从左边界开始数，第 size_of_left 个节点就是此时的右边界，也就是 post_right = post_left + size_of_left - 1。
  • 右子树边界：
    • post_left：这里右子树紧跟着左子树，那么左边界也就是左子树右边界的下一个位置，即是 post_left + size_of_left；
    • post_right：序列末尾元素为根节点，所以此时右子树的右边界为根节点的前一位，也就是 post_root - 1。

这里同样用图示来进一步理解（额外添加一个节点，只为方便说明）：

在这里额外提一下，由后序序列得到根节点，要在中序序列中定位其位置。Python list 有内置函数 index()，但是这里查找时间为线性时间，可以考虑使用字典先存储中序序列中元素以及对应的索引位置，这样查找时间就会变为常数时间，也就是利用空间换时间。

以上就是具体的分析内容，具体的代码如下：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:

        def build_tree(in_left, in_right, post_left, post_right):
            if in_left > in_right:
                return
            
            # 后序序列末尾元素就是根节点
            post_root = post_right

            # 构造节点
            root = TreeNode(postorder[post_root])

            # 在中序序列定位根节点位置
            in_root = inorder_map[root.val]    
            
            # size_of_right = in_right - in_root
            # 获取中序序列中左子树的节点数
            size_of_left = in_root - in_left
            
            # root.left = build_tree(in_left, in_root-1, post_left, post_right-size_of_right-1)
            # 递归构建左子树
            root.left = build_tree(in_left, in_root-1, post_left, post_left+size_of_left-1)

            # root.right = build_tree(in_root+1, in_right, post_right-size_of_right, post_right-1)
            # 递归构建右子树
            root.right = build_tree(in_root+1, in_right, post_left+size_of_left, post_root-1)

            return root

        size = len(inorder)
        # 先用字典存储中序序列，元素及其对应的索引位置
        inorder_map = {}

        for i in range(size):
            inorder_map[inorder[i]] = i

        return build_tree(0, size-1, 0, size-1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

欢迎关注

---

公众号 【书所集录】