Update 0102.二叉树的层序遍历.md

problems/0102.二叉树的层序遍历.md

@@ -171,47 +171,60 @@ python3代码：
 
 
 ```python
-class Solution:
+# 利用长度法
-    """二叉树层序遍历迭代解法"""
+# Definition for a binary tree node.
-
+# class TreeNode:
-    def levelOrder(self, root: TreeNode) -> List[List[int]]:
+#     def __init__(self, val=0, left=None, right=None):
-        results = []
+#         self.val = val
-        if not root:
+#         self.left = left
-            return results
+#         self.right = right
-
 from collections import deque
-        que = deque([root])
+class Solution:
-
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
-        while que:
+        if not root:
-            size = len(que)
+            return []
+        queue = deque([root])
         result = []
-            for _ in range(size):
+        while queue:
-                cur = que.popleft()
+            level = []
-                result.append(cur.val)
+            for _ in range(len(queue)):
+                cur = queue.popleft()
+                level.append(cur.val)
                 if cur.left:
-                    que.append(cur.left)
+                    queue.append(cur.left)
                 if cur.right:
-                    que.append(cur.right)
+                    queue.append(cur.right)
-            results.append(result)
+            result.append(level)
-
+        return result
-        return results
 ```
-
 ```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 levelOrder(self, root: TreeNode) -> List[List[int]]:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
-        res = []
+        levels = []
-        def helper(root, depth):
+        self.helper(root, 0, levels)
-            if not root: return []
+        return levels
-            if len(res) == depth: res.append([]) # start the current depth
+    
-            res[depth].append(root.val) # fulfil the current depth
+    def helper(self, node, level, levels):
-            if  root.left: helper(root.left, depth + 1) # process child nodes for the next depth
+        if not node:
-            if  root.right: helper(root.right, depth + 1)
+            return
-        helper(root, 0)
+        if len(levels) == level:
-        return res
+            levels.append([])
+        levels[level].append(node.val)
+        self.helper(node.left, level + 1, levels)
+        self.helper(node.right, level + 1, levels)
+
+
 ```
 
+
+
 go:
 
 ```go