一、题目描述

示例 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

二、思路分析

层次遍历也就是一层一层的从上往下的遍历，有点先进先出的感觉，可以考虑用队列来解决！ 那怎么用队列来解决吗？（按照上面的示例举例,，并且假设9也有10,11两个左右子树，相当于是一个满二叉树）

首先我们把整个树添加到队列中，开始遍历队列 此时队列的长度为1,弹出队头，并且把队头的值放到结果中，再把队头也就是跟节点的左右孩子添加到队列中，此时完成了第一层的遍历 现在队列的长度为2，让len=queue.size()，然后开始再次开始遍历队列，弹出队头（第一个左子树9），把值放到结果中，然后把对头的左右孩子放进去，队列的长度为3,并且完成的第二层的第一个元素的遍历，再次弹出队头（第一个右子树20），把值放到结果中，然后把左右孩子的放到队列中，此时队列的长度为4,并且每次len–，此时len为0,同时第二层也遍历完了，同时队列的长度相当于第三层的长度 重复上面的操作，再次遍历队列，然后存值，然后再把左右子树结果放到队列中，这就完成了层次遍历！

简单的说就是每次把每一层的左右孩子放到队列中，并记录长度遍历结果！

三、AC代码

/**
 * 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>> levelOrder(TreeNode root) {
          
   
        List<List<Integer>> result = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if (root != null) queue.offer(root);
        while (queue.isEmpty() == false){
          
   
            List<Integer> list = new ArrayList<>();
            int len = queue.size();
            while (len > 0){
          
   
                TreeNode tmpNode = queue.poll();
                list.add(tmpNode.val);

                if (tmpNode.left != null) queue.offer(tmpNode.left);
                if (tmpNode.right != null) queue.offer(tmpNode.right);

                len--;
            }
            result.add(list);
        }

        return result;
    }
}

四、总结

队列可以实现二叉树的层次遍历 栈和队列的实现类总结

栈：Stack stack = new Stack();

队列：Queue queue = new LinkedList();

双向队列，栈：
方式一：Deque deque = new ArrayDeque();
方式二：Deque deque = new LinkeLIst();

感谢大家的阅读，我是Alson_Code，一个喜欢把简单问题复杂化，把复杂问题简单化的程序猿！ ❤