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

愿成为大佬腿上的挂件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;
    }
}
相关推荐
Dong雨1 小时前
六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序
数据结构·算法·排序算法
茶猫_2 小时前
力扣面试题 39 - 三步问题 C语言解法
c语言·数据结构·算法·leetcode·职场和发展
初学者丶一起加油2 小时前
C语言基础：指针（数组指针与指针数组）
linux·c语言·开发语言·数据结构·c++·算法·visual studio
半盏茶香4 小时前
C语言勘破之路-最终篇 —— 预处理(上)
c语言·开发语言·数据结构·c++·算法
2401_858286114 小时前
118.【C语言】数据结构之排序(堆排序和冒泡排序)
c语言·数据结构·算法
没事就去码4 小时前
RBTree(红黑树)
数据结构·c++
就爱学编程4 小时前
重生之我在异世界学编程之数据结构与算法：单链表篇
数据结构·算法·链表
CSCN新手听安10 小时前
list的常用操作
数据结构·list
梅茜Mercy11 小时前
数据结构：链表（经典算法例题）详解
数据结构·链表
青春男大12 小时前
java栈--数据结构
java·开发语言·数据结构·学习·eclipse
热门推荐
01大模型国产化适配7-华为昇腾LLM落地可选解决方案（MindFormers、ModelLink、MindIE）02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03玄机平台应急响应—webshell查杀04电赛2024年H题智能小车基于MSPM0G3507主控MCU（利用8路灰度加上MPU6050的解决方式）具体项目报告05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06支付宝短视频平台创作分成激励项目07怎么找小红书美食探店博主合作？08【一文读懂】NTN（非地面网络）技术介绍09优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间10STM32 无法烧录