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

愿成为大佬腿上的挂件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;
    }
}
相关推荐
C++忠实粉丝4 小时前
前缀和(8)_矩阵区域和
数据结构·c++·线性代数·算法·矩阵
ZZZ_O^O5 小时前
二分查找算法——寻找旋转排序数组中的最小值&点名
数据结构·c++·学习·算法·二叉树
代码雕刻家6 小时前
数据结构-3.9.栈在递归中的应用
c语言·数据结构·算法
Kalika0-07 小时前
猴子吃桃-C语言
c语言·开发语言·数据结构·算法
代码雕刻家7 小时前
课设实验-数据结构-单链表-文教文化用品品牌
c语言·开发语言·数据结构
小字节，大梦想9 小时前
【C++】二叉搜索树
数据结构·c++
我是哈哈hh9 小时前
专题十_穷举vs暴搜vs深搜vs回溯vs剪枝_二叉树的深度优先搜索_算法专题详细总结
服务器·数据结构·c++·算法·机器学习·深度优先·剪枝
丶Darling.10 小时前
LeetCode Hot100 | Day1 | 二叉树：二叉树的直径
数据结构·c++·学习·算法·leetcode·二叉树
labuladuo52010 小时前
Codeforces Round 977 (Div. 2) C2 Adjust The Presentation (Hard Version)（思维，set）
数据结构·c++·算法
Indigo_code10 小时前
【数据结构】【链表代码】合并有序链表
数据结构·windows·链表
热门推荐
01【经验分享】Ubuntu22.04安装微信(linux官方版)02安卓系列机型永久去除data分区加密 详细步骤解析032024年高教社杯数学建模国赛C题超详细解题思路分析04CTF网络安全大赛简单的web抓包题目：HEADache05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07pve(Proxmox VE)安装i225v网卡驱动08苍穹外卖面试总结09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10RAG 实践- Ollama+RagFlow 部署本地知识库