剑指 Offer 32 - I. 从上到下打印二叉树
难度：中等
方法一：层序遍历 BFS
题目要求的二叉树的从上至下打印（即按层打印），又称为二叉树的广度优先搜索（BFS）。
BFS 通常借助队列的先入先出特性来实现。
算法流程：
- 特例处理：当树的根节点为空，则直接返回空列表 []；
- 初始化：打印结果列表 res = []，包含根节点的队列 queue = [root]；
- BFS 循环：当队列 queue 为空时跳出；
- 返回值：返回打印结果列表 res 即可。
class Solution {
public int[] levelOrder(TreeNode root) {
if(root == null) return new int[0];
Queue<TreeNode> queue = new LinkedList<>(){{ add(root); }};
ArrayList<Integer> ans = new ArrayList<>();
while(!queue.isEmpty()) {
TreeNode node = queue.poll();
ans.add(node.val);
if(node.left != null) queue.add(node.left);
if(node.right != null) queue.add(node.right);
}
int[] res = new int[ans.size()];
for(int i = 0; i < ans.size(); i++)
res[i] = ans.get(i);
return res;
}
}
作者：Krahets
链接：https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/9ab39g/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。时间复杂度：O(N)，空间复杂度：O(N)。
剑指 Offer 32 - II. 从上到下打印二叉树 II
难度：简单
方法一：层序遍历 BFS
在 I 的基础上，将本层全部节点打印到一行，并将下一层全部节点加入队列，以此类推，即可分为多行打印。
算法流程：
- 特例处理：当根节点为空，则返回空列表 []；
- 初始化：打印结果列表 res = []，包含根节点的队列 queue = [root]；
- BFS 循环：当队列 queue 为空时跳出；
- 返回值：返回打印结果列表 res 即可。
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
Queue<TreeNode> queue = new LinkedList<>();
List<List<Integer>> res = new ArrayList<>();
if(root != null) queue.add(root);
while(!queue.isEmpty()) {
List<Integer> tmp = new ArrayList<>();
for(int i = queue.size(); i > 0; i--) {
TreeNode node = queue.poll();
tmp.add(node.val);
if(node.left != null) queue.add(node.left);
if(node.right != null) queue.add(node.right);
}
res.add(tmp);
}
return res;
}
}
作者：Krahets
链接：https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/5v22om/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。时间复杂度：O(N)，空间复杂度：O(N)。
其中的 int i = queue.size(); 用的很妙，学习学习。
剑指 Offer 32 - III. 从上到下打印二叉树 III
难度：中等
方法一：层序遍历 + 双端队列
算法流程：
- 特例处理：当树的根节点为空，则直接返回空列表 []；
- 初始化：打印结果空列表 res，包含根节点的双端队列 deque；
- BFS 循环：当 deque 为空时跳出；
- 返回值： 返回打印结果列表 res 即可；
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
Queue<TreeNode> queue = new LinkedList<>();
List<List<Integer>> res = new ArrayList<>();
if(root != null) queue.add(root);
while(!queue.isEmpty()) {
LinkedList<Integer> tmp = new LinkedList<>();
for(int i = queue.size(); i > 0; i--) {
TreeNode node = queue.poll();
if(res.size() % 2 == 0) tmp.addLast(node.val);
else tmp.addFirst(node.val);
if(node.left != null) queue.add(node.left);
if(node.right != null) queue.add(node.right);
}
res.add(tmp);
}
return res;
}
}
作者：Krahets
链接：https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/5vve57/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。时间复杂度：O(N)，空间复杂度：O(N)。
方法二：层序遍历 + 双端队列（奇偶逻辑分离）
算法流程：
- BFS 循环：循环打印奇 / 偶数层，当 deque 为空时跳出；
- 打印奇数层：从左向右打印，先左后右加入下层节点；
- 若 deque 为空，说明向下无偶数层，则跳出；
- 打印偶数层：从右向左打印，先右后左加入下层节点；
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
Deque<TreeNode> deque = new LinkedList<>();
List<List<Integer>> res = new ArrayList<>();
if(root != null) deque.add(root);
while(!deque.isEmpty()) {
// 打印奇数层
List<Integer> tmp = new ArrayList<>();
for(int i = deque.size(); i > 0; i--) {
// 从左向右打印
TreeNode node = deque.removeFirst();
tmp.add(node.val);
// 先左后右加入下层节点
if(node.left != null) deque.addLast(node.left);
if(node.right != null) deque.addLast(node.right);
}
res.add(tmp);
if(deque.isEmpty()) break; // 若为空则提前跳出
// 打印偶数层
tmp = new ArrayList<>();
for(int i = deque.size(); i > 0; i--) {
// 从右向左打印
TreeNode node = deque.removeLast();
tmp.add(node.val);
// 先右后左加入下层节点
if(node.right != null) deque.addFirst(node.right);
if(node.left != null) deque.addFirst(node.left);
}
res.add(tmp);
}
return res;
}
}
作者：Krahets
链接：https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/5vve57/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。时间复杂度：O(N)，空间复杂度：O(N)。
方法三：层序遍历 + 倒序
- 此方法的优点是只用列表即可，无需其他数据结构。
- 偶数层倒序：若 res 的长度为奇数，说明当前是偶数层，则对 tmp 执行倒序操作。
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
Queue<TreeNode> queue = new LinkedList<>();
List<List<Integer>> res = new ArrayList<>();
if(root != null) queue.add(root);
while(!queue.isEmpty()) {
List<Integer> tmp = new ArrayList<>();
for(int i = queue.size(); i > 0; i--) {
TreeNode node = queue.poll();
tmp.add(node.val);
if(node.left != null) queue.add(node.left);
if(node.right != null) queue.add(node.right);
}
if(res.size() % 2 == 1) Collections.reverse(tmp);
res.add(tmp);
}
return res;
}
}
作者：Krahets
链接：https://leetcode-cn.com/leetbook/read/illustration-of-algorithm/5vve57/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。时间复杂度：O(N)，空间复杂度：O(N)。