二叉树层序遍历 及相关题目

愿成为大佬腿上的挂件2024-04-07 23:26

1，力扣102

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

复制代码 
输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

复制代码 
输入：root = [1]
输出：[[1]]

示例 3：

复制代码 
输入：root = []
输出：[]

提示：

  • 树中节点数目在范围 [0, 2000] 内
  • -1000 <= Node.val <= 1000
java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();//二维数组存数据
        Queue<TreeNode>que = new LinkedList<TreeNode>();//借助队列
        if(root==null) return res;
        que.offer(root);
        while(!que.isEmpty()){//遍历每一层
            int len = que.size();//用于记录每一层节点的个数
            List<Integer>list = new ArrayList<>();
            while(len>0){//对每一层数据进行处理
                TreeNode t = que.poll();
                list.add(t.val);//收集一层数据
                if(t.left!=null) que.offer(t.left);
                if(t.right!=null) que.offer(t.right);
                len--;

            }
            res.add(list);//收集一整层数据

        }
        return res;
    }
}

2，力扣107 二叉树遍历II

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：

复制代码 
输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]

示例 2：

复制代码 
输入：root = [1]
输出：[[1]]

示例 3：

复制代码 
输入：root = []
输出：[]

提示：

  • 树中节点数目在范围 [0, 2000] 内
  • -1000 <= Node.val <= 1000
java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        Queue<TreeNode> que= new LinkedList<>();
        if(root==null) return res;
        que.offer(root);
        while(!que.isEmpty()){
            int len = que.size();
            List<Integer>list = new ArrayList<>();
            while(len > 0){
                TreeNode t = que.poll();
                list.add(t.val);
                if(t.left!=null) que.offer(t.left);
                if(t.right!=null) que.offer(t.right);
                len--;
            }
            res.add(list);
        }
        Collections.reverse(res);//将res逆置一下即可
        return res;
      
    }
}

3， 力扣199

二叉树的右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:

复制代码 
输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

示例 2:

复制代码 
输入: [1,null,3]
输出: [1,3]

示例 3:

复制代码 
输入: []
输出: []

提示:

  • 二叉树的节点个数的范围是 [0,100]
  • -100 <= Node.val <= 100
java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Queue<TreeNode>que = new LinkedList<TreeNode>();//借助队列
        if(root==null) return res;
        que.offer(root);
        while(!que.isEmpty()){//遍历每一层
            int len = que.size();//用于记录每一层节点的个数
            while(len>0){//对每一层数据进行处理
                TreeNode t = que.poll();
                if(len==1){
                res.add(t.val);//只收集每一层的最后一个节点的值
                }
                if(t.left!=null) que.offer(t.left);
                if(t.right!=null) que.offer(t.right);
                len--;
            }
        }
        return res;
    }
}

4，力扣637 二叉树层的平均值

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

示例 1：

复制代码 
输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11] 。

示例 2:

复制代码 
输入：root = [3,9,20,15,7]
输出：[3.00000,14.50000,11.00000]

提示：

  • 树中节点数量在 [1, 104] 范围内
  • -231 <= Node.val <= 231 - 1
java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> res = new ArrayList<>();
        Queue<TreeNode>que = new LinkedList<TreeNode>();//借助队列
        if(root==null) return res;
        que.offer(root);
        while(!que.isEmpty()){//遍历每一层
            int len = que.size();//用于记录每一层节点的个数
            int size = len;//记录len,一会算平均值做分母，
            double sum = 0;
            while(len>0){//对每一层数据进行处理
                TreeNode t = que.poll();
                sum+=t.val;
                if(t.left!=null) que.offer(t.left);
                if(t.right!=null) que.offer(t.right);
                len--;

            }
            double ave = sum/size;
            res.add(ave);
        }
        return res;
    }
}

5， 力扣429 N叉树的层序遍历

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

示例 1：

复制代码 
输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

示例 2：

复制代码 
输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

提示：

  • 树的高度不会超过 1000
  • 树的节点总数在 [0, 10^4] 之间
java 复制代码 
/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();//二维数组存数据
        Queue<Node>que = new LinkedList<Node>();//借助队列
        if(root==null) return res;
        que.offer(root);
        while(!que.isEmpty()){//遍历每一层
            int len = que.size();//用于记录每一层节点的个数
            List<Integer>list = new ArrayList<>();
            while(len>0){//对每一层数据进行处理
                Node t = que.poll();
                list.add(t.val);//收集一层数据
                for(Node child : t.children){//把每个节点的孩子都送进队列
                     que.offer(child);
                     }
                len--;
            }
            res.add(list);//收集一整层数据
        }
        return res;
        
    }
}

5， 力扣515 找每个树行的最大值

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

示例1：

复制代码 
输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]

示例2：

复制代码 
输入: root = [1,2,3]
输出: [1,3]

提示：

  • 二叉树的节点个数的范围是 [0,104]
  • -231 <= Node.val <= 231 - 1
