二叉树层级遍历以及相关练习
力扣：102. 二叉树的层序遍历 - 力扣（Leetcode）
思想
层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。
使用队列实现二叉树广度优先遍历，动画如下：
步骤
- 先将根节点放到队列中
- 记录当前队列元素个数
- 出队，将出对的元素接收起来
- 判断是否有左右节点，有就加入队列
- 重复2到4步骤，直到队列中没有元素
代码实现
package com.algo.tree.binarytree;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class Algo102 {
//二叉树的层级遍历
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> lists = new ArrayList<>();
if(root==null){
return lists;
}
Queue<TreeNode> queue = new LinkedList<>();
//先将根节点放到队列中
queue.add(root);
while (!queue.isEmpty()){
//记录当前层的元素个数
int num = queue.size();
List<Integer> list = new ArrayList<>();
//从队列中依次取出num个元素进行出队 即到哪一层就将哪一层元素全部出队
for (int i = 0; i < num; i++) {
//出队
TreeNode node = queue.remove();
if(node.left!=null){//如果当前节点的左子节点不为空，那么就将当前节点的左子节点入队
queue.add(node.left);
}
if(node.right!=null){//如果当前节点的右子节点不为空，那么就将当前节点的右子节点入队
queue.add(node.right);
}
//将当前节点的值放到集合中
list.add(node.val);
}
lists.add(list);
}
return lists;
}
}
相关练习
- 107.二叉树的层次遍历II
力扣：107. 二叉树的层序遍历 II - 力扣（Leetcode）
- 先将二叉树层级遍历
- 然后将每层的元素保存到每个集合中
- 再将这些结合翻转
代码实现
package com.algo.tree.binarytree;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class Algo107 {
public List<List<Integer>> levelOrderBottom(TreeNode root) {
List<List<Integer>> lists = new ArrayList<>();
if (root == null) {
return lists;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
//层级遍历
while (!queue.isEmpty()) {
int num = queue.size();
List<Integer> list = new ArrayList<>();
for (int i = 0; i < num; i++) {
TreeNode node = queue.remove();
if (node.left != null) {
queue.add(node.left);
}
if (node.right != null) {
queue.add(node.right);
}
//将每层元素添加到列表中
list.add(node.val);
}
//将每个集合添加到列表中
lists.add(list);
}
//将lists中的元素位置互换
int left = 0;
int right = lists.size() - 1;
while (left <= right) {
List<Integer> list = lists.get(left);
lists.set(left, lists.get(right));
lists.set(right, list);
left++;
right--;
}
return lists;
}
}
- 199.二叉树的右视图
力扣：199. 二叉树的右视图 - 力扣（Leetcode）
- 右视图无非就是每层的最后一个元素
- 先层级遍历二叉树
- 当碰到每层的最后一个元素就加入到列表中
代码实现
package com.algo.tree.binarytree;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class Algo199 {
public List<Integer> rightSideView(TreeNode root) {
List<Integer> list = new ArrayList<>();
if(root==null){
return list;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
//层级遍历
while (!queue.isEmpty()){
int num = queue.size();
for (int i = 0; i < num; i++) {
TreeNode node = queue.remove();
if(node.left!=null){
queue.add(node.left);
}
if(node.right!=null){
queue.add(node.right);
}
//将每层的最后一个元素加入到list中
if(i==num-1){
list.add(node.val);
}
}
}
return list;
}
}
- 637.二叉树的层平均值
力扣：637. 二叉树的层平均值 - 力扣（Leetcode）
- 每层在遍历之前都创建一个sum
- 遍历一层中的每个元素都加到sum中
- 在遍历之后取平均值
- 将平均值加到列表中
代码实现
package com.algo.tree.binarytree;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class Algo637 {
public List<Double> averageOfLevels(TreeNode root) {
List<Double> list = new ArrayList<>();
if(root==null){
return list;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
while (!queue.isEmpty()){
double num = queue.size();
//遍历之前先创建sum
double sum = 0;
for (int i = 0; i < num; i++) {
TreeNode node = queue.remove();
if(node.left!=null){
queue.add(node.left);
}
if(node.right!=null){
queue.add(node.right);
}
//将该层的元素的值全部相加
sum+=node.val;
}
//取平均值加到列表中
list.add( sum/num);
}
return list;
}
}
- 429.N叉树的层序遍历
力扣：429. N 叉树的层序遍历 - 力扣（Leetcode）
- N叉树的层级遍历步骤和二叉树的层级遍历步骤几乎一样
- 先将根节点放到队列中
- 再记录当前队列元素个数
- 出队，将出队元素保存
- 如果该元素有子节点列表，那么就将子节点列表中的元素依次加入到队列中
- 直到队列为空，遍历完毕
package com.algo.tree.binarytree;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class Algo429 {
//N 叉树的层序遍历
public List<List<Integer>> levelOrder(Node root) {
List<List<Integer>> lists = new ArrayList<>();
if(root==null){
return lists;
}
Queue<Node> queue = new LinkedList<>();
queue.add(root);
//层级遍历
while (!queue.isEmpty()){
//记录当前队列元素个数
int num = queue.size();
List<Integer> list = new ArrayList<>();
for (int i = 0; i < num; i++) {
Node node = queue.poll();
if(node.children!=null){
//将当前节点的所有子节点都放到队列中
for(Node node1:node.children){
queue.add(node1);
}
}
//将当前节点的值放到集合中
list.add(node.val);
}
//将当前的集合放到lists中
lists.add(list);
}
return lists;
}
}
- 515.在每个树行中找最大值
力扣：515. 在每个树行中找最大值 - 力扣（Leetcode）
- 在遍历每一层之前创建一个数组
- 用该数组保存该层的每一个元素
- 当该层遍历完毕就对数组进行从小到大排序
- 然后将该数组的最后一个元素加入到列表中
package com.algo.tree.binarytree;
import java.util.*;
public class Algo515 {
public List<Integer> largestValues(TreeNode root) {
List<Integer> list = new ArrayList<>();
if(root==null){
return list;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
while (!queue.isEmpty()){
int num = queue.size();
int[] arr = new int[num];
//遍历每一层
for (int i = 0; i < num; i++) {
TreeNode node = queue.poll();
if(node.left!=null){
queue.add(node.left);
}
if(node.right!=null){
queue.add(node.right);
}
//将每个值存储起来
arr[i] = node.val;
}
//排序
Arrays.sort(arr);
//将排完序的数组的最后一位放到list中
list.add(arr[num-1]);
}
return list;
}
}
- 116.填充每个节点的下一个右侧节点指针
力扣：116. 填充每个节点的下一个右侧节点指针 - 力扣（Leetcode）
- 每次递归前都将当前节点的下一层处理完毕
- 如果当前节点的左子节点不为空 让当前节点的左子节点的next指向当前节点的右子节点
- 如果当前节点的next不为空 让当前节点的右子节点的next指向下一个节点的左子节点
- 向左递归
- 向右递归
package com.algo.tree.binarytree;
import java.util.LinkedList;
import java.util.Queue;
public class Algo116 {
public Node1 connect(Node1 root) {
if(root==null){
return root;
}
//每次递归前都将当前节点的下一层处理完毕
//如果当前节点的左子节点不为空 让当前节点的左子节点的next指向当前节点的右子节点
if(root.left!=null){
root.left.next = root.right;
if(root.next!=null){//如果当前节点的next不为空 让当前节点的右子节点的next指向下一个节点的左子节点
root.right.next = root.next.left;
}
}
connect(root.left);
connect(root.right);
return root;
}
}
- 117.填充每个节点的下一个右侧节点指针II
力扣：117. 填充每个节点的下一个右侧节点指针 II - 力扣（Leetcode）
- 因为这不是完美二叉树，所以得用层级遍历的思想
- 遍历每一层，在未遍历完该层时让出队列的元素的next指向队列头部元素
- 当遍历到该层最后一个元素时，就将该元素的next指向null
- 最后返回头结点
package com.algo.tree.binarytree;
import java.util.LinkedList;
import java.util.Queue;
public class Algo117 {
public Node1 connect(Node1 root) {
if(root==null){
return root;
}
Queue<Node1> queue = new LinkedList<>();
queue.add(root);
//层级遍历
while (!queue.isEmpty()){
int num = queue.size();
for (int i = 0; i < num; i++) {
Node1 node1 = queue.poll();
if(node1.left!=null){
queue.add(node1.left);
}
if(node1.right!=null){
queue.add(node1.right);
}
if(i==num-1){
//让当前层的最后一个元素指向null
node1.next=null;
}else{
//让当前节点指向队列的头 当当前层的元素没有出完时 对头元素永远是当前节点的下一个元素
node1.next = queue.peek();
}
}
}
return root;
}
}
- 104.二叉树的最大深度
力扣：104. 二叉树的最大深度 - 力扣（Leetcode）
- 分别向左和向右递归
- 返回深度最大的值
package com.algo.tree.binarytree;
public class Algo104 {
public int maxDepth(TreeNode root) {
return root == null ? 0 : Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
}
}
- 111.二叉树的最小深度
力扣：111. 二叉树的最小深度 - 力扣（Leetcode）
- 有5中情况
- 第一种：当根节点为空时返回0
- 第二种：当根节点不为空但是没有子节点返回1
- 第三种：当根节点不为空且左右子节点也不为空时，分别向左和向右递归，取最小值
- 第四种：当根节点不为空且左子节点不为空而右子节点为空，那么向左子节点递归
- 第五种：当根节点不为空且右子节点不为空而左子节点为空，那么向右子节点递归
package com.algo.tree.binarytree;
public class Algo111 {
public int minDepth(TreeNode root) {
if(root==null){
return 0;
}else if(root.left==null&&root.right==null){
return 1;
}else if(root.left!=null&&root.right!=null){
return Math.min(minDepth(root.left),minDepth(root.right))+1;
}else if(root.left!=null){
return minDepth(root.left)+1;
}else {
return minDepth(root.right)+1;
}
}
}
567
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
