Merge pull request #2587 from markwang1992/102-levelOrder

102.二叉树的层序遍历增加Go使用切片解法

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

@@ -265,7 +265,7 @@ func levelOrder(root *TreeNode) [][]int {
 
 ```go
 /**
-102. 二叉树的层序遍历
+102. 二叉树的层序遍历 使用container包
  */
 func levelOrder(root *TreeNode) [][]int {
     res := [][]int{}
@@ -296,6 +296,35 @@ func levelOrder(root *TreeNode) [][]int {
     return res
 }
 
+/**
+  102. 二叉树的层序遍历 使用切片
+*/
+func levelOrder(root *TreeNode) [][]int {
+     res := make([][]int, 0)
+     if root == nil {
+        return res
+     }
+     queue := make([]*TreeNode, 0)
+     queue = append(queue, root)
+     for len(queue) > 0 {
+          size := len(queue)
+          level := make([]int, 0)
+          for i := 0; i < size; i++ {
+               node := queue[0]
+               queue = queue[1:]
+               level = append(level, node.Val)
+               if node.Left != nil {
+				   queue = append(queue, node.Left)
+               }
+               if node.Right != nil {
+				   queue = append(queue, node.Right)
+               }
+          }
+          res = append(res, level)
+     }
+     return res
+}
+
 /**
 102. 二叉树的层序遍历：使用切片模拟队列，易理解
  */
@@ -695,6 +724,41 @@ func levelOrderBottom(root *TreeNode) [][]int {
 }
 ```
 
+```GO
+// 使用切片作为队列
+func levelOrderBottom(root *TreeNode) [][]int {
+    res := make([][]int, 0)
+    if root == nil {
+		return res
+    }
+    queue := make([]*TreeNode, 0)
+    queue = append(queue, root)
+    for len(queue) > 0 {
+        size := len(queue)
+        level := make([]int, 0)
+        for i := 0; i < size; i++ {
+            node := queue[0]
+            queue = queue[1:]
+            level = append(level, node.Val)
+            if node.Left != nil {
+                queue = append(queue, node.Left)
+            }
+            if node.Right != nil {
+                queue = append(queue, node.Right)
+            }
+        }
+        res = append(res, level)
+    }
+    l, r := 0, len(res)-1
+    for l < r {
+		res[l], res[r] = res[r], res[l]
+		l++
+		r--
+    }
+    return res
+}
+```
+
 #### Javascript:
 
 ```javascript
@@ -1008,6 +1072,35 @@ func rightSideView(root *TreeNode) []int {
 }
 ```
 
+```GO
+// 使用切片作为队列
+func rightSideView(root *TreeNode) []int {
+    res := make([]int, 0)
+    if root == nil {
+        return res
+    }
+    queue := make([]*TreeNode, 0)
+    queue = append(queue, root)
+    for len(queue) > 0 {
+        size := len(queue)
+        for i := 0; i < size; i++ {
+            node := queue[0]
+            queue = queue[1:]
+            if node.Left != nil {
+                queue = append(queue, node.Left)
+            }
+            if node.Right != nil {
+                queue = append(queue, node.Right)
+            }
+            if i == size-1 {
+                res = append(res, node.Val)
+            }
+        }
+    }
+    return res
+}
+```
+
 #### Javascript:
 
 ```javascript
@@ -1299,6 +1392,35 @@ func averageOfLevels(root *TreeNode) []float64 {
 }
 ```
 
+```GO
+// 使用切片作为队列
+func averageOfLevels(root *TreeNode) []float64 {
+    res := make([]float64, 0)
+    if root == nil {
+        return res
+    }
+    queue := make([]*TreeNode, 0)
+    queue = append(queue, root)
+    for len(queue) > 0 {
+        size := len(queue)
+        sum := 0
+        for i := 0; i < size; i++ {
+            node := queue[0]
+            queue = queue[1:]
+            sum += node.Val
+            if node.Left != nil {
+                queue = append(queue, node.Left)
+            }
+            if node.Right != nil {
+                queue = append(queue, node.Right)
+            }
+        }
+        res = append(res, float64(sum)/float64(size))
+    }
+    return res
+}
+```
+
 #### Javascript：
 
 ```javascript
@@ -1631,6 +1753,32 @@ func levelOrder(root *Node) [][]int {
 }
 ```
 
+```GO
+// 使用切片作为队列
+func levelOrder(root *Node) [][]int {
+    res := make([][]int, 0)
+    if root == nil {
+        return res
+    }
+    queue := make([]*Node, 0)
+    queue = append(queue, root)
+    for len(queue) > 0 {
+        size := len(queue)
+        level := make([]int, 0)
+        for i := 0; i < size; i++ {
+            node := queue[0]
+            queue = queue[1:]
+            level = append(level, node.Val)
+            if len(node.Children) > 0 {
+                queue = append(queue, node.Children...)
+            }
+        }
+        res = append(res, level)
+    }
+    return res
+}
+```
+
 #### JavaScript：
 
 ```JavaScript
@@ -1930,6 +2078,37 @@ func max(x, y int) int {
 }
 ```
 
+```GO
+// 使用切片作为队列
+func largestValues(root *TreeNode) []int {
+    res := make([]int, 0)
+    if root == nil {
+        return res
+    }
+    queue := make([]*TreeNode, 0)
+    queue = append(queue, root)
+    for len(queue) > 0 {
+        size := len(queue)
+        maxValue := math.MinInt64
+        for i := 0; i < size; i++ {
+            node := queue[0]
+            queue = queue[1:]
+            if node.Val > maxValue {
+                maxValue = node.Val
+            }
+            if node.Left != nil {
+                queue = append(queue, node.Left)
+            }
+            if node.Right != nil {
+                queue = append(queue, node.Right)
+            }
+        }
+        res = append(res, maxValue)
+    }
+    return res
+}
+```
+
 #### Javascript：
 
 ```javascript
@@ -2243,6 +2422,34 @@ func connect(root *Node) *Node {
 
 ```
 
+```GO
+// 使用切片作为队列
+func connect(root *Node) *Node {
+    if root == nil {
+        return root
+    }
+    queue := make([]*Node, 0)
+    queue = append(queue, root)
+    for len(queue) > 0 {
+        size := len(queue)
+        for i := 0; i < size; i++ {
+            node := queue[i]
+            if i != size - 1 {
+                queue[i].Next = queue[i+1]
+            }
+            if node.Left != nil {
+                queue = append(queue, node.Left)
+            }
+            if node.Right != nil {
+                queue = append(queue, node.Right)
+            }
+        }
+        queue = queue[size:]
+    }
+    return root
+}
+```
+
 #### JavaScript:
 
 ```javascript
@@ -2531,6 +2738,34 @@ func connect(root *Node) *Node {
 }
 ```
 
+```GO
+// 使用切片作为队列
+func connect(root *Node) *Node {
+    if root == nil {
+        return root
+    }
+    queue := make([]*Node, 0)
+    queue = append(queue, root)
+    for len(queue) > 0 {
+        size := len(queue)
+        for i := 0; i < size; i++ {
+            node := queue[i]
+            if i != size - 1 {
+                queue[i].Next = queue[i+1]
+            }
+            if node.Left != nil {
+                queue = append(queue, node.Left)
+            }
+            if node.Right != nil {
+                queue = append(queue, node.Right)
+            }
+        }
+        queue = queue[size:]
+    }
+    return root
+}
+```
+
 #### JavaScript:
 
 ```javascript
@@ -2800,6 +3035,33 @@ func maxDepth(root *TreeNode) int {
 }
 ```
 
+```go
+// 使用切片作为队列
+func maxDepth(root *TreeNode) int {
+    if root == nil {
+        return 0
+    }
+    depth := 0
+    queue := make([]*TreeNode, 0)
+    queue = append(queue, root)
+    for len(queue) > 0 {
+        size := len(queue)
+        for i := 0; i < size; i++ {
+            node := queue[0]
+            queue = queue[1:]
+            if node.Left != nil {
+                queue = append(queue, node.Left)
+            }
+            if node.Right != nil {
+                queue = append(queue, node.Right)
+            }
+        }
+        depth++
+    }
+    return depth
+}
+```
+
 #### JavaScript：
 
 ```javascript
@@ -3073,7 +3335,37 @@ func minDepth(root *TreeNode) int {
         ans++//记录层数
     }
 
-    return ans+1
+    return ans
+}
+```
+
+```go
+// 使用切片作为队列
+func minDepth(root *TreeNode) int {
+    if root == nil {
+        return 0
+    }
+    depth := 0
+    queue := make([]*TreeNode, 0)
+    queue = append(queue, root)
+    for len(queue) > 0 {
+        size := len(queue)
+        depth++
+        for i := 0; i < size; i++ {
+            node := queue[0]
+            queue = queue[1:]
+            if node.Left != nil {
+                queue = append(queue, node.Left)
+            }
+            if node.Right != nil {
+                queue = append(queue, node.Right)
+            }
+            if node.Left == nil && node.Right == nil {
+                return depth
+            }
+        }
+    }
+    return depth
 }
 ```