代码随想录算法训练营第15天|● 层序遍历 10 ● 226.翻转二叉树 ● 101.对称二叉树 2

102. 二叉树的层序遍历

中等
给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：
[图片]
输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]
示例 2：
输入：root = [1]
输出：[[1]]
示例 3：
输入：root = []
输出：[]

提示：

• 树中节点数目在范围 [0, 2000] 内
• -1000 <= Node.val <= 1000

模板

func levelOrder(root *TreeNode) (res [][]int) {
   if root == nil {
      return
   }

   curLevel := []*TreeNode{root} // 存放当前层节点
   for len(curLevel) > 0 {
      nextLevel := []*TreeNode{} // 准备通过当前层生成下一层
      vals := []int{}

      for _, node := range curLevel {
         vals = append(vals, node.Val) // 收集当前层的值
         // 收集下一层的节点
         if node.Left != nil {
            nextLevel = append(nextLevel, node.Left)
         }
         if node.Right != nil {
            nextLevel = append(nextLevel, node.Right)
         }
      }
      res = append(res, vals)
      curLevel = nextLevel // 将下一层变成当前层
   }

   return
}

代码

func levelOrder(root *TreeNode) [][]int {
    queue := make([]*TreeNode, 0)
    res := make([][]int, 0)
    queue = append(queue, root)
    for len(queue) > 0 {
        n := len(queue)
        next, r := make([]*TreeNode, 0), make([]int, 0)
        for i := 0; i < n; i++ {
            x := queue[i]
            if x != nil {
                next = append(next, x.Left, x.Right)
                r = append(r, x.Val)
            }
        }
        if len(r)>0{
            res = append(res, r)
        }
        
        queue = next
    }
    return res
}

107. 二叉树的层序遍历 II

中等
给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：
[图片]
输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]
示例 2：
输入：root = [1]
输出：[[1]]
示例 3：
输入：root = []
输出：[]

提示：

• 树中节点数目在范围 [0, 2000] 内
• -1000 <= Node.val <= 1000

代码

func levelOrderBottom(root *TreeNode) [][]int {
    queue := make([]*TreeNode, 0)
    res := make([][]int, 0)
    queue = append(queue, root)
    for len(queue) > 0 {
        n := len(queue)
        next, r := make([]*TreeNode, 0), make([]int, 0)
        for i := 0; i < n; i++ {
            x := queue[i]
            if x != nil {
                next = append(next, x.Left, x.Right)
                r = append(r, x.Val)
            }
        }
        if len(r) > 0 {
            res = append(res, r)
        }

        queue = next
    }
    res = reverse(res)
    return res
}

func reverse(res [][]int) [][]int {
    i, j := 0, len(res)-1
    for i < j {
        res[i], res[j] = res[j], res[i]
        i++
        j--
    }
    return res
}

199. 二叉树的右视图

中等
给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:
[图片]
输入: [1,2,3,null,5,null,4]
输出: [1,3,4]
示例 2:
输入: [1,null,3]
输出: [1,3]
示例 3:
输入: []
输出: []

提示:

• 二叉树的节点个数的范围是 [0,100]
• -100 <= Node.val <= 100

代码

func rightSideView(root *TreeNode) []int {
    queue := make([]*TreeNode, 0)
    res := make([]int, 0)
    queue = append(queue, root)
    for len(queue) > 0 {
        n := len(queue)
        next, r := make([]*TreeNode, 0), make([]int, 0)
        for i := 0; i < n; i++ {
            x := queue[i]
            if x != nil {
                next = append(next, x.Left, x.Right)
                r = append(r, x.Val)
            }
        }
        if len(r) > 0 {
            res = append(res, r[len(r)-1])
        }

        queue = next
    }
    return res
}

637. 二叉树的层平均值

简单
给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10(-5) 以内的答案可以被接受。

示例 1：
[图片]
输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11] 。
示例 2:
[图片]
输入：root = [3,9,20,15,7]
输出：[3.00000,14.50000,11.00000]

提示：

• 树中节点数量在 [1, 10(4)] 范围内
• -2(31) <= Node.val <= 2(31) - 1

代码

func averageOfLevels(root *TreeNode) []float64 {
    queue := make([]*TreeNode, 0)
    res := make([]float64, 0)
    queue = append(queue, root)
    for len(queue) > 0 {
        n := len(queue)
        next, r, cnt := make([]*TreeNode, 0), float64(0), 0
        for i := 0; i < n; i++ {
            x := queue[i]
            if x != nil {
                next = append(next, x.Left, x.Right)
                r += float64(x.Val)
                cnt++
            }
        }
        if cnt > 0 {
            res = append(res, r/float64(cnt))
        }

        queue = next
    }
    return res
}

