Merge pull request #544 from KelvinG-611/0106.从中序与后序遍历序列构造二叉树

Update 0106.从中序与后序遍历序列构造二叉树.md

problems/0106.从中序与后序遍历序列构造二叉树.md

@@ -654,42 +654,67 @@ class Solution {
 ```
 
 Python：
+
 105.从前序与中序遍历序列构造二叉树
 
 ```python
-# Definition for a binary tree node.
-# class TreeNode:
-#     def __init__(self, val=0, left=None, right=None):
-#         self.val = val
-#         self.left = left
-#         self.right = right
-//递归法
 class Solution:
     def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
-            if not preorder: return None  //特殊情况
-            root = TreeNode(preorder[0])  //新建父节点
-            p=inorder.index(preorder[0])  //找到父节点在中序遍历的位置(因为没有重复的元素，才可以这样找)
-            root.left = self.buildTree(preorder[1:p+1],inorder[:p])  //注意左节点时分割中序数组和前续数组的开闭环
-            root.right = self.buildTree(preorder[p+1:],inorder[p+1:])  //分割中序数组和前续数组
+        # 第一步: 特殊情况讨论: 树为空. 或者说是递归终止条件
+        if not preorder: 
+            return None
+
+        # 第二步: 前序遍历的第一个就是当前的中间节点. 
+        root_val = preorder[0]
+        root = TreeNode(root_val)
+
+        # 第三步: 找切割点. 
+        separator_idx = inorder.index(root_val)
+
+        # 第四步: 切割inorder数组. 得到inorder数组的左,右半边. 
+        inorder_left = inorder[:separator_idx]
+        inorder_right = inorder[separator_idx + 1:]
+
+        # 第五步: 切割preorder数组. 得到preorder数组的左,右半边.
+        # ⭐️ 重点1: 中序数组大小一定跟前序数组大小是相同的. 
+        preorder_left = preorder[1:1 + len(inorder_left)]
+        preorder_right = preorder[1 + len(inorder_left):]
+
+        # 第六步: 递归
+        root.left = self.buildTree(preorder_left, inorder_left)
+        root.right = self.buildTree(preorder_right, inorder_right)
+
         return root
 ```
 106.从中序与后序遍历序列构造二叉树
 
 ```python
-# Definition for a binary tree node.
-# class TreeNode:
-#     def __init__(self, val=0, left=None, right=None):
-#         self.val = val
-#         self.left = left
-#         self.right = right
-//递归法
 class Solution:
     def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
-            if not postorder: return None  //特殊情况
-            root = TreeNode(postorder[-1]) //新建父节点
-            p=inorder.index(postorder[-1]) //找到父节点在中序遍历的位置*因为没有重复的元素，才可以这样找
-            root.left = self.buildTree(inorder[:p],postorder[:p]) //分割中序数组和后续数组
-            root.right = self.buildTree(inorder[p+1:],postorder[p:-1]) //注意右节点时分割中序数组和后续数组的开闭环
+        # 第一步: 特殊情况讨论: 树为空. (递归终止条件)
+        if not postorder: 
+            return None
+
+        # 第二步: 后序遍历的最后一个就是当前的中间节点. 
+        root_val = postorder[-1]
+        root = TreeNode(root_val)
+
+        # 第三步: 找切割点. 
+        separator_idx = inorder.index(root_val)
+
+        # 第四步: 切割inorder数组. 得到inorder数组的左,右半边. 
+        inorder_left = inorder[:separator_idx]
+        inorder_right = inorder[separator_idx + 1:]
+
+        # 第五步: 切割postorder数组. 得到postorder数组的左,右半边.
+        # ⭐️ 重点1: 中序数组大小一定跟后序数组大小是相同的. 
+        postorder_left = postorder[:len(inorder_left)]
+        postorder_right = postorder[len(inorder_left): len(postorder) - 1]
+
+        # 第六步: 递归
+        root.left = self.buildTree(inorder_left, postorder_left)
+        root.right = self.buildTree(inorder_right, postorder_right)
+
         return root 
 ```
 Go：