1. 基本的层序遍历与变换
1.1 入门级
输出结果为 3 9 20 15 7
public static List<Integer> getResult(TreeNote root) {
if (root == null) return new ArrayList<>();
List<Integer> list = new ArrayList<>();
LinkedList<TreeNote> queue = new LinkedList<>();
// 放入根节点
queue.add(root);
// 只有当队列不为空的时候
while (queue.size() > 0) {
TreeNote treeNote = queue.remove();
list.add(treeNote.val);
if (treeNote.leftNode != null) {
queue.add(treeNote.leftNode);
}
if (treeNote.rightNode != null) {
queue.add(treeNote.rightNode);
}
}
return list;
}
2. 二叉树的层序遍历
二叉树的层序遍历
给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）
输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]
可以看出，基本的步骤都一样，唯一的差别在于，现在需要将每一层的节点元素放入单独的list集合里面去
public List<List<Integer>> levelOrder(TreeNode root) {
if(root == null) return new ArrayList<List<Integer>> ();
// 记录结果
List<List<Integer>> res = new ArrayList<List<Integer>>();
LinkedList<TreeNode> queue= new LinkedList<>();
// 添加root
queue.add(root);
while(queue.size()>0){
// 记录当前一行的节点条数
int size = queue.size();
ArrayList<Integer> list = new ArrayList<>();
// 队列元素放入list
for(int i =0;i<size;i++){
TreeNode node =queue.remove();
list.add(node.val);
if(node.left!=null){
queue.add(node.left);
}
if(node.right!=null){
queue.add(node.right);
}
}
res.add(list);
}
return res;
}
3. 二叉树的层序遍历 II
107. 二叉树的层序遍历 II
给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]
3.1 层序+逆序
初始想法就是依然正向添加元素，然后将List里面元素逆序排序list，但是不知道是否可行。
public List<List<Integer>> levelOrderBottom(TreeNode root) {
if(root == null) return new ArrayList<List<Integer>>();
ArrayList<List<Integer>> res = new ArrayList<List<Integer>>();
LinkedList<TreeNode> queue = new LinkedList<>();
queue.add(root);
while(queue.size()>0){
int size = queue.size();
ArrayList<Integer> list = new ArrayList<>();
for(int i=0;i<size;i++){
TreeNode node = queue.remove();
list.add(node.val);
if(node.left!=null) queue.add(node.left);
if(node.right!=null) queue.add(node.right);
}
res.add(list);
}
// 工具逆序
Collections.reverse(res);
return res;
}
实际发现，结果速度还是很快的，而且比第二题速度还快。
3.2 新列表添加到列表头部
这种思路就是一开始定义列表，将新列表添加至列表的头部，就完成了逆序。
public List<List<Integer>> levelOrderBottom(TreeNode root) {
List<List<Integer>> levelOrder = new LinkedList<List<Integer>>();
if(root == null) return levelOrder;
LinkedList<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while(queue.size()>0){
int size = queue.size();
List<Integer> level = new ArrayList<Integer>();
for(int i=0;i<size;i++){
TreeNode node = queue.poll();
level.add(node.val);
if(node.left!=null) queue.add(node.left);
if(node.right!=null) queue.add(node.right);
}
levelOrder.add(0,level);
}
return levelOrder;
}
两种思路都差不多，都是将列表里面的列表元素逆序。
4. 二叉树的锯齿形层序遍历
103. 二叉树的锯齿形层序遍历
给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
输入：root = [3,9,20,null,null,15,7]
输出：[[3],[20,9],[15,7]]
依然是先写出简单方法，只不过列表里面的列表元素需要根据左右左右进行排序，思路主要是先定义一个布尔状态标识现在是先左子树还是右子树。 添加列表元素的时候采用Deque来存储，因为里面有addFirst和addLast方法，当此时是从左往右遍历，那么就将其添加到last位置，最后需要转换为ArrayList。
Deque特点：双端队列，两端都可添加和删除元素。
Queue特点：单端队列，只能一段添加，另一端删除元素。
这一题主要考察的是树和双端队列。
public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
if(root == null) return new ArrayList<List<Integer>>();
List<List<Integer>> res = new LinkedList<List<Integer>>();
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
Boolean isOrderLeft = true;
while(queue.size()>0){
int size = queue.size();
// 双端队列，存储元素
Deque<Integer> list = new LinkedList<>();
for(int i=0;i<size;i++){
TreeNode node = queue.remove();
//如果当前遍历方向为从右到左，则将当前节点值添加到双端队列的左侧。
//如果当前遍历方向为从左到右，则将当前节点值添加到双端队列的右侧。
if(!isOrderLeft){
list.addFirst(node.val);
}else{
list.addLast(node.val);
}
if(node.left!=null) queue.add(node.left);
if(node.right!=null) queue.add(node.right);
}
// 转换普通列表
res.add(new ArrayList<>(list));
// 切换遍历方向
isOrderLeft = !isOrderLeft;
}
return res;
}
时间复杂度：O（n）n为节点个数
空间复杂度：O（n）使用双端队列存储n个元素
总结：关于一些常用的特性需要多留意
5. N 叉树的层序遍历
N 叉树的层序遍历
给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。
树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）
输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]
遍历子树
依然先写出简单的层序遍历，但是这一题是n叉树，意味着原来的左右子树是无法使用了，但是仔细思考一下，原来的左右子树也是子树，只不过现在采用List存储子树，只需要遍历子树，队列重新遍历添加子树即可。
public List<List<Integer>> levelOrder(Node root) {
if(root == null) return new ArrayList<List<Integer>>();
List<List<Integer>> res = new ArrayList<List<Integer>>();
Queue<Node> queue = new LinkedList<>();
queue.add(root);
while(!queue.isEmpty()){
int size = queue.size();
List<Integer> list = new ArrayList<>();
for(int i=0;i<size;i++){
Node temp = queue.remove();
list.add(temp.val);
// 遍历子树
if(temp.children!=null){
for(Node child:temp.children){
queue.add(child);
}
}
}
res.add(list);
}
return res;
}
时间复杂度：O（n）遍历每个子树
空间复杂度：O（n） 队列使用空间
总结
可以很清晰看出，对于层序遍历，无非就是在简单版本的基础上继续扩充，简单版本一定是需要会的。