Merge pull request #1594 from marspere/master

Update 0102：优化二叉树层序遍历中116和117题的go方法

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

@@ -810,16 +810,15 @@ go:
 199. 二叉树的右视图
  */
 func rightSideView(root *TreeNode) []int {
-    queue:=list.New()
-    res:=[][]int{}
-    var finaRes []int
     if root == nil {
-        return finaRes
+        return nil
     }
+    res := make([]int, 0)
+    queue := list.New()
     queue.PushBack(root)
+
     for queue.Len() > 0 {
         length := queue.Len()
-        tmp:=[]int{}
         for i := 0; i < length; i++ {
             node := queue.Remove(queue.Front()).(*TreeNode)
             if node.Left != nil {
@@ -828,15 +827,13 @@ func rightSideView(root *TreeNode) []int {
             if node.Right != nil {
                 queue.PushBack(node.Right)
             }
-            tmp=append(tmp,node.Val)
+            // 取每层的最后一个元素，添加到结果集中
+            if i == length-1 {
+                res = append(res, node.Val)
             }
-        res=append(res,tmp)
         }
-    //取每一层的最后一个元素
-    for i:=0;i<len(res);i++{
-        finaRes=append(finaRes,res[i][len(res[i])-1])
     }
-    return finaRes
+    return res
 }
 ```
 
@@ -1054,40 +1051,34 @@ go:
 637. 二叉树的层平均值
  */
 func averageOfLevels(root *TreeNode) []float64 {
-    res:=[][]int{}
+    if root == nil {
-    var finRes []float64
+        // 防止为空
-    if root==nil{//防止为空
+        return nil
-        return finRes
     }
+    res := make([]float64, 0)
     queue := list.New()
     queue.PushBack(root)
-    var tmpArr []int
+
+    var sum int
     for queue.Len() > 0 {
-        length:=queue.Len()//保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+        //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+        length := queue.Len()
         for i := 0; i < length; i++ {
-            node:=queue.Remove(queue.Front()).(*TreeNode)//出队列
+            node := queue.Remove(queue.Front()).(*TreeNode)
             if node.Left != nil {
                 queue.PushBack(node.Left)
             }
             if node.Right != nil {
                 queue.PushBack(node.Right)
             }
-            tmpArr=append(tmpArr,node.Val)//将值加入本层切片中
+            // 当前层元素求和
+            sum += node.Val
         }
-        res=append(res,tmpArr)//放入结果集
+        // 计算每层的平均值，将结果添加到响应结果中
-        tmpArr=[]int{}//清空层的数据
+        res = append(res, float64(sum)/float64(length))
+        sum = 0 // 清空该层的数据
     }
-    //计算每层的平均值
+    return res
-    length:=len(res)
-    for i:=0;i<length;i++{
-        var sum int
-        for j:=0;j<len(res[i]);j++{
-            sum+=res[i][j]
-        }
-        tmp:=float64(sum)/float64(len(res[i]))
-        finRes=append(finRes,tmp)//将平均值放入结果集合
-    }
-    return finRes
 }
 ```
 
@@ -1552,44 +1543,40 @@ go:
 515. 在每个树行中找最大值
  */
 func largestValues(root *TreeNode) []int {
-    res:=[][]int{}
+    if root == nil {
-    var finRes []int
+        //防止为空
-    if root==nil{//防止为空
+        return nil
-        return finRes
     }
     queue := list.New()
     queue.PushBack(root)
-    var tmpArr []int
+    ans := make([]int, 0)
-    //层次遍历
+    temp := math.MinInt64
+    // 层序遍历
     for queue.Len() > 0 {
-        length:=queue.Len()//保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+        //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+        length := queue.Len()
         for i := 0; i < length; i++ {
             node := queue.Remove(queue.Front()).(*TreeNode)//出队列
+            // 比较当前层中的最大值和新遍历的元素大小，取两者中大值
+            temp = max(temp, node.Val)
             if node.Left != nil {
                 queue.PushBack(node.Left)
             }
             if node.Right != nil {
                 queue.PushBack(node.Right)
             }
-            tmpArr=append(tmpArr,node.Val)//将值加入本层切片中
         }
-        res=append(res,tmpArr)//放入结果集
+        ans = append(ans, temp)
-        tmpArr=[]int{}//清空层的数据
+        temp = math.MinInt64
     }
-    //找到每层的最大值
+    return ans
-    for i:=0;i<len(res);i++{
-        finRes=append(finRes,max(res[i]...))
 }
-    return finRes
+
+func max(x, y int) int {
+    if x > y {
+        return x
     }
-func max(vals...int) int {
+    return y
-    max:=int(math.Inf(-1))//负无穷
-    for _, val := range vals {
-        if val > max {
-            max = val
-        }
-    }
-    return max
 }
 ```
 
@@ -1891,13 +1878,12 @@ go:
  */
 
 func connect(root *Node) *Node {
-   res:=[][]*Node{}
     if root == nil { //防止为空
         return root
     }
     queue := list.New()
     queue.PushBack(root)
-    var tmpArr []*Node
+    tmpArr := make([]*Node, 0)
     for queue.Len() > 0 {
         length := queue.Len() //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
         for i := 0; i < length; i++ {
@@ -1910,17 +1896,17 @@ func connect(root *Node) *Node {
             }
             tmpArr = append(tmpArr, node) //将值加入本层切片中
         }
-        res=append(res,tmpArr)//放入结果集
+        if len(tmpArr) > 1 {
-        tmpArr=[]*Node{}//清空层的数据
-    }
             // 遍历每层元素,指定next
-    for i:=0;i<len(res);i++{
+            for i := 0; i < len(tmpArr)-1; i++ {
-        for j:=0;j<len(res[i])-1;j++{
+                tmpArr[i].Next = tmpArr[i+1]
-            res[i][j].Next=res[i][j+1]
             }
         }
+        tmpArr = []*Node{} //清空层的数据
+    }
     return root
 }
+
 ```
 
 Swift：
@@ -2172,13 +2158,12 @@ go:
  */
 
 func connect(root *Node) *Node {
-   res:=[][]*Node{}
     if root == nil { //防止为空
         return root
     }
     queue := list.New()
     queue.PushBack(root)
-    var tmpArr []*Node
+    tmpArr := make([]*Node, 0)
     for queue.Len() > 0 {
         length := queue.Len() //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
         for i := 0; i < length; i++ {
@@ -2191,15 +2176,14 @@ func connect(root *Node) *Node {
             }
             tmpArr = append(tmpArr, node) //将值加入本层切片中
         }
-        res=append(res,tmpArr)//放入结果集
+        if len(tmpArr) > 1 {
-        tmpArr=[]*Node{}//清空层的数据
-    }
             // 遍历每层元素,指定next
-    for i:=0;i<len(res);i++{
+            for i := 0; i < len(tmpArr)-1; i++ {
-        for j:=0;j<len(res[i])-1;j++{
+                tmpArr[i].Next = tmpArr[i+1]
-            res[i][j].Next=res[i][j+1]
             }
         }
+        tmpArr = []*Node{} //清空层的数据
+    }
     return root
 }
 ```