429. N 叉树的层序遍历

中等
给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。
树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

示例 1：
[图片]
输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]
示例 2：
[图片]
输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

提示：

• 树的高度不会超过 1000
• 树的节点总数在 [0, 10^4] 之间

代码

func levelOrder(root *Node) [][]int {
    queue := make([]*Node, 0)
    res := make([][]int, 0)
    queue = append(queue, root)
    for len(queue) > 0 {
        n := len(queue)
        next, r := make([]*Node, 0), make([]int, 0)
        for i := 0; i < n; i++ {
            x := queue[i]
            if x != nil {
                for j:=0;j<len(x.Children);j++{
                    next = append(next, x.Children[j])
                }
                r = append(r, x.Val)
            }
        }
        if len(r) > 0 {
            res = append(res, r)
        }

        queue = next
    }
    return res
}

515. 在每个树行中找最大值

中等
337
相关企业
给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

示例1：
[图片]
输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]
示例2：
输入: root = [1,2,3]
输出: [1,3]

提示：

• 二叉树的节点个数的范围是 [0,10(4)]
• -2(31) <= Node.val <= 2(31) - 1

代码

func largestValues(root *TreeNode) []int {
    queue := make([]*TreeNode, 0)
    res := make([]int, 0)
    queue = append(queue, root)
    for len(queue) > 0 {
        n,m := len(queue),0
        next, r := make([]*TreeNode, 0), math.MinInt32
        for i := 0; i < n; i++ {
            x := queue[i]
            if x != nil {
                next = append(next, x.Left, x.Right)
                if r < x.Val {
                    r = x.Val
                }
                m++
            }
        }
        if m != 0 {
            res = append(res, r)
        }

        queue = next
    }
    return res
}

116. 填充每个节点的下一个右侧节点指针

117. 填充每个节点的下一个右侧节点指针 II
     中等
     给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
     struct Node {
     int val;
     Node *left;
     Node *right;
     Node *next;
     }
     填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
     初始状态下，所有 next 指针都被设置为 NULL。

示例 1：
[图片]
输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，‘#’ 标志着每一层的结束。

示例 2:
输入：root = []
输出：[]

提示：

• 树中节点的数量在 [0, 2(12) - 1] 范围内
• -1000 <= node.val <= 1000

进阶：

• 你只能使用常量级额外空间。
• 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。

代码

func connect(root *Node) *Node {
    queue := make([]*Node, 0)
    queue = append(queue, root)
    for len(queue) > 0 {
        n := len(queue)
        next := make([]*Node, 0)
        prenode := &Node{}
        for i := 0; i < n; i++ {
            x := queue[i]
            if i > 0 {
                prenode.Next = x
            }
            if x != nil {
                if i > 0 { //防止节点为空
                    prenode.Next = x
                }
                next = append(next, x.Left, x.Right)
                prenode = x
            }

        }
        queue = next
    }
    return root
}

226. 翻转二叉树

简单
给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：
[图片]
输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]
示例 2：
[图片]
输入：root = [2,1,3]
输出：[2,3,1]
示例 3：
输入：root = []
输出：[]

提示：

• 树中节点数目范围在 [0, 100] 内
• -100 <= Node.val <= 100

代码

func invertTree(root *TreeNode) *TreeNode {
  if root==nil{
    return nil
  }
  root.Left,root.Right = invertTree(root.Right), invertTree(root.Left)
  return root
}

101. 对称二叉树

简单
给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：
[图片]
输入：root = [1,2,2,3,4,4,3]
输出：true
示例 2：
[图片]
输入：root = [1,2,2,null,3,null,3]
输出：false

提示：

• 树中节点数目在范围 [1, 1000] 内
• -100 <= Node.val <= 100

代码

func isSymmetric(root *TreeNode) bool {
   return isSymmetric_dfs(root.Right, root.Left)
}

func isSymmetric_dfs(left *TreeNode, right *TreeNode) bool {
   // 如果两个节点都为空，是对称的
   if left == nil && right == nil {
      return true
   }
   // 如果一个节点为空，另一个不为空，不对称
   if left == nil || right == nil {
      return false
   }
   // 两个节点的值必须相等，**keypoint
   // 且左子树的左子树和右子树的右子树对称，左子树的右子树和右子树的左子树对称
   return left.Val == right.Val &&
      isSymmetric_dfs(left.Left, right.Right) &&
      isSymmetric_dfs(left.Right, right.Left)
}