diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index 26f0ae2d..e777c2a4 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -171,47 +171,60 @@ python3代码：
 
 
 ```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
+from collections import deque
 class Solution:
-    """二叉树层序遍历迭代解法"""
-
-    def levelOrder(self, root: TreeNode) -> List[List[int]]:
-        results = []
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
         if not root:
-            return results
-
-        from collections import deque
-        que = deque([root])
-
-        while que:
-            size = len(que)
-            result = []
-            for _ in range(size):
-                cur = que.popleft()
-                result.append(cur.val)
+            return []
+        queue = deque([root])
+        result = []
+        while queue:
+            level = []
+            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)
-            results.append(result)
-
-        return results
+                    queue.append(cur.right)
+            result.append(level)
+        return result
 ```
-
 ```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]]:
-        res = []
-        def helper(root, depth):
-            if not root: return []
-            if len(res) == depth: res.append([]) # start the current depth
-            res[depth].append(root.val) # fulfil the current depth
-            if  root.left: helper(root.left, depth + 1) # process child nodes for the next depth
-            if  root.right: helper(root.right, depth + 1)
-        helper(root, 0)
-        return res
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        levels = []
+        self.helper(root, 0, levels)
+        return levels
+    
+    def helper(self, node, level, levels):
+        if not node:
+            return
+        if len(levels) == level:
+            levels.append([])
+        levels[level].append(node.val)
+        self.helper(node.left, level + 1, levels)
+        self.helper(node.right, level + 1, levels)
+
+
 ```
 
+
+
 go:
 
 ```go