update 0102.二叉树的层序遍历: 优化 js 和 go 的代码风格

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

@@ -47,7 +47,7 @@
 
 层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。
 
-需要借用一个辅助数据结构即队列来实现，**队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。**
+需要借用一个辅助数据结构即队列来实现，**队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。**
 
 **而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。**
 
@@ -106,50 +106,6 @@ public:
 };
 ```
 
-python3代码：
-
-
-```python
-
-class Solution:
-    """二叉树层序遍历迭代解法"""
-
-    def levelOrder(self, root: TreeNode) -> List[List[int]]:
-        results = []
-        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)
-                if cur.left:
-                    que.append(cur.left)
-                if cur.right:
-                    que.append(cur.right)
-            results.append(result)
-
-        return results
-```
-```python
-# 递归法
-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
-```
 java: 
 
 ```Java
@@ -206,6 +162,51 @@ class Solution {
 }
 ```
 
+python3代码：
+
+
+```python
+
+class Solution:
+    """二叉树层序遍历迭代解法"""
+
+    def levelOrder(self, root: TreeNode) -> List[List[int]]:
+        results = []
+        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)
+                if cur.left:
+                    que.append(cur.left)
+                if cur.right:
+                    que.append(cur.right)
+            results.append(result)
+
+        return results
+```
+```python
+# 递归法
+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
+```
+
 go: 
 
 ```go
@@ -249,7 +250,9 @@ func levelOrder(root *TreeNode) [][]int {
     }
     queue := list.New()
     queue.PushBack(root)
+    
     var tmpArr []int
+    
     for queue.Len() > 0 {
         length := queue.Len()               //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
         for i := 0; i < length; i++ {
@@ -265,6 +268,7 @@ func levelOrder(root *TreeNode) [][]int {
         res = append(res, tmpArr)          //放入结果集
         tmpArr = []int{}                  //清空层的数据
     }
+    
     return res
 }
 ```
@@ -541,6 +545,7 @@ func levelOrderBottom(root *TreeNode) [][]int {
         return res
     }
     queue.PushBack(root)
+    
     for queue.Len() > 0 {
         length := queue.Len()
         tmp := []int{}
@@ -556,10 +561,12 @@ func levelOrderBottom(root *TreeNode) [][]int {
         }
         res=append(res, tmp)
     }
+    
     //反转结果集
     for i:=0; i<len(res)/2; i++ {
         res[i], res[len(res)-i-1] = res[len(res)-i-1], res[i]
     }
+    
     return res
 }
 ```
@@ -854,6 +861,7 @@ var rightSideView = function(root) {
     //二叉树右视图 只需要把每一层最后一个节点存储到res数组
     let res = [], queue = [];
     queue.push(root);
+    
     while(queue.length && root!==null) {
         // 记录当前层级节点个数
         let length = queue.length;
@@ -867,6 +875,7 @@ var rightSideView = function(root) {
             node.right && queue.push(node.right);
         }
     }
+    
     return res;
 };
 ```
@@ -1131,6 +1140,7 @@ var averageOfLevels = function(root) {
     //层级平均值
     let res = [], queue = [];
     queue.push(root);
+    
     while(queue.length && root!==null) {
         //每一层节点个数
         let length = queue.length;
@@ -1145,6 +1155,7 @@ var averageOfLevels = function(root) {
         //每一层的平均值存入数组res
         res.push(sum/length);
     }
+    
     return res;
 };
 ```
@@ -1423,6 +1434,7 @@ func levelOrder(root *Node) [][]int {
         }
         res = append(res, tmp)
     }
+    
     return res
 }
 ```
@@ -1434,6 +1446,7 @@ var levelOrder = function(root) {
     //每一层可能有2个以上,所以不再使用node.left node.right
     let res = [], queue = [];
     queue.push(root);
+    
     while(queue.length && root!==null) {
         //记录每一层节点个数还是和二叉树一致
         let length = queue.length;
@@ -1442,6 +1455,7 @@ var levelOrder = function(root) {
         while(length--) {
             let node = queue.shift();
             curLevel.push(node.val);
+	    
             //这里不再是 ndoe.left node.right 而是循坏node.children
            for(let item of node.children){
                item && queue.push(item);
@@ -1449,6 +1463,7 @@ var levelOrder = function(root) {
         }
         res.push(curLevel);
     }
+    
     return res;
 };
 ```
