力扣刷题day13|（层序遍历系列题目）102二叉树的层序遍历、107二叉树的层次遍历II、199二叉树的右视图、637二叉树的层平均值、429N叉树的层序遍历、515在每个树行中找最大值

102. 二叉树的层序遍历

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

思路

将每一层的元素加进队列，记录每一层的大小，依次弹出每一层的节点

难点

对于每一层都需要额外定义一个变量记录当前层的size，否额因为队列不断加入元素，不要使用que.size()，因为que.size()会不断变化。

public List<List<Integer>> levelOrder(TreeNode root) {
    Deque<TreeNode> que = new ArrayDeque<>();
    List<List<Integer>> res = new ArrayList<List<Integer>>();


    if (root != null) {
         que.offer(root);
    }
    int size; // 记录每层大小
    while (!que.isEmpty()) {
        // 存放每一层
        List<Integer> level = new ArrayList<>();
        size = que.size();
        while (size-- > 0) {
            TreeNode node = que.poll();
            level.add(node.val);
            // 每出队一个节点，就要让他的左右子树入队
            if (node.left != null) {
                que.offer(node.left);
            }
            if (node.right != null) {
                que.offer(node.right);
            }

        }

        res.add(level);
    }

    return res;
}

107. 二叉树的层次遍历 II

力扣题目链接

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

思路

将从上至下的层序遍历反转

完整代码

    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        Deque<TreeNode> que = new ArrayDeque<>();
        List<List<Integer>> res = new ArrayList<List<Integer>>();


        if (root != null) {
            que.offer(root);
        }
        int size; // 记录每层大小
        while (!que.isEmpty()) {
            // 存放每一层
            List<Integer> level = new ArrayList<>();
            size = que.size();
            while (size-- > 0) {
                TreeNode node = que.poll();
                level.add(node.val);
                // 每出队一个节点，就要让他的左右子树入队
                if (node.left != null) {
                    que.offer(node.left);
                }
                if (node.right != null) {
                    que.offer(node.right);
                }

            }

            res.add(level);
        }
        Collections.reverse(res);
        return res;
//        List<List<Integer>> newResult = new ArrayList<>();
//        for (int i = res.size() - 1; i >= 0; i--) {
//            newResult.add(res.get(i));
//        }
//
//        return newResult;
    }

199. 二叉树的右视图

力扣题目链接

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

思路

从上至下层序遍历，将每层的节点入队，然后不停弹出，每次size–到最后一个元素时加入数组返回

public List<Integer> rightSideView(TreeNode root) {

    Deque<TreeNode> que = new ArrayDeque<>();
    List<Integer> res = new ArrayList<>();


    if (root != null) {
        que.offer(root);
    }
    int size; // 记录每层大小
    while (!que.isEmpty()) {
        // 存放每一层
        size = que.size();
        while (size-- > 0) {
            TreeNode node = que.poll();
            // 每出队一个节点，就要让他的左右子树入队
            if (node.left != null) {
                que.offer(node.left);
            }
            if (node.right != null) {
                que.offer(node.right);
            }
            // 如果是最右侧的节点，就加入res
            if (size == 0) {
                res.add(node.val);

            }
        }
    }

    return res;
}

637.二叉树的层平均值

力扣题目链接

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

思路

本题就是层序遍历的时候把一层求个总和在取一个均值。最好用for遍历每一层的每个元素，这样size不变可以用来求最后的均值

public List<Double> averageOfLevels(TreeNode root) {
    Deque<TreeNode> que = new ArrayDeque<>();
    List<Double> res = new ArrayList<>();


    if (root != null) {
        que.offer(root);
    }
    int size; // 记录每层大小
    while (!que.isEmpty()) {
        // 存放每一层
        List<Integer> level = new ArrayList<>();
        size = que.size();
        // 记录每层的和
        double sum = 0;
        for (int i = 0; i < size; i++) {
            TreeNode node = que.poll();
            level.add(node.val);
            // 每出队一个节点，就要让他的左右子树入队
            if (node.left != null) {
                que.offer(node.left);
            }
            if (node.right != null) {
                que.offer(node.right);
            }
            sum = sum + node.val;
        }
        double avg = sum / size;
        res.add(avg);
    }

    return res;
}

429. N叉树的层序遍历

力扣题目链接

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

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

思路

层序遍历，一个节点有多个孩子，每出队一个节点时，都要for (Node child : node.children)将他的所有孩子入队

public class NaryTreeLevelOrder {
    class Node {
        public int val;
        public List<Node> children;

        public Node() {}

        public Node(int _val) {
            val = _val;
        }

        public Node(int _val, List<Node> _children) {
            val = _val;
            children = _children;
        }
    }

    public List<List<Integer>> levelOrder(Node root) {
        Deque<Node> que = new ArrayDeque<>();
        List<List<Integer>> res = new ArrayList<>();

        if (root != null) {
            que.offer(root);
        }

        int size;
        while (!que.isEmpty()) {
            size = que.size();
            // 记录每层的元素
            List<Integer> level = new ArrayList<>();

            for (int i = 0; i < size; i++) {
                Node node = que.poll();
                level.add(node.val);
                // 将所有孩子节点入队
                if (node.children != null) {
                    for (Node child : node.children) {
                        que.offer(child);
                    }
                }
            }
            res.add(level);
        }

        return res;
    }
}

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

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

思路

层序遍历，遍历某一层的每个节点的时候，应该比较大小，最后这一层结束后将max值加入返回数组

public List<Integer> largestValues(TreeNode root) {
    Deque<TreeNode> que = new ArrayDeque<>();
    List<Integer> res = new ArrayList<>();

    if (root != null) {
        que.offer(root);
    }
    int size; // 记录每层大小
    while (!que.isEmpty()) {
        // 存放每一层
        List<Integer> level = new ArrayList<>();
        size = que.size();
        // 取一个最小值
        int max = Integer.MIN_VALUE;

        for (int i = 0; i < size; i++) {
            TreeNode node = que.poll();

            // 比较每一个数
            max = Math.max(node.val, max);
            // 每出队一个节点，就要让他的左右子树入队
            if (node.left != null) {
                que.offer(node.left);
            }
            if (node.right != null) {
                que.offer(node.right);
            }

        }
        // 最后一个数计较完后进入res数组
        res.add(max);
    }

    return res;
}