一网打尽二叉数的层序遍历及相关衍生题

最新推荐文章于 2024-05-22 13:02:21 发布
最新推荐文章于 2024-05-22 13:02:21 发布
阅读量147 收藏 4
点赞数 8
文章标签： 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43743971/article/details/137527529
版权

一网打尽二叉数的层序遍历及相关衍生题

基本概念：层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

leetcode102.二叉树的层序遍历

代码如下：

/**
 * 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>> result = new ArrayList<>();
        
        // 如果根节点为空，则返回空列表
        if(root == null){
            return result;
        }
        
        // 使用队列进行层序遍历，初始时包含根节点
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        
        // 当队列不为空时，继续遍历
        while(!queue.isEmpty()){
            // 用于存储当前层节点值的列表
            List<Integer> currentLevel = new ArrayList<>();
            // 当前层的节点数
            int size = queue.size();
            
            // 遍历当前层的所有节点
            while(size > 0){
                // 从队列中取出一个节点
                TreeNode node = queue.poll();
                // 将节点的值加入当前层结果列表中
                currentLevel.add(node.val);
                // 如果节点有左子节点，将左子节点加入队列
                if(node.left != null){
                    queue.offer(node.left);
                }
                // 如果节点有右子节点，将右子节点加入队列
                if(node.right != null){
                    queue.offer(node.right);
                }
                // 处理完一个节点，当前层待处理节点数减一
                size--;
            }
            // 将当前层的结果加入到最终结果列表中
            result.add(currentLevel);
        }
        // 返回层序遍历的结果
        return result;
    }
}

leetcode107二叉树的层序遍历2

代码如下：

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        // 存储正序层序遍历结果
        List<List<Integer>> result = new ArrayList<>();
        
        // 如果根节点为空，则直接返回空列表
        if(root == null){
            return result;
        }
        
        // 使用队列进行层序遍历
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root); // 初始将根节点加入队列
        
        // 当队列不为空，说明还有节点未被处理
        while(!queue.isEmpty()){
            // 存储当前层的节点值
            List<Integer> currentLevel = new ArrayList<>();
            // 当前层的节点数
            int size = queue.size();
            
            // 遍历当前层的所有节点
            while(size > 0){
                // 从队列中取出节点
                TreeNode node = queue.poll();
                // 将节点值加入当前层结果列表
                currentLevel.add(node.val);
                // 如果节点有左子节点，加入队列
                if(node.left != null){
                    queue.offer(node.left);
                }
                // 如果节点有右子节点，加入队列
                if(node.right != null){
                    queue.offer(node.right);
                }
                // 处理完一个节点后，待处理节点数减一
                size--;
            }
            // 将当前层结果加入正序结果列表
            result.add(currentLevel);
        }
        
        // 用于存储逆序结果
        List<List<Integer>> list = new ArrayList<>();
        // 将正序结果逆序加入list
        for(int i = result.size() - 1; i >= 0; i--){
            list.add(result.get(i));
        }
        // 返回逆序的层序遍历结果
        return list;
    }
}

leetcode199二叉树的右视图

代码如下：

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        // 结果列表，用于存储每一层最右侧节点的值
        List<Integer> result = new ArrayList<>();
        // 如果根节点为空，则直接返回空的结果列表
        if(root == null){
            return result;
        }
        
        // 使用队列进行层序遍历
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root); // 将根节点加入队列
        
        // 当队列不为空时，继续遍历
        while(!queue.isEmpty()){
            // 当前层的节点数
            int size = queue.size();
            
            // 遍历当前层的所有节点
            while(size > 0){
                // 从队列中取出一个节点
                TreeNode node = queue.poll();
                size--; // 处理完一个节点后，当前层待处理节点数减一
                
                // 如果当前节点是该层的最后一个节点，则将其值加入结果列表
                if(size == 0){
                    result.add(node.val);
                }
                
                // 如果节点有左子节点，加入队列
                if(node.left != null){
                    queue.offer(node.left);
                }
                // 如果节点有右子节点，加入队列
                if(node.right != null){
                    queue.offer(node.right);
                }               
            }
        }
        // 返回从二叉树的右边看过去能看到的节点值
        return result;
    }
}

leetcode637. 二叉树的层平均值

代码如下：

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        // 用于存储每一层节点值平均数的结果列表
        List<Double> result = new ArrayList<>();
        // 如果根节点为空，则直接返回空的结果列表
        if(root == null){
            return result;
        }
        
        // 使用队列进行层序遍历
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root); // 将根节点加入队列
        
        // 当队列不为空时，继续遍历
        while(!queue.isEmpty()){
            // 当前层的节点数
            int size = queue.size();
            // 用于累计当前层节点值的总和
            double levelSum = 0.0;
            // 保存当前层的长度，用于计算平均值
            int currentLength = size;
            
            // 遍历当前层的所有节点
            while(size > 0){
                // 从队列中取出一个节点
                TreeNode node = queue.poll();
                // 将当前节点的值加入到当前层总和中
                levelSum += node.val;

                // 如果节点有左子节点，加入队列
                if(node.left != null){
                    queue.offer(node.left);
                }
                // 如果节点有右子节点，加入队列
                if(node.right != null){
                    queue.offer(node.right);
                }
               // 处理完一个节点后，当前层待处理节点数减一
               size--;
            }
            // 计算当前层的平均值，并加入到结果列表中
            result.add(levelSum/currentLength);
        }
        // 返回每一层节点值平均数的列表
        return result;
    }
}

leetcode429. N 叉树的层序遍历

代码如下：

/*
// 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>> result = new ArrayList<>();
        // 如果根节点为空，则直接返回空列表
        if (root == null) {
            return result;
        }

        // 使用队列支持层序遍历的实现
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root); // 初始时，队列中只有根节点

        // 当队列不为空，继续遍历
        while (!queue.isEmpty()) {
            // 用于存储当前层节点值的列表
            List<Integer> currentLevel = new ArrayList<>();
            int size = queue.size(); // 当前层的节点数量

            // 遍历当前层的所有节点
            while (size > 0) {
                Node node = queue.poll(); // 从队列中取出一个节点
                currentLevel.add(node.val); // 将节点的值添加到当前层的列表中

                // 使用迭代器遍历当前节点的所有子节点
                Iterator<Node> iterator = node.children.iterator();
                while (iterator.hasNext()) {
                    Node child = iterator.next();
                    if (child != null) {
                        queue.offer(child); // 子节点非空则加入队列，以便后续遍历
                    }
                }

                size--; // 处理完一个节点，当前层待处理节点数减一
            }

            // 当前层遍历完成，将当前层的结果添加到最终结果列表中
            result.add(currentLevel);
        }

        // 返回层序遍历的结果
        return result;
    }
}

leetcode515. 在每个树行中找最大值

代码如下：

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        // 结果列表，用于存储每一层的最大值
        List<Integer> result = new ArrayList<>();
        // 如果根节点为空，直接返回空列表
        if(root == null){
            return result;
        }
        
        // 使用队列支持按层遍历树的节点
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root); // 将根节点加入队列开始遍历
        
        // 当队列不为空，继续按层遍历
        while(!queue.isEmpty()){
            // 用于记录当前层的最大值，初始设为最小可能值
            int levelMax = Integer.MIN_VALUE;
            // 当前层的节点数量
            int length = queue.size();
            
            // 遍历当前层的所有节点
            while(length > 0){
                // 从队列中取出一个节点
                TreeNode node = queue.poll();
                // 更新当前层的最大值
                levelMax = Math.max(levelMax, node.val);
                
                // 如果当前节点有左子节点，加入队列
                if(node.left != null){
                    queue.offer(node.left);
                }
                // 如果当前节点有右子节点，加入队列
                if(node.right != null){
                    queue.offer(node.right);
                }
                // 处理完一个节点，当前层待处理节点数减一
                length--;
            }
            // 将当前层的最大值加入结果列表
            result.add(levelMax);
        }
        // 返回每一层的最大值组成的列表
        return result;
    }
}

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

代码如下：

/*
// 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) {
        // 如果根节点为空，则不需要连接节点，直接返回 null
        if (root == null) {
            return null;
        }
        
        // 使用队列进行层序遍历，初始时队列中只有根节点
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);
        
        // 当队列不为空时，持续进行层序遍历
        while (!queue.isEmpty()) {
            // 当前层的节点数量
            int size = queue.size();
            
            // 遍历当前层的所有节点
            for (int i = 0; i < size; i++) {
                // 从队列中取出当前节点
                Node node = queue.poll();
                // 如果当前节点不是这一层的最后一个节点
                // 则将当前节点的 next 指针指向队列的头部节点（即这一层的下一个节点）
                if (i < size - 1) {
                    node.next = queue.peek();
                }
                
                // 将当前节点的左右子节点加入队列中，以便下一轮遍历
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }      
        }
        // 返回处理过的树的根节点
        return root;
    }
}

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

代码如下：

class Solution {
    public Node connect(Node root) {
        // 如果根节点为空，则不需要连接节点，直接返回 null
        if (root == null) {
            return null;
        }
        
        // 使用队列进行层序遍历，初始时队列中只有根节点
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);
        
        // 当队列不为空时，持续进行层序遍历
        while (!queue.isEmpty()) {
            // 当前层的节点数量
            int size = queue.size();
            
            // 遍历当前层的所有节点
            for (int i = 0; i < size; i++) {
                // 从队列中取出当前节点
                Node node = queue.poll();
                // 如果当前节点不是这一层的最后一个节点
                // 则将当前节点的 next 指针指向队列的头部节点（即这一层的下一个节点）
                if (i < size - 1) {
                    node.next = queue.peek();
                }
                
                // 将当前节点的左右子节点加入队列中，以便下一轮遍历
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }      
        }
        // 返回处理过的树的根节点
        return root;
    }
}

leetcode104. 二叉树的最大深度

代码如下：

class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int depth = 0;

        while (!queue.isEmpty()) {
            int size = queue.size(); // 当前层的节点数
            // 使用 for 循环来遍历这一层的所有节点
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
            }
            depth++; // 完成一层的遍历，深度加一
        }

        return depth;
    }
    
}

111. 二叉树的最小深度

代码如下：

class Solution {
    public int minDepth(TreeNode root) {
          if (root == null) {
            return 0;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int depth = 1; // 根节点本身就是一层，因此初始深度为1

        while (!queue.isEmpty()) {
            int size = queue.size(); // 当前层的节点数
            
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                
                // 检查是否达到叶子节点
                if (node.left == null && node.right == null) {
                    return depth; // 找到最近的叶子节点，返回当前深度
                }
                
                // 将当前节点的左右子节点加入队列
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            
            depth++; // 完成一层的遍历，深度加一
        }

        return depth;
    }
}
于荣到底是谁
关注
  • 8
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
牛客大数据面试题集锦+答案，共523道，46W+字 面试题总结一网打尽
06-13
以后会慢慢把Java相关的面试题、计算机网络等都加进来，其实这不仅仅是一份面试题，更是一份面试参考，让你熟悉面试题各种提问情况，当然，项目部分，就只能看自己了，毕竟每个人简历、实习、项目等都不一样。面试题...
【二叉树初阶】前中后序遍历+层序遍历+基础习题
weixin_46016019的博客
04-19 5368
图解二叉树前序、中序、后序、层序遍历详解，以及基础习题解析，
算法刷题重温（一）：二叉树的 前中后层序 遍历的写法总结（树专题）
Miracle8070
01-19 1854
1. 写在下面 最近又重新开始刷算法题，这次刷题和之前不太一样， 之前刷题的时候，由于对整体宏观没有把握住，所以大多是以框架思维为主，按照从基本的数据结构到算法这样的专题思路进行刷题， 每学一个地方，就要先整理相关理论，然后对应的一些题目刷一遍。 这样的好处是长期下来会形成一个知识框架，后面复刷的时候会很容易梳理总结。 缺点就是太费时间， 我花了很长的一段时间(从上年9月开始吧)，到现在刚整理到一半， 而现在转眼就到了新的一年的快二月份了， 感觉这个思路进行的太慢了， 这样搞下去根本看不到全貌了，所以这次重
二叉树的层序遍历模板
qq_45858191的博客
12-10 416
层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。
二叉搜索树序列问题（一网打尽）
qq_56999918的博客
04-06 2528
一.验证二叉搜索树的前序序列 255. 验证前序遍历序列二叉搜索树 - 力扣（LeetCode） (leetcode-cn.com) 题目描述： 解题思路：
teechart应用文档,vfp示例及控件一网打尽demo
05-03
teechart应用文档,vfp示例及控件一网打尽demo
2021届全国各地高三历史上期模拟题一网打尽 专题五 1、新中国初期的外交 人民版必修1.doc
11-16
2021届全国各地高三历史上期模拟题一网打尽 专题五 1、新中国初期的外交 人民版必修1.doc
蓝桥杯历年真题（PDF）
12-03
蓝桥杯单片机比赛历年初赛（省赛）真题，从第一届到今年的真题最新资源一网打尽，最近两年还包含客观题部分，
让你的测试用例将软件bug一网打尽
02-26
下面便以一次亲身经历来说说设计测试用例的几大要点吧。首先说说基本背景。TopCoder是一个对全世界程序开发爱好者开放的平台，在上面可以讨论、交流、竞赛。这里真的是汇聚了世界上最顶尖的算法高手。...
数据结构堆排序（c语言版）
z6665454的博客
05-18 1172
在构建好堆之后,堆排序会进行反复的交换和调整操作,将堆顶元素(最大值或最小值)与堆的最后一个元素交换,然后缩小堆的规模。堆排序的优势是能够在一个数组上就地完成排序,不需要额外的空间。堆排序是一种原地排序算法,不需要额外的内存空间来辅助排序,而是直接在原数组上进行操作。大顶堆的根节点是数组中的最大值,小顶堆的根节点是数组中的最小值。堆排序的主要功能是对一个给定的数组进行升序或降序排序。大顶堆的特点是根节点的值大于或等于其左右子节点的值。堆排序的时间复杂度为O(nlogn),这使它成为高效的通用排序算法之一。
OpenHarmony 实战开发——内核IPC机制数据结构解析
maniuT的博客
05-21 596
队列控制块：管理具体消息队列的数据块，内核初始化时调用OsQueueInit()创建，并依次挂载到双向环形链表g_freeQueueList中，此时控制块状态为OS_QUEUE_UNUSED，队列控制块用来保存队列的状态，队列长度、消息长度、队列ID、队列头尾位置和等待读写的任务列表，内核就是根据这些信息来管理消息队列和任务完成对消息读写等操作。任意时刻互斥锁的状态只有开锁或闭锁，当有任务持有时，互斥锁处于闭锁状态，任务获得该互斥锁的所有权；当该任务释放它时，互斥锁被开锁，任务失去该互斥锁的所有权；
二叉树
xkroy的博客
05-22 470
二叉树
刷题篇--数据结构--链表
hyldzbg的博客
05-18 417
如果我们有一个链表是1-->2-->3-->4-->5这样的，那我们反转后就是5-->4-->3-->2-->1这样的，那么要如果对链表操作呢？我们可以发现在反转后的链表里1-->2,变成2-->1那么我们就顺着这个思路，直接将下一个节点插到头节点前不就好了！！看起来好像不是很难，但是实现起来却很简单😉👌，嘿嘿！(^0^)我们可以再思考一下，将一个节点插到头节点前不就是头插嘛对不对，所以我们可以直接利用头插的方法来解决问题。
【数据结构】神奇的二叉树
flmz_Kk的博客
05-18 736
详细介绍数据结构中二叉树的概念，遍历等等
C：通过fwrite和fread读写数据结构
qq_35662333的博客
05-21 715
如果发生错误或到达文件末尾，则 fread()返回的值将小于参数 nmemb，那么到底发生了错误 还是到达了文件末尾，fread()不能区分文件结尾和错误，究竟是哪一种情况，此时可以使用 ferror()或 feof() 函数来判断。返回值： 调用成功返回一个指向 FILE 类型对象的指针（ FILE * ），该指针与打开或创建的文件相关联， 后续的标准 I/O 操作将围绕 FILE 指针进行。如果文件名称与已存在的文件相同，则会删除已有文件的内容，文件被视为一个新的空文件。如果文件不存在，则创建文件。
数据结构——栈
2302_80339723的博客
05-15 327
1.我们可以定义一个结构体（ struct stack），其中有数组（SLDataType *a），栈顶元素的下标（top）和栈的空间（capacity）。通常为0.我们会将栈为空时状态定义为以下，但是如果将没有元素时top为0，这是top指向的就不是栈顶元素，而是栈顶元素的下一个元素。我们可以实现一个静态栈（数组的长度是一定），但是这种结构并不实用，我们接下来实现的是动态栈。如果不是左括号，就要判断栈是不是为空，若为空，直接返回false，不为空，再取栈顶元素与之比较。总体来说，实现一个栈还是很容易的。
数据结构--双向链表
2301_78724721的博客
05-18 837
LTNode;date用来存储数据 ，next指针保存下个节点，prev指针保存前一个节点。
Java—选择排序
最新发布
qq_56725871的博客
05-22 237
它的基本思想是从待排序的数据中选择最小（或最大）的元素，放到已排序序列的末尾（或开头），然后再从剩余未排序的元素中选择最小（或最大）的元素，放到已排序序列的末尾（或开头），以此类推，直到全部元素排序完成。选择排序的时间复杂度为O(n^2)，其中n为待排序数组的长度。尽管选择排序的时间复杂度较高，但它简单易懂，适用于小规模数据的排序。对于大规模数据，更高效的排序算法如快速排序和归并排序更为常用。以上代码通过遍历整个数组，找到剩余未排序部分的最小值，并将其与当前位置的元素交换，重复这个过程直到数组排序完成。
1 km fishnet
08-08
1公里长的渔网可以覆盖一大片水域，将游弋在附近的鱼群一网打尽。渔网的网孔大小可以根据目标鱼类的大小来调整，从而实现有效的捕捞。 渔网与传统的捕鱼方式相比具有以下几个优势。首先，渔网可以迅速覆盖大面积...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值