@@ -1710,6 +1725,7 @@ var largestValues = function(root) {
     //使用层序遍历
     let res = [], queue = [];
     queue.push(root);
+    
     while(root !== null && queue.length) { 
         //设置max初始值就是队列的第一个元素
         let max = queue[0].val;
@@ -1723,6 +1739,7 @@ var largestValues = function(root) {
         //把每一层的最大值放到res数组
         res.push(max);
     }
+    
     return res;
 };
 ```
@@ -1964,6 +1981,46 @@ class Solution:
             first = first.left  # 从本层扩展到下一层
         return root
 ```
+go:
+
+```GO
+/**
+116. 填充每个节点的下一个右侧节点指针
+117. 填充每个节点的下一个右侧节点指针 II
+ */
+
+func connect(root *Node) *Node {
+    if root == nil { //防止为空
+        return root
+    }
+    queue := list.New()
+    queue.PushBack(root)
+    tmpArr := make([]*Node, 0)
+    for queue.Len() > 0 {
+        length := queue.Len() //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+        for i := 0; i < length; i++ {
+            node := queue.Remove(queue.Front()).(*Node) //出队列
+            if node.Left != nil {
+                queue.PushBack(node.Left)
+            }
+            if node.Right != nil {
+                queue.PushBack(node.Right)
+            }
+            tmpArr = append(tmpArr, node) //将值加入本层切片中
+        }
+        if len(tmpArr) > 1 {
+            // 遍历每层元素,指定next
+            for i := 0; i < len(tmpArr)-1; i++ {
+                tmpArr[i].Next = tmpArr[i+1]
+            }
+        }
+        tmpArr = []*Node{} //清空层的数据
+    }
+    return root
+}
+
+```
+
 JavaScript:
 ```javascript
 
@@ -2024,46 +2081,6 @@ function connect(root: Node | null): Node | null {
 };
 ```
 
-go:
-
-```GO
-/**
-116. 填充每个节点的下一个右侧节点指针
-117. 填充每个节点的下一个右侧节点指针 II
- */
-
-func connect(root *Node) *Node {
-    if root == nil { //防止为空
-        return root
-    }
-    queue := list.New()
-    queue.PushBack(root)
-    tmpArr := make([]*Node, 0)
-    for queue.Len() > 0 {
-        length := queue.Len() //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
-        for i := 0; i < length; i++ {
-            node := queue.Remove(queue.Front()).(*Node) //出队列
-            if node.Left != nil {
-                queue.PushBack(node.Left)
-            }
-            if node.Right != nil {
-                queue.PushBack(node.Right)
-            }
-            tmpArr = append(tmpArr, node) //将值加入本层切片中
-        }
-        if len(tmpArr) > 1 {
-            // 遍历每层元素,指定next
-            for i := 0; i < len(tmpArr)-1; i++ {
-                tmpArr[i].Next = tmpArr[i+1]
-            }
-        }
-        tmpArr = []*Node{} //清空层的数据
-    }
-    return root
-}
-
-```
-
 Swift：
 
 ```swift
@@ -2226,6 +2243,45 @@ class Solution:
         return root
 
 ```
+go:
+
+```GO
+/**
+116. 填充每个节点的下一个右侧节点指针
+117. 填充每个节点的下一个右侧节点指针 II
+ */
+
+func connect(root *Node) *Node {
+    if root == nil { //防止为空
+        return root
+    }
+    queue := list.New()
+    queue.PushBack(root)
+    tmpArr := make([]*Node, 0)
+    for queue.Len() > 0 {
+        length := queue.Len() //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+        for i := 0; i < length; i++ {
+            node := queue.Remove(queue.Front()).(*Node) //出队列
+            if node.Left != nil {
+                queue.PushBack(node.Left)
+            }
+            if node.Right != nil {
+                queue.PushBack(node.Right)
+            }
+            tmpArr = append(tmpArr, node) //将值加入本层切片中
+        }
+        if len(tmpArr) > 1 {
+            // 遍历每层元素,指定next
+            for i := 0; i < len(tmpArr)-1; i++ {
+                tmpArr[i].Next = tmpArr[i+1]
+            }
+        }
+        tmpArr = []*Node{} //清空层的数据
+    }
+    return root
+}
+```
+
 JavaScript:
 ```javascript
 /**
@@ -2284,44 +2340,6 @@ function connect(root: Node | null): Node | null {
 };
 ```
 
-go:
-
-```GO
-/**
-116. 填充每个节点的下一个右侧节点指针
-117. 填充每个节点的下一个右侧节点指针 II
- */
-
-func connect(root *Node) *Node {
-    if root == nil { //防止为空
-        return root
-    }
-    queue := list.New()
-    queue.PushBack(root)
-    tmpArr := make([]*Node, 0)
-    for queue.Len() > 0 {
-        length := queue.Len() //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
-        for i := 0; i < length; i++ {
-            node := queue.Remove(queue.Front()).(*Node) //出队列
-            if node.Left != nil {
-                queue.PushBack(node.Left)
-            }
-            if node.Right != nil {
-                queue.PushBack(node.Right)
-            }
-            tmpArr = append(tmpArr, node) //将值加入本层切片中
-        }
-        if len(tmpArr) > 1 {
-            // 遍历每层元素,指定next
-            for i := 0; i < len(tmpArr)-1; i++ {
-                tmpArr[i].Next = tmpArr[i+1]
-            }
-        }
-        tmpArr = []*Node{} //清空层的数据
-    }
-    return root
-}
-```
 Swift：
 
 ```swift
@@ -2461,7 +2479,6 @@ class Solution {
 }
 ```
 
-
 Python：
 ```python 3
 class Solution:
@@ -2521,8 +2538,6 @@ func maxDepth(root *TreeNode) int {
 }
 ```
 
-
-
 JavaScript：
 ```javascript
 /**
@@ -2784,9 +2799,8 @@ func minDepth(root *TreeNode) int {
             }
         }
         ans++//记录层数
-        
-
     }
+    
     return ans+1
 }
 ```