Merge pull request #1594 from marspere/master

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

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

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