【算法刷题 | 二叉树 02】3.21 二叉树的层序遍历01（5题：二叉树的层序遍历、层序遍历||、右视图、层平均值，以及N叉树的层序遍历）

5.二叉树的层序遍历

5.1 102_二叉树的层序遍历

5.1.1问题

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

5.1.2解法：队列

1. 层序遍历需要借用一个辅助数据结构，即 队列 来实现
2. 队列先进先出，符合一层一层遍历的逻辑
3. 首先将根节点添加到队列中，接着开启一个循环（只要队列不为空，就一直循环）
   1. 在每次循环中，先拿到此时队列的长度
   2. 接着依次取出此时队列的全部节点（先进先出），并处理该元素
   3. 若该节点的左孩子不为空，则添加进队列；若该节点的右孩子不为空，则添加进队列
   4. 每次循环中，将处理完的list数组添加到返回值即可

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {

        //1、借助队列实现：先进先出
        Queue<TreeNode> queue=new LinkedList<>();
        List<List<Integer>> list=new ArrayList<>();
        if(root==null){
            return list;
        }

        //添加根节点到队列
        queue.offer(root);
        while(!queue.isEmpty()){
            //只要队列不为空，就一直循环
            List<Integer> tmp=new ArrayList<>();
            //取出队列全部元素
            int len=queue.size();
            while(len>0){
                
                TreeNode node=queue.poll();
                //添加值
                tmp.add(node.val);                                 
                
                if(node.left!=null){
                    queue.offer(node.left);
                }
                if(node.right!=null){
                    queue.offer(node.right);
                }
                len--;
            }
            
            list.add(tmp);
        }
        return list;

        
    }
}

5.2 107_二叉树的层序遍历||

5.2.1问题

给定一个二叉树，返回其 节点值自底向上 的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

5.2.2解法：队列

1. 思路：跟上一题一样，使用队列解决
2. 由于是自底向上，所以结果反转list即可

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        Queue<TreeNode> queue=new LinkedList<>();
        List<List<Integer>> list=new ArrayList<>();
        if(root==null){
            return list;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            //遍历该层
            List<Integer> tmp=new ArrayList<>();
            int len=queue.size();
            while(len>0){
                TreeNode node=queue.poll();
                tmp.add(node.val);
                if(node.left!=null){
                    queue.offer(node.left);
                }
                if(node.right!=null){
                    queue.offer(node.right);
                }
                len--;
            }

            //将该层结果添加到返回list中
            list.add(tmp);
        }

        //反转，也可以新建一个list，从后往前遍历原来的list
        Collections.reverse(list);
        return list;
        
    }
}

5.3 199_二叉树的右视图

5.3.1问题

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

• 示例一：

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

5.3.2解决：队列

1. 思路：层序遍历，将每层的最右节点添加到返回list中即可

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        Queue<TreeNode> queue=new LinkedList<>();
        List<Integer> list=new ArrayList<>();

        if(root==null){
            return list;
        }

        queue.offer(root);
        while(!queue.isEmpty()){
            int len=queue.size();
            for(int i=0;i<len;i++){
                
                TreeNode node=queue.poll();
                if(i==len-1){
                    //每层的最后一个
                    list.add(node.val);
                }

                if(node.left!=null){
                    queue.offer(node.left);
                }
                if(node.right!=null){
                    queue.offer(node.right);
                }
            }
            
        }
        return list;
    }
}

5.4 637_二叉树的层平均值

5.4.1问题

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

• 示例一：

输入：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] 。

5.4.2解决：队列

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {

        Queue<TreeNode> queue=new LinkedList<>();
        List<Double> list=new ArrayList<>();
        if(root==null){
            return list;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            //遍历该层
            int len=queue.size();
            Double tmp=0.0;

            for(int i=0;i<len;i++){
                TreeNode node=queue.poll();
                tmp+=node.val;
                if(node.left!=null){
                    queue.offer(node.left);
                }
                if(node.right!=null){
                    queue.offer(node.right);
                }
            }

            //将该层结果添加到返回list中
            list.add(tmp/len);
        }

        return list;
    }
}

5.5 429_N叉树的层序遍历

5.5.1问题

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

• 示例一：

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

5.5.2解法：层序遍历+栈

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        Queue<Node> queue=new LinkedList<>();
        List<List<Integer>> list=new ArrayList<>();
        if(root==null){
            return list;
        } 
        queue.offer(root);
        while(!queue.isEmpty()){
            int len=queue.size();
            List<Integer> tmp=new ArrayList<>();
            while(len>0){
                Node node=queue.poll();
                tmp.add(node.val);
                
                //由左右节点变成孩子节点
                List<Node> childrens=node.children;
                for(Node children:childrens){
                    if(children!=null){
                        queue.offer(children);
                    }
                }
                len--;
            }
            list.add(tmp);
        }
        return list;
    }
}