【代码随想录刷题】一口气打10道层次遍历 打打打
文章目录
- 1.二叉树的层次遍历
-
- 1.1 解题思路
- 1.2 一口气刷十道题
-
- 1.2.1【102】二叉树的层次遍历
- 1.2.2 【107】二叉树的层次遍历II
-
- 1.2.2.1 题目描述
- 1.2.2.2 java代码实现
- 1.2.3【199】二叉树的右视图
-
- 1.2.3.1 题目描述
- 1.2.3.2 java代码实现
- 1.2.4【637】二叉树的层平均值
-
- 1.2.4.1 题目描述
- 1.2.4.2 java代码实现
- 1.2.5【429】N叉树的层序遍历
-
- 1.2.5.1 题目概述
- 1.2.5.2 java代码实现
- 1.2.6【515】在每个树行中找最大值
-
- 1.2.6.1 题目描述
- 1.2.6.2 java代码实现
- 1.2.7【116】填充每个节点的下一个右侧节点指针
-
- 1.2.7.1 题目描述
- 1.2.7.2 java代码实现
- 1.2.8【117】填充每个节点的下一个右侧节点指针II
- 1.2.9【104】二叉树的最大深度
-
- 1.2.9.1 题目描述
- 1.2.9.2 java代码实现
- 1.2.10【111】二叉树的最小深度
-
- 1.2.10.1 题目描述
- 1.2.10.2 java代码实现
【102】二叉树的层次遍历
【107】二叉树的层次遍历II
【199】二叉树的右视图
【637】二叉树的层平均值
【429】N叉树的层序遍历
【515】在每个树行中找最大值
【116】填充每个节点的下一个右侧节点指针
【117】填充每个节点的下一个右侧节点指针II
【104】二叉树的最大深度
【111】二叉树的最小深度
1.二叉树的层次遍历
1.1 解题思路
- 层序遍历一个二叉树，就是从左到右一层一层的去遍历二叉树。
- 需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。
- 而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。
1.2 一口气刷十道题
1.2.1【102】二叉树的层次遍历
【102】二叉树的层次遍历
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> list=new ArrayList<>();
Deque<TreeNode> que=new LinkedList<>();
if (root == null){
return list;
}
que.offer(root);
while (!que.isEmpty()){
List<Integer> levelList=new ArrayList<>();
int len=que.size();
while (len>0){//len=0说明这一层遍历完了
TreeNode tempNode=que.poll();
levelList.add(tempNode.val);
if (tempNode.left!=null){
que.offer(tempNode.left);
}
if (tempNode.right!=null){
que.offer(tempNode.right);
}
len--;
}
list.add(levelList);
}
return list;
}
}
1.2.2 【107】二叉树的层次遍历II
【107】二叉树的层次遍历II
1.2.2.1 题目描述
给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
1.2.2.2 java代码实现
解法：队列，迭代
把层次遍历得到的结果数组翻转一下即可
/**
把层次遍历得到的结果数组翻转一下即可
*/
class Solution {
public List<List<Integer>> levelOrderBottom(TreeNode root) {
List<List<Integer>> list=new ArrayList<>();
Deque<TreeNode> que=new LinkedList<>();
if (root==null){
return list;
}
que.offer(root);
while (!que.isEmpty()){
List<Integer> levelList=new ArrayList<>();
int len=que.size();
while (len>0){//len=0说明这一层遍历完了
TreeNode tempNode=que.poll();
levelList.add(tempNode.val);
if (tempNode.left!=null){
que.offer(tempNode.left);
}
if (tempNode.right!=null){
que.offer(tempNode.right);
}
len--;
}
list.add(levelList);
}
Collections.reverse(list);
return list;
}
}
1.2.3【199】二叉树的右视图
【199】二叉树的右视图
1.2.3.1 题目描述
给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
1.2.3.2 java代码实现
解法：队列，迭代。
每次返回每层的最后一个字段即可。
/**
解法：队列，迭代。
每次返回每层的最后一个字段即可。
*/
class Solution {
public List<Integer> rightSideView(TreeNode root) {
List<Integer> list=new ArrayList<>();
Deque<TreeNode> que=new LinkedList<>();
if (root==null){
return list;
}
que.offer(root);
while (!que.isEmpty()){
int len=que.size();
for (int i=0;i<len;i++){
TreeNode tempNode=que.poll();
if (tempNode.left!=null){
que.offer(tempNode.left);
}
if (tempNode.right!=null){
que.offer(tempNode.right);
}
if (i==len-1){
list.add(tempNode.val);
}
}
}
return list;
}
}
1.2.4【637】二叉树的层平均值
【637】二叉树的层平均值
1.2.4.1 题目描述
给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。
1.2.4.2 java代码实现
层次遍历每一层之后求个和再取个平均值
class Solution {
public List<Double> averageOfLevels(TreeNode root) {
/**
* 在层次遍历每一层之后求个和再取个平均值
*/
List<Double> list=new ArrayList<>();
Deque<TreeNode> que=new LinkedList<>();
if (root==null){
return list;
}
que.offer(root);
while (!que.isEmpty()){
int len=que.size();
double levelSum=0.0;
for (int i=0;i<len;i++){
TreeNode tempNode=que.poll();
levelSum+=tempNode.val;
if (tempNode.left!=null){
que.offer(tempNode.left);
}
if (tempNode.right!=null){
que.offer(tempNode.right);
}
}
list.add(levelSum/len);
}
return list;
}
}
1.2.5【429】N叉树的层序遍历
【429】N叉树的层序遍历
1.2.5.1 题目概述
给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。
树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
1.2.5.2 java代码实现
解法：队列，迭代
这道题依旧是层次遍历的模板题，只不过一个节点有多个孩子了
class Solution {
public List<List<Integer>> levelOrder(Node root) {
/**
* 解法：队列，迭代
* 这道题依旧是层次遍历的模板题，只不过一个节点有多个孩子了
*/
List<List<Integer>> list=new ArrayList<>();
Deque<Node> que=new LinkedList<>();
if (root==null){
return list;
}
que.offer(root);
while (!que.isEmpty()){
int len= que.size();
List<Integer> levelList=new ArrayList<>();
for (int i=0;i<len;i++){
Node tempNode=que.poll();
levelList.add(tempNode.val);
List<Node> children=tempNode.children;
if (children==null || children.size()==0){
continue;
}
for (Node child : children) {
if (child!=null){
que.offer(child);
}
}
}
list.add(levelList);
}
return list;
}
}
1.2.6【515】在每个树行中找最大值
【515】在每个树行中找最大值
1.2.6.1 题目描述
给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。
1.2.6.2 java代码实现
解法：队列，迭代
层序遍历，取每一层的最大值
class Solution {
public List<Integer> largestValues(TreeNode root) {
/**
* 解法：队列，迭代
* 层序遍历，取每一层的最大值
*/
List<Integer> list=new ArrayList<>();
Deque<TreeNode> que=new LinkedList<>();
if (root==null){
return Collections.emptyList();
}
que.offer(root);
while (!que.isEmpty()){
int max=Integer.MIN_VALUE;
int len=que.size();
for (int i=0;i<len;i++){
TreeNode tempNode=que.poll();
max=Math.max(max,tempNode.val);
if (tempNode.left!=null){
que.offer(tempNode.left);
}
if (tempNode.right!=null){
que.offer(tempNode.right);
}
}
list.add(max);
}
return list;
}
}
1.2.7【116】填充每个节点的下一个右侧节点指针
【116】填充每个节点的下一个右侧节点指针
1.2.7.1 题目描述
给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。
1.2.7.2 java代码实现
本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点， 然后在遍历的时候让前一个节点指向本节点就可以了
//题目中定义了Node
class Node {
public int val;
public Node left;
public Node right;
public Node next;
public Node() {}
public Node(int _val) {
val = _val;
}
public Node(int _val, Node _left, Node _right, Node _next) {
val = _val;
left = _left;
right = _right;
next = _next;
}
};
class Solution {
public Node connect(Node root) {
/**
* 本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，
* 然后在遍历的时候让前一个节点指向本节点就可以了
*/
Queue<Node> que=new LinkedList<>();
if (root!=null){
que.offer(root);
}
while (!que.isEmpty()){
int len= que.size();
Node tempNode=que.poll();
if (tempNode.left!=null){
que.offer(tempNode.left);
}
if (tempNode.right!=null){
que.offer(tempNode.right);
}
for (int i=1;i<len;i++){
Node next=que.poll();
if (next.left!=null){
que.offer(next.left);
}
if (next.right!=null){
que.offer(next.right);
}
tempNode.next=next;
tempNode=next;
}
}
return root;
}
}
1.2.8【117】填充每个节点的下一个右侧节点指针II
【117】填充每个节点的下一个右侧节点指针II
和116一样的，只是116是完美二叉树，此题是二叉树
class Solution {
public Node connect(Node root) {
/**
* 和116一样的，只是116是完美二叉树，此题是二叉树
* 本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，
* 然后在遍历的时候让前一个节点指向本节点就可以了
*/
Queue<Node> que=new LinkedList<>();
if (root!=null){
que.offer(root);
}
while (!que.isEmpty()){
int len= que.size();
Node tempNode=que.poll();
if (tempNode.left!=null){
que.offer(tempNode.left);
}
if (tempNode.right!=null){
que.offer(tempNode.right);
}
for (int i=1;i<len;i++){
Node next=que.poll();
if (next.left!=null){
que.offer(next.left);
}
if (next.right!=null){
que.offer(next.right);
}
tempNode.next=next;
tempNode=next;
}
}
return root;
}
}
1.2.9【104】二叉树的最大深度
【104】二叉树的最大深度
1.2.9.1 题目描述
给定一个二叉树 root ，返回其最大深度。
二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。
1.2.9.2 java代码实现
使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。
在二叉树中，一层一层的来遍历二叉树，记录一下遍历的层数就是二叉树的深度，如图所示：
所以这道题的迭代法就是一道模板题，可以使用二叉树层序遍历的模板来解决的。
class Solution {
public int maxDepth(TreeNode root) {
Queue<TreeNode> que=new LinkedList<>();
if (root==null){
return 0;
}
que.offer(root);
int depth=0;//深度
while (!que.isEmpty()) {
int len=que.size();
for (int i=0;i<len;i++){
TreeNode tempNode=que.poll();
if (tempNode.left!=null){
que.offer(tempNode.left);
}
if (tempNode.right!=null){
que.offer(tempNode.right);
}
}
depth++;
}
return depth;
}
}
1.2.10【111】二叉树的最小深度
【111】二叉树的最小深度
1.2.10.1 题目描述
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。
1.2.10.2 java代码实现
相对于 104.二叉树的最大深度 ，本题还也可以使用层序遍历的方式来解决，思路是一样的。
需要注意的是，只有当左右孩子都为空的时候，才说明遍历的最低点了。 如果其中一个孩子为空则不是最低点。
class Solution {
public int minDepth(TreeNode root) {
/**
* 相对于 104.二叉树的最大深度 ，
* 本题还也可以使用层序遍历的方式来解决，思路是一样的。
*
* 需要注意的是，只有当左右孩子都为空的时候，才说明遍历的最低点了。
* 如果其中一个孩子为空则不是最低点
*/
Queue<TreeNode> que = new LinkedList<>();
if (root == null) {
return 0;
}
que.offer(root);
int depth = 0;
while (!que.isEmpty()){
int len = que.size();
depth++;
TreeNode tempNode = null;
for (int i = 0; i < len; i++) {
tempNode = que.poll();
//如果当前节点的左右孩子都为空，直接返回最小深度
if (tempNode.left == null && tempNode.right == null){
return depth;
}
if (tempNode.left != null) que.offer(tempNode.left);
if (tempNode.right != null) que.offer(tempNode.right);
}
}
return depth;
}
}