java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Queue<TreeNode>que = new LinkedList<TreeNode>();//借助队列
        if(root==null) return res;
        que.offer(root);
        while(!que.isEmpty()){//遍历每一层
            int len = que.size();//用于记录每一层节点的个数  
            int max = Integer.MIN_VALUE; //使用这种初始化方式的场景通常出现在需要通过比较来找到一个数列中的最大值时        
            while(len>0){//对每一层数据进行处理
                TreeNode t = que.poll();
                if(t.val > max){
                    max = t.val;
                }
                if(t.left!=null) que.offer(t.left);
                if(t.right!=null) que.offer(t.right);
                len--;
            }
            res.add(max);//收集一整层数据
        }
        return res;
    }
}

6，填充每个节点的下一个右侧节点指针

116.填充每个节点的下一个右侧节点指针

力扣题目链接(opens new window)

给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

1

2

3

4

5

6

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

java 复制代码 
/*
// Definition for a 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<Node>();//借助队列
        if(root==null) return root;
        que.offer(root);
        while(!que.isEmpty()){//遍历每一层
            int len = que.size();//用于记录每一层节点的个数
            while(len>0){//对每一层数据进行处理
                Node t = que.poll();
                Node tnext = que.peek();//记录t的下一个节点
                 if(len==1){//每一层的最后一个节点，之后没有节点
                    t.next = null;
                 }else{//后面有节点，则指向后节点
                    t.next = tnext;
                 }

                if(t.left!=null) que.offer(t.left);
                if(t.right!=null) que.offer(t.right);
                len--;
            }
        }
        return root;
    }
}

7，104.二叉树的最大深度

104.二叉树的最大深度

力扣题目链接(opens new window)

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：

给定二叉树 [3,9,20,null,null,15,7]，

返回它的最大深度 3 。

java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
//法一
class Solution {
    public int maxDepth(TreeNode root) {
        if(root==null) return 0;
        Queue<TreeNode>que = new LinkedList<TreeNode>();//借助队列
        que.offer(root);
        int depth=0;//记录深度，初始化为0
        while(!que.isEmpty()){//遍历每一层
            int len = que.size();//用于记录每一层节点的个数
            List<Integer>list = new ArrayList<>();
            while(len>0){//对每一层数据进行处理
                TreeNode t = que.poll();
                list.add(t.val);//收集一层数据
                if(t.left!=null) que.offer(t.left);
                if(t.right!=null) que.offer(t.right);
                len--;
            }
            depth++;//一次遍历完，深度加1
        }
        return depth;
    }
}
java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
//法二递归
class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null) return 0;
        return 1+Math.max(maxDepth(root.left),maxDepth(root.right));
    }
}

8，力扣111， 给定一个二叉树，找出其最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

**说明：**叶子节点是指没有子节点的节点。

示例 1：

复制代码 
输入：root = [3,9,20,null,null,15,7]
输出：2

示例 2：

复制代码 
输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

提示：

  • 树中节点数的范围在 [0, 105] 内
  • -1000 <= Node.val <= 1000
java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        Queue<TreeNode>que = new LinkedList<TreeNode>();//借助队列
        if(root==null) return 0;
        que.offer(root);
        int depth = 0;
        while(!que.isEmpty()){//遍历每一层
            int len = que.size();//用于记录每一层节点的个数
            depth++;//注意这里先深度加一，不能在第二个循环之后++，因为万一就一个节点，就会在下面depth返回出来为0，是错的
            while(len>0){//对每一层数据进行处理
                TreeNode t = que.poll();
                if(t.left!=null) que.offer(t.left);
                if(t.right!=null) que.offer(t.right);
                if(t.left==null&&t.right==null){
                    return depth;
                }
                len--;
            }
            
        }
        return depth;
    }
}
相关推荐
ChoSeitaku3 小时前
链表交集相关算法题|AB链表公共元素生成链表C|AB链表交集存放于A|连续子序列|相交链表求交点位置(C)
数据结构·考研·链表
偷心编程3 小时前
双向链表专题
数据结构
香菜大丸3 小时前
链表的归并排序
数据结构·算法·链表
jrrz08283 小时前
LeetCode 热题100（七）【链表】（1）
数据结构·c++·算法·leetcode·链表
@小博的博客3 小时前
C++初阶学习第十弹——深入讲解vector的迭代器失效
数据结构·c++·学习
泉崎5 小时前
11.7比赛总结
数据结构·算法
你好helloworld5 小时前
滑动窗口最大值
数据结构·算法·leetcode
JSU_曾是此间年少7 小时前
数据结构——线性表与链表
数据结构·c++·算法
sjsjs117 小时前
【数据结构-合法括号字符串】【hard】【拼多多面试题】力扣32. 最长有效括号
数据结构·leetcode
blammmp8 小时前
Java：数据结构-枚举
java·开发语言·数据结构
热门推荐
01如何才能让手机厂商主动拥抱华为，接入鸿蒙系统？02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04Macbook pro M1 安装Ubuntu教程05(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明06【经验分享】Ubuntu22.04安装微信(linux官方版)07文件或文件夹名称中有空格如何批量去除08全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）09RAG 实践- Ollama+RagFlow 部署本地知识库10基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测