2022.2.18 LeetCode —— 二叉树
文章目录
- 一、今日刷题
-
- 1. 第七部分：二叉树 -- 102. 二叉树的层序遍历
- 2. 第七部分：二叉树 -- 107. 二叉树的层序遍历 II
- 3. 第七部分：二叉树 -- 199. 二叉树的右视图
- 4. 第七部分：二叉树 -- 637. 二叉树的层平均值
- 5. 第七部分：二叉树 -- 429. N 叉树的层序遍历
- 二、知识积累
-
- 1.队列Queue的一些方法：
一、今日刷题
1. 第七部分：二叉树 – 102. 二叉树的层序遍历
跳转LeetCode
答案代码：
维护一个队列用于存储树的节点，一个集合用于存储每层遍历到的节点，对队列的操作很巧妙：
一层一层的遍历，
①先加入第一层的 root 节点到队列中，poll 到集合中，再将集合加入 ans
②将 root 的左右子节点（如果不为 null ）加入队列，分别再 poll 到集合中，再将集合加入 ans
③再陆续将上一层所有节点的左右子节点加入队列，分别再 poll 到集合中，再将集合加入 ans
…
直到队列中没有元素，树的节点也就遍历完了。
package BinaryTree;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
/**
* @author: LYZ
* @date: 2022/2/18 19:49
* @description: 105.
*/
public class LevelOrder {
public static void main(String[] args) {
TreeNode root = new TreeNode(1, new TreeNode(2), new TreeNode(3));
LevelOrder levelOrder = new LevelOrder();
List<List<Integer>> ans = levelOrder.levelOrder(root);
System.out.println(ans);
}
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> ans = new ArrayList<>();
if (root == null) {
return ans;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
List<Integer> level = new ArrayList<>();
int levelSize = queue.size(); //做题时差了这个语句，结果就不对了
for (int i = 1; i <= levelSize; i++) {
TreeNode node = queue.poll();
level.add(node.val);
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
ans.add(level);
}
return ans;
}
}
2. 第七部分：二叉树 – 107. 二叉树的层序遍历 II
跳转LeetCode
答案代码：
方法一：
自底向上的层序遍历，我的思路是：整体代码按照自顶向下编写，但引入一个栈，将每一层遍历的节点所存储的集合 level 存入栈，最后利用栈先入后出的原则将元素依次 pop 存入 ans 中。
方法二：
在105题代码最终 return 语句前写
Collections.reverse(ans);
package BinaryTree;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
/**
* @author: LYZ
* @date: 2022/2/18 19:49
* @description: 105.
*/
public class LevelOrder {
public static void main(String[] args) {
TreeNode root = new TreeNode(1, new TreeNode(2), new TreeNode(3));
LevelOrder levelOrder = new LevelOrder();
List<List<Integer>> ans = levelOrder.levelOrder(root);
System.out.println(ans);
}
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> ans = new ArrayList<>();
if (root == null) {
return ans;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
List<Integer> level = new ArrayList<>();
int levelSize = queue.size(); //做题时差了这个语句，结果就不对了
for (int i = 1; i <= levelSize; i++) {
TreeNode node = queue.poll();
level.add(node.val);
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
ans.add(level);
}
return ans;
}
}
3. 第七部分：二叉树 – 199. 二叉树的右视图
跳转LeetCode
答案代码：
依旧是以105的代码思想为基础，我们依然把每层的节点都加入队列，并以此 poll 出来，但我们只需要将每一层的最后一个节点加入 ans，这样ans中存的就是右视图看到的节点。
(在做题时，最开始的思路是在向队列中加入节点时，只取每个节点的右侧子节点，但这样不能解决输入为 [1, 2, null] 的情况)
package BinaryTree;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
/**
* @author: LYZ
* @date: 2022/2/18 20:56
* @description: 199.给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
*/
public class RightSideView {
public static void main(String[] args) {
TreeNode root = new TreeNode(1, new TreeNode(2), new TreeNode(3));
RightSideView rightSideView = new RightSideView();
List<Integer> ans = rightSideView.rightSideView(root);
System.out.println(ans);
}
public List<Integer> rightSideView(TreeNode root) {
List<Integer> ans = new ArrayList<>();
Queue<TreeNode> queue = new LinkedList<>();
if (root == null) {
return ans;
}
queue.offer(root);
while (!queue.isEmpty()) {
int levelSize = queue.size();
for (int i = 0; i < levelSize; i++) {
TreeNode node = queue.poll();
if (i == (levelSize - 1)) {
ans.add(node.val);
}
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
}
return ans;
}
}
4. 第七部分：二叉树 – 637. 二叉树的层平均值
跳转LeetCode
给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10^ -5 以内的答案可以被接受。
答案代码：
依旧是以105的代码思想为基础，但为了对每层取平均值，我们把每一层遍历出来的节点的 val 不再存入集合，而是将 val 加入 sum，将每层的 sum 与 size 做除法运算作为平均值。
package BinaryTree;
import java.util.*;
/**
* @author: LYZ
* @date: 2022/2/18 21:21
* @description: 637.给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。
*/
public class AverageOfLevels {
public static void main(String[] args) {
TreeNode root = new TreeNode(1, new TreeNode(2), new TreeNode(3));
AverageOfLevels averageOfLevels = new AverageOfLevels();
List<Double> ans = averageOfLevels.averageOfLevels(root);
System.out.println(ans);
}
public List<Double> averageOfLevels(TreeNode root) {
List<Double> ans = new ArrayList<>();
if (root == null) {
return ans;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
//List level = new ArrayList<>();
long sum = 0; //注意这里，如果sum为int型，当输入为[2147483647,2147483647,2147483647]时会溢出，第二层的平均值不再是2147483647
int levelSize = queue.size();
for (int i = 1; i <= levelSize; i++) {
TreeNode node = queue.poll();
sum += node.val;
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
double ave = (double) sum / levelSize; //平均值的计算，前几天刚练过数型转换
ans.add(ave);
}
return ans;
}
}
5. 第七部分：二叉树 – 429. N 叉树的层序遍历
跳转LeetCode
给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。
树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
答案代码：
依旧是以105的代码思想为基础，在 for 循环中不再只判断左右子节点，而是直接使用队列的 addAll 方法将所有子节点加入队列（小心空指针异常，记得在方法外套一层if判断语句）
package BinaryTree;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
/**
* @author: LYZ
* @date: 2022/2/18 21:43
* @description: 429. N叉树的层序遍历
*/
public class LevelOrderN {
public static void main(String[] args) {
List<Node> children = new ArrayList<>();
children.add(new Node(2));
children.add(new Node(3));
children.add(new Node(4));
children.add(new Node(5));
Node node = new Node(1, children);
LevelOrderN levelOrderN = new LevelOrderN();
List<List<Integer>> ans = levelOrderN.levelOrderN(node);
System.out.println(ans);
}
public List<List<Integer>> levelOrderN(Node root) {
List<List<Integer>> ans = new ArrayList<>();
if (root == null) {
return ans;
}
Queue<Node> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
List<Integer> level = new ArrayList<>();
int levelSize = queue.size();
for (int i = 1; i <= levelSize; i++) {
Node node = queue.poll();
level.add(node.val);
if (node.children != null) {
queue.addAll(node.children);
}
}
ans.add(level);
}
return ans;
}
}
二、知识积累
1.队列Queue的一些方法：
add 增加一个元索 如果队列已满，则抛出一个 IIIegaISlabEepeplian 异常
remove 移除并返回队列头部的元素 如果队列为空，则抛出一个 NoSuchElementException 异常
element 返回队列头部的元素 如果队列为空，则抛出一个 NoSuchElementException 异常
offer 添加一个元素并返回true 如果队列已满，则返回false
poll 移除并返问队列头部的元素 如果队列为空，则返回null
peek 返回队列头部的元素 如果队列为空，则返回null
put 添加一个元素 如果队列满，则阻塞
take 移除并返回队列头部的元素 如果队列为空，则阻塞
①声明队列：
Queue<String> queue = new LinkedList<String>();
②add()和remove()方法在失败的时候会抛出异常所以不推荐使用。
③操作实例：
import java.util.LinkedList;
import java.util.Queue;
public class Main {
public static void main(String[] args) {
//add()和remove()方法在失败的时候会抛出异常(不推荐)
Queue<String> queue = new LinkedList<String>();
//添加元素
queue.offer("a");
queue.offer("b");
queue.offer("c");
queue.offer("d");
queue.offer("e");
for(String q : queue){
System.out.println(q);
}
System.out.println("===");
System.out.println("poll="+queue.poll()); //返回第一个元素，并在队列中删除
for(String q : queue){
System.out.println(q);
}
System.out.println("===");
System.out.println("element="+queue.element()); //返回第一个元素
for(String q : queue){
System.out.println(q);
}
System.out.println("===");
System.out.println("peek="+queue.peek()); //返回第一个元素
for(String q : queue){
System.out.println(q);
}
}
}
