---

前言

1、二叉树的层序遍历
2、二叉树的层序遍历||
3、二叉树的层平均值
4、二叉树的锯齿形层序遍历
5、二叉树的右视图
6、N叉树的层序遍历

---

一、二叉树的层序遍历（力扣102）

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

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {

    public List<List<Integer>> resList = new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        checkFun02(root);
        return resList;
    }
    public void checkFun02(TreeNode node){
        if(node==null){
            return ;
        }
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        //根节点入队
        que.offer(node);
        while(!que.isEmpty()){
            List<Integer> itemList = new ArrayList<Integer>();
            int len = que.size();
            while(len-->0){
                //弹出结点
                TreeNode tmpNode = que.poll();
                //记录
                itemList.add(tmpNode.val);
                //左右孩子入队
                if(tmpNode.left!=null){
                    que.offer(tmpNode.left);
                }
                if(tmpNode.right!=null){
                    que.offer(tmpNode.right);
                }
            }
            resList.add(itemList);
        }
    }
}

借助队列实现

二、二叉树的层序遍历||（力扣107）

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

思路：
在（一）的基础上将最后的结果集翻转即可

class Solution {

    public List<List<Integer>> resList = new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        checkFun(root);
        return resList;
    }
    public void checkFun(TreeNode root){
        if(root == null){
            return ;
        }
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(root);
        while(!que.isEmpty()){
            int len =que.size();
            List<Integer> itemList = new ArrayList<>();
            while(len-->0){
                TreeNode tmpNode = que.poll();
                if(tmpNode.left!=null){
                    que.offer(tmpNode.left);
                }
                if(tmpNode.right!=null){
                    que.offer(tmpNode.right);
                }
                itemList.add(tmpNode.val);
            }
            resList.add(itemList);
        }
        Collections.reverse(resList);
    }
}

三、二叉树的层平均值（力扣637）

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

思路：
在每一层结束时，直接求取平均值即可

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> resList = new ArrayList<>();
        if(root==null){
            return resList;
        }
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(root);
        while(!que.isEmpty()){
            int len = que.size();
            int size = len ;
            double levelSum=0.0;
            while(size-->0){
                TreeNode tmpNode = que.poll();
                if(tmpNode.left!=null){
                    que.offer(tmpNode.left);
                }
                if(tmpNode.right!=null){
                    que.offer(tmpNode.right);
                }
                levelSum +=tmpNode.val;
            }
            resList.add(levelSum/len);
        }
        return resList;
    }
}

四、二叉树的锯齿形层序遍历（力扣103）

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

思路：
起初自认为 分为奇偶层 奇数层（根节点为第一层）右孩子先入队然后再左孩子，偶数层左孩子先入队然后再右孩子。这个思路很明显是错误的

换一种思路，按照最开始的层序遍历，将偶数层翻转即可。

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

        List<List<Integer>> resList = new ArrayList<>();
        Queue<TreeNode> que = new LinkedList<>();
        int level =0;
        if(root==null){
            return resList;
        }
        que.offer(root);
        while(!que.isEmpty()){
            List<Integer> itemList = new ArrayList<>();
            int len = que.size();
            while(len-->0){
                TreeNode tmpNode = que.poll();
                if(tmpNode.left!=null){
                    que.offer(tmpNode.left);
                }
                if(tmpNode.right!=null){
                    que.offer(tmpNode.right);
                }
                itemList.add(tmpNode.val);
            }
            level++;
            if(level%2==0){
                Collections.reverse(itemList);
                resList.add(itemList);
            }else{
                resList.add(itemList);
            }
        }
        return resList;
    }
}

五、二叉树的右视图（力扣199）

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

思路：
正常的层序遍历 只不过当len==1时，记录当前结点的值

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> resList = new ArrayList<>();
        Queue<TreeNode> que = new LinkedList<>();
        if(root==null){
            return resList;
        }
        que.offer(root);
        while(!que.isEmpty()){
            int len = que.size();
            while(len>0){
                TreeNode tmpNode = que.poll();
                if(tmpNode.left!=null){
                    que.offer(tmpNode.left);
                }
                if(tmpNode.right!=null){
                    que.offer(tmpNode.right);
                }
                if(len==1){
                   resList.add(tmpNode.val);
                }
                len--;
            }
        }
        return resList;
    }
}

六、N叉树的层序遍历（力扣429）

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

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

思路：
和二叉树的层序遍历基本一致

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> resList = new ArrayList<>();
        Queue<Node> que = new LinkedList<>();

        if(root==null){
            return resList;
        }
        que.offer(root);
        while(!que.isEmpty()){
            int len = que.size();
            List<Integer> itemList = new ArrayList<>();
            while(len-->0){
                Node tmpNode = que.poll();
                for(int i=0;i<tmpNode.children.size();i++){
                    que.offer(tmpNode.children.get(i));
                }
                itemList.add(tmpNode.val);
            }
            resList.add(itemList);
        }
        return resList;
    }
}

---