文章目录
栈 -> 二叉树三种遍历方式（递归和迭代，本质都是递归）-> DFS
队列 -> 二叉树的层序遍历 -> BFS
102.二叉树的层序遍历
示例：
二叉树：[3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回其层序遍历结果：
[
[3],
[9,20],
[15,7]
]
输入：一维数组，数组元素按层排列，没有的就用null
输出：一个二维数组，表示该二叉树的层序遍历
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> outerList=new ArrayList<List<Integer>>();
Queue<TreeNode> queue=new LinkedList<>();
if (null != root) queue.offer(root); // 尾部插入
while(queue.size()>0){
int size=queue.size();
List<Integer> innerList=new ArrayList<Integer>(); // innerList初始化长度为零
for (int i=0;i<size;i++){
TreeNode node=queue.poll(); // 队列头部弹出这个元素
innerList.add(node.val); // innerList赶快装上这个元素
if(null != node.left) queue.offer(node.left);
if(null != node.right) queue.offer(node.right);
}
outerList.add(innerList);
}
return outerList;
}
}
107.二叉树的层次遍历II
例如：
给定二叉树 [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回其自底向上的层序遍历为：
[
[15,7],
[9,20],
[3]
]
输入：一维数组，数组元素按层排列，没有的就用null
输出：一个二维数组，表示该二叉树的层序遍历
class Solution {
public List<List<Integer>> levelOrderBottom(TreeNode root) {
List<List<Integer>> outerList=new ArrayList<List<Integer>>();
Queue<TreeNode> queue=new LinkedList<>();
if (null != root) queue.offer(root); // 尾部插入
while(queue.size()>0){
int size=queue.size();
List<Integer> innerList=new ArrayList<Integer>(); // innerList初始化长度为零
for (int i=0;i<size;i++){
TreeNode node=queue.poll(); // 队列头部弹出这个元素
innerList.add(node.val); // innerList赶快装上这个元素
if(null != node.left) queue.offer(node.left);
if(null != node.right) queue.offer(node.right);
}
outerList.add(innerList);
}
Collections.reverse(outerList); // 就是比层序遍历多了这么一行而已
return outerList;
}
}
Collections.reverse(outerList); // 就是比层序遍历多了这么一行而已
199.二叉树的右视图
给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
示例:
输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:
1 <---
/ \
2 3 <---
\ \
5 4 <---
输入：一维数组，数组元素按层排列，没有的就用null
输出：一个一维数组，表示该二叉树的最右端元素
class Solution {
public List<Integer> rightSideView(TreeNode root) {
List<Integer> innerList=new ArrayList<Integer>(); // innerList初始化长度为零
Queue<TreeNode> queue=new LinkedList<>();
if (null != root) queue.offer(root); // 尾部插入
while(queue.size()>0){
int size=queue.size();
for (int i=0;i<size;i++){
TreeNode node=queue.poll(); // 队列头部弹出这个元素
if (i==size-1) innerList.add(node.val); // innerList赶快装上这个元素
if(null != node.left) queue.offer(node.left);
if(null != node.right) queue.offer(node.right);
}
}
return innerList;
}
}
加上了一句判断 if (i==size-1) innerList.add(node.val);
去掉了outerList，直接使用了innerList
637.二叉树的层平均值
输入：[3,9,20,null,null,15,7],
输出：[3, 14.5, 11]
解释：
3
/ \
9 20
/ \
15 7
第 0 层的平均值是 3 , 第1层是 14.5 , 第2层是 11 。因此返回 [3, 14.5, 11] 。
输入：一维数组，数组元素按层排列，没有的就用null
输出：一个一维数组，表示该二叉树每层的平均值
class Solution {
public List<Double> averageOfLevels(TreeNode root) {
List<Double> innerList=new ArrayList<Double>(); // innerList初始化长度为零
Queue<TreeNode> queue=new LinkedList<>();
if (null != root) queue.offer(root); // 尾部插入
while(queue.size()>0){
int size=queue.size();
double sum=0; // 这里要是double,才能保证下面sum/size结果是一个小数
for (int i=0;i<size;i++){
TreeNode node=queue.poll(); // 队列头部弹出这个元素
sum = sum + node.val;
if(null != node.left) queue.offer(node.left);
if(null != node.right) queue.offer(node.right);
}
innerList.add(sum/size);
}
return innerList;
}
}
429. N 叉树的层序遍历
给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。
树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
示例 1：
输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]
输入：一维数组，数组元素按层排列，一层没有了就用null
输出：一个一维数组，表示该二叉树每层的平均值
class Solution {
public List<List<Integer>> levelOrder(Node root) {
List<List<Integer>> outerList=new ArrayList<List<Integer>>();
Queue<Node> queue=new LinkedList<>();
if (null != root) queue.offer(root); // 尾部插入
while(queue.size()>0){
int size=queue.size();
List<Integer> innerList=new ArrayList<Integer>(); // innerList初始化长度为零
for (int i=0;i<size;i++){
Node node=queue.poll(); // 队列头部弹出这个元素
innerList.add(node.val); // innerList赶快装上这个元素
for (int j=0;j<node.children.size();j++)
queue.offer(node.children.get(j));
}
outerList.add(innerList);
}
return outerList;
}
}
