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

最新推荐文章于 2024-11-02 20:41:42 发布
最新推荐文章于 2024-11-02 20:41:42 发布
阅读量193 收藏 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;
    }
}
于荣到底是谁
关注
牛客大数据面试题集锦+答案，共523道，46W+字 面试题总结一网打尽
06-13
以后会慢慢把Java相关的面试题、计算机网络等都加进来，其实这不仅仅是一份面试题，更是一份面试参考，让你熟悉面试题各种提问情况，当然，项目部分，就只能看自己了，毕竟每个人简历、实习、项目等都不一样。面试题...
一网打尽：四级考试历年真题集（2016年12月-2023年6月）
06-12
“一网打尽：四级考试历年真题集（2016年12月-2023年6月）” 想要顺利拿下英语四级考试？别再东拼西凑找资料了！我们为您精心整理了从2016年12月至2023年6月的所有四级真题，一网打尽，不留死角。这不仅仅是一本...
【二叉树初阶】前中后序遍历+层序遍历+基础习题
weixin_46016019的博客
04-19 6197
图解二叉树前序、中序、后序、层序遍历详解，以及基础习题解析，
训练营第十三天 | 二叉树的递归遍历、层序遍历
m0_46229261的博客
07-16 327
二叉树1
算法刷题重温（一）：二叉树的 前中后层序 遍历的写法总结（树专题）
Miracle8070
01-19 2016
1. 写在下面 最近又重新开始刷算法题，这次刷题和之前不太一样， 之前刷题的时候，由于对整体宏观没有把握住，所以大多是以框架思维为主，按照从基本的数据结构到算法这样的专题思路进行刷题， 每学一个地方，就要先整理相关理论，然后对应的一些题目刷一遍。 这样的好处是长期下来会形成一个知识框架，后面复刷的时候会很容易梳理总结。 缺点就是太费时间， 我花了很长的一段时间(从上年9月开始吧)，到现在刚整理到一半， 而现在转眼就到了新的一年的快二月份了， 感觉这个思路进行的太慢了， 这样搞下去根本看不到全貌了，所以这次重
二叉树的层序遍历模板
qq_45858191的博客
12-10 450
层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。
二叉搜索树序列问题（一网打尽）
qq_56999918的博客
04-06 2675
一.验证二叉搜索树的前序序列 255. 验证前序遍历序列二叉搜索树 - 力扣（LeetCode） (leetcode-cn.com) 题目描述： 解题思路：
代码随想录算法训练营第十三天 | 二叉树理论基础、递归遍历、迭代遍历、统一迭代、层序遍历
weixin_43581681的博客
07-08 736
满二叉树：节点数量。完全二叉树：底部从左到右。二叉搜索树：左子树所有节点小于中间节点，右子树所有节点大于中间节点，时间复杂度为log(n)。平衡二叉搜索树：左子树和右子树高度差不能超过1。链式存储：为一个链表，指针指向两个子节点。线式存储：用一个字符数组保存二叉树，左子节点为 ，右子节点为 。递归遍历（深度优先搜索）：一直搜到终点再回头换方向，一般用递归实现，也可以用迭代法解决。常见方式：前中后序遍历，前序遍历——中左右，中序遍历——左中右，后续遍历——左右中，什么序中在哪。层序遍历（广度优先搜索）：一层一
Linux常见面试题，一网打尽！
Java技术江湖
05-15 2175
Linux 概述 什么是Linux Unix和Linux有什么区别？ 什么是 Linux 内核？ Linux的基本组件是什么？ Linux 的体系结构 BASH和DOS之间的基本区别是什么？ Linux 开机启动过程？ Linux系统缺省的运行级别？ Linux 使用的进程间通信方式？ Linux 有哪些系统日志文件？ Linux系统安装多个桌面环境有帮助吗？ 什么是交换空间？ 什么是root帐户 什么是LILO？ 什么是BASH？ 什么是CLI？ 什么是GUI？ 开源的优势是什么？ GNU项目的重要性是什
SpringBoot面试题一网打尽
半页童话
12-23 940
1.运行SpringBoot有哪几种方式？ 1.打包用命令或者放到容器中运行 2.用 Maven/ Gradle 插件运行 3.直接执行 main 方法运行
数据结构常见面试题，一网打尽！
Java技术江湖
05-14 3444
（1） 红黑树的了解（平衡树，二叉搜索树），使用场景 把数据结构上几种树集中的讨论一下： 1.AVLtree 定义：最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。 节点的平衡因子是它的左子树的高度减去它的右子树的高度（有时相反）。带有平衡因子1、0或 -1的节点被认为是平衡的。带有平衡因子 -2或2的节点被认为是不平衡的，并需要重新平衡
2021届全国各地高三历史上期模拟题一网打尽 专题五 1、新中国初期的外交 人民版必修1.doc
11-16
2021届全国各地高三历史上期模拟题一网打尽 专题五 1、新中国初期的外交 人民版必修1.doc
Java集合总结【面试题+脑图】，将知识点一网打尽！
04-15
在面试中，不仅要知道这些概念，还要理解其内部工作原理，如ArrayList和Vector的扩容策略，HashMap和Hashtable的同步性及对null的处理，以及集合类的源码分析。熟练掌握这些知识点能够帮助你在面试中表现出色。同时...
2011届全国各地高三历史上期模拟题一网打尽专题二2中国军民维护国家主权的斗争人民版必修1.rar
11-06
标题中的“2011届全国各地高三历史上期模拟题一网打尽专题二2中国军民维护国家主权的斗争人民版必修1.rar”揭示了这个压缩包文件的主要内容，它是一个针对2011年高三历史学生的复习资料集，专注于“中国军民维护国家...
通用型函数——冒泡排序
2401_84654619的博客
10-29 334
计算机中，任何数据最终都是二进制数，故只需有足够的空间，就可以将任何数据存储起来，相应的，读取时使用数据类型容器识别就可还原原本的意思。memcpy函数用于将指定数量的字节从源内存地址（src）复制到目标内存地址（dest）。n : 要复制的字节数，类型为size_t表示要复制的字节的数量。代码：（char型）
数据结构 | 第三章 | 带头双向循环链表
ZJC744575的博客
10-30 471
尾删，随机插入，随机删除的时间复杂度都是O(N)，都需要找到pos的前一个。
【数据结构篇】探索堆的算法的巧妙
braveact的博客
11-02 513
⽤剩余的N-K个元素依次与堆顶元素来⽐较，不满⾜则替换堆顶元素 ，然后再将交换进去后的元素向下调整（保证这k个元素始终是堆），最后将剩余N-k个元素依次与堆顶元素⽐完之后，堆中剩余的K个元素就是所求的前k个最⼩或者最⼤的元素。对于Top-K问题，能想到的最简单直接的⽅式就是排序，但是：如果数据量⾮常⼤，排序就不太可取了 (可能数据都不能⼀下⼦全部加载到内存中)。依次将堆顶最大的数据与最后一个（不断发生变化）元素交换，每次都是将最大的数据放最后，可以想象一下，就是升序了。前k个最⼩的元素，则建⼤堆。
数据结构，问题 F: 括弧匹配检验
最新发布
nick_912912的博客
11-02 117
假设表达式中允许包含两种括号：圆括号和方括号，其嵌套的顺序随意，如（［ ］（））或［（［ ］［ ］）］等为正确的匹配，［（ ]）或（［ ］（ ）或 ( ( ) ) ）均为错误的匹配。输入一个只包含圆括号和方括号的字符串，判断字符串中的括号是否匹配，匹配就输出 “OK” ，不匹配就输出“Wrong”。匹配就输出 “OK” ，不匹配就输出“Wrong”。现在的问题是，要求检验一个给定表达式中的括弧是否正确匹配？输入仅一行字符（字符个数小于255）输入一个字符串：［（［］［］）］，输出：OK。
python的数据结构列表方法及扩展（栈和队列）
闲来垂钓碧溪上的博客
10-30 477
! 使用示例： 使用示例 使用示例： 练习题目1： 练习题目2： collections.deque()队列 列表推导式 从序列中创建新的列表的简单途径，将操作应用于每一个元素，获得新的列表。示例1： 示例： 使用示例： 不仅如此，元组、序列、字典、集合都属于python的数据结构具体使用示例:
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值