二叉树

Author: realJaydenCheng

2.data_structure/1. binary_tree.md renamed to 2.data_structure/1.binary_tree.md

@@ -203,6 +203,27 @@ class Solution:
         return levels
 ```
 
+关键点：想办法只遍历当前层。上面的方法是在遍历前，计算当前层的节点数。下面的方法是在遍历时，将新产生的节点加入一个临时数组，结束后再合并。双端队列并非关键。
+
+```python
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        outs = []
+        nodes = [root]
+        while nodes:
+            nodes_t = []
+            values = []
+            for node in nodes:
+                if node is None:
+                    continue
+                nodes_t.extend([node.left, node.right])
+                values.append(node.val)
+            if values:
+                outs.append(values)
+            nodes = nodes_t
+        return outs
+```
+
 ### 分治法应用
 
 先分别处理局部，再合并结果
@@ -225,7 +246,7 @@ class Solution:
 
 > 给定一个二叉树，找出其最大深度。
 
-- 思路 1：分治法
+- 思路 1：分治法（递归）
 
 ```Python
 class Solution:
@@ -270,55 +291,53 @@ class Solution:
 
 ```Python
 class Solution:
-    def isBalanced(self, root: TreeNode) -> bool:
- 
-        def depth(root):
-            
-            if root is None:
-                return 0, True
-            
-            dl, bl = depth(root.left)
-            dr, br = depth(root.right)
-            
-            return max(dl, dr) + 1, bl and br and abs(dl - dr) < 2
-        
-        _, out = depth(root)
-        
-        return out
+    def isBalanced(self, root: Optional[TreeNode]) -> bool:
+        balanced = True
+
+        def isBalancedS(root):
+            nonlocal balanced
+            if not root: return
+            stack = [(root, 1)]  # node, isTree
+            heights = {}
+            while balanced and stack:
+                node, isTree = stack.pop()
+                if isTree:
+                    stack.append((node, 0))
+                    if n:=node.right:
+                        stack.append((n, 1))
+                    if n:=node.left:
+                        stack.append((n, 1))
+                else:
+                    left_height = heights.get(node.left, 0) if node.left else 0
+                    right_height = heights.get(node.right, 0) if node.right else 0
+                    if abs(left_height - right_height) > 1:
+                        balanced = False
+                        return
+                    heights[node] = 1 + max(left_height, right_height)
+                    
+        def isBalancedC(node):
+            nonlocal balanced
+            if (not balanced) or (node is None) :
+                return 0
+
+            l_d = isBalancedC(node.left)
+            r_d = isBalancedC(node.right)
+
+            if abs(l_d - r_d) > 1:
+                balanced = False
+                return 0
+
+            return 1 + max(l_d, r_d)
+        
+        isBalancedS(root)
+        return balanced
 ```
 
 - 思路 2：使用后序遍历实现分治法的迭代版本
+- 为什么要后序遍历呢？观察上面的分治法（递归法），自然而然的就是后序遍历递归的变体。
+- 非递归法的难点：存储高度信息。解法：引入额外字典结构，以节点为键存储高度信息。
 
-```Python
-class Solution:
-    def isBalanced(self, root: TreeNode) -> bool:
-
-        s = [[TreeNode(), -1, -1]]
-        node, last = root, None
-        while len(s) > 1 or node is not None:
-            if node is not None:
-                s.append([node, -1, -1])
-                node = node.left
-                if node is None:
-                    s[-1][1] = 0
-            else:
-                peek = s[-1][0]
-                if peek.right is not None and last != peek.right:
-                    node = peek.right
-                else:
-                    if peek.right is None:
-                        s[-1][2] = 0
-                    last, dl, dr = s.pop()
-                    if abs(dl - dr) > 1:
-                        return False
-                    d = max(dl, dr) + 1
-                    if s[-1][1] == -1:
-                        s[-1][1] = d
-                    else:
-                        s[-1][2] = d
-        
-        return True
-```
+TODO: 似乎还可以使用中序遍历的非递归方法来写：[https://leetcode.cn/problems/balanced-binary-tree/solutions/2099334/tu-jie-leetcode-ping-heng-er-cha-shu-di-gogyi]
 
 ### [binary-tree-maximum-path-sum](https://leetcode-cn.com/problems/binary-tree-maximum-path-sum/)