【算法通关村 Day6】二叉树层次遍历

news2025/11/1 5:42:42

树与层次遍历青铜挑战

理解树的结构

通过中序和后序遍历序列恢复二叉树是一个经典的二叉树构建问题。给定二叉树的中序遍历序列和后序遍历序列，我们可以利用以下步骤进行恢复。

思路：

  1. 后序遍历的特点：
    • 后序遍历的最后一个节点是树的根节点。
  2. 中序遍历的特点：
    • 中序遍历中，根节点左边的元素是左子树，根节点右边的元素是右子树。

步骤：

  • 从后序遍历的最后一个节点开始，它是树的根节点。
  • 在中序遍历中找到该根节点的位置，它把中序遍历序列分成两部分：左子树和右子树。
  • 递归地对左子树和右子树的中序遍历和后序遍历进行相同的操作，直到所有节点都被处理。
import java.util.HashMap;
import java.util.Map;

public class BinaryTreeBuilder {

    // 定义二叉树节点结构
    static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int val) {
            this.val = val;
        }
    }

    // 用于存储中序遍历的节点索引，方便快速查找
    private Map<Integer, Integer> inorderMap;

   // 主方法，传入中序和后序序列，建立二叉树 
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        inorderMap = new HashMap<>();

        // 将中序遍历的节点及其对应索引存入map
        for(int i = 0; i < inorder.length; i++){
            inorderMap.put(inorder[i], i);
        }

        // 从后序数组的最后一个元素开始，递归构建树
        return build(inorder, postorder, 0, inorder.length - 1, new int[]{postorder.length - 1});
    }

    // 递归构建树
    private TreeNode build(int[] inorder, int[] postorder, int inStart, int inEnd, int[] postIndex){
        // 递归终止条件：没有元素可处理
        if (inStart > inEnd) {
            return null;
        }

        // 确保postIndex不会越界
        if (postIndex[0] < 0) {
            return null;
        }

        //后序遍历的当前节点
        int rootVal = postorder[postIndex[0]--];
        TreeNode root = new TreeNode(rootVal);

        // 获取当前根节点在中序遍历中的位置
        int rootIndex = inorderMap.get(rootVal);

        // 先构建右子树，再构建左子树（因为postorder是后序遍历）
        root.right = build(inorder, postorder, rootIndex + 1, inEnd, postIndex);
        root.left = build(inorder, postorder, inStart, rootIndex - 1, postIndex);
        
        return root;
    }

    // 辅助方法：打印二叉树（中序遍历）
    public void inorderTraversal(TreeNode root){
        if(root != null){
            inorderTraversal(root.left);
            System.out.print(root.val + " ");
            inorderTraversal(root.right);
        }
    }

    public static void main(String[] args) {
        BinaryTreeBuilder builder = new BinaryTreeBuilder();

        //示例
        int[] inorder = {9, 3, 15, 20, 7};
        int[] postorder = {9, 15, 7, 20, 3};

        // 构建二叉树
        TreeNode root = builder.buildTree(inorder, postorder);

        //打印构建的二叉树的中序遍历作验证
        System.out.println("Inorder Traversal: ");
        builder.inorderTraversal(root);
    }
}

  1. 后序遍历：后序遍历的最后一个元素是 3，所以树的根节点是 3。

  2. 中序遍历：在中序遍历数组中，3 位于索引位置 1，这意味着我们可以将树分为左右子树：

    • 左子树：中序序列 {9}（在 3 左边）
    • 右子树：中序序列 {15, 20, 7}（在 3 右边）

  3. 递归构建左子树和右子树：

    • 左子树：对应的后序序列是 {9}。所以左子树的根节点就是 9，没有子节点（因为没有更多元素）。
    • 右子树：右子树的中序序列是 {15, 20, 7}，后序序列是 {15, 7, 20}。我们从后序序列中取出 20 作为右子树的根节点。然后将其继续分为左右子树：
      • 左子树：中序序列 {15} 和后序序列 {15}，所以左子树的根节点就是 15。
      • 右子树：中序序列 {7} 和后序序列 {7}，所以右子树的根节点就是 7。

构建出的树结构：

        3
       / \
      9   20
         /  \
        15   7

树与层次遍历白银挑战

二叉树层次遍历的经典问题

二叉树层次遍历

二叉树的层次遍历（也叫广度优先遍历，BFS）是指从根节点开始，逐层遍历树的节点，每一层从左到右依次访问。

在 Java 中实现二叉树的层次遍历可以使用队列（Queue）来辅助。队列是一种先进先出的数据结构，适合用来逐层遍历树的节点。

假设你已经有了二叉树的定义（TreeNode 类），可以按以下方式实现层次遍历：

import java.util.LinkedList;
import java.util.Queue;

class TreeNode {
    int val;
    TreeNode left, right;

    TreeNode(int val) {
        this.val = val;
        left = right = null;
    }
}

public class BinaryTreeLevelOrderTraversal {
    public void levelOrder(TreeNode root) {
        if (root == null) {
            return;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root); // 将根节点放入队列

        while (!queue.isEmpty()) {
            TreeNode currentNode = queue.poll(); // 取出队首元素

            // 访问当前节点
            System.out.println(currentNode.val + " ");

            // 如果左子节点不为空，将其加入队列
            if (currentNode.left != null) {
                queue.offer(currentNode.left);
            } 

            // 如果右子节点不为空，将其加入队列
            if (currentNode.right != null) {
                queue.offer(currentNode.right);
            }
        }
    }

    public static void main(String[] args) {
        BinaryTreeLevelOrderTraversal tree = new BinaryTreeLevelOrderTraversal();

            // 创建一个示例二叉树
            TreeNode root = new TreeNode(1);
            root.left = new TreeNode(2);
            root.right = new TreeNode(3);
            root.left.left = new TreeNode(4);
            root.left.right = new TreeNode(5);
            root.right.left = new TreeNode(6);
            root.right.right = new TreeNode(7);

            // 执行层次遍历
            System.out.print("Level Order Traversal: ");
            tree.levelOrder(root);
    }
}
  1. TreeNode 类：代表二叉树的节点，每个节点有一个整数值（val），以及指向左右子节点的指针（left 和 right）。
  2. levelOrder 函数：这个方法实现了层次遍历。它使用一个队列来逐层遍历树的节点。根节点首先入队，然后每次从队列中取出一个节点，访问它的值，并将它的左右子节点加入队列，直到队列为空。
  3. 主函数（main）：创建一个示例二叉树并调用 levelOrder 函数进行层次遍历。
  • 时间复杂度：O(n)，其中 n 是树中的节点数。每个节点都只会被访问一次。
  • 空间复杂度：O(n)，最坏情况下，队列中最多会保存树的最大宽度的节点数（即叶子节点的数目）。

处理不同层的值

例题一 在每个树行中找最大值

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

leetcode515

你可以通过广度优先搜索 (BFS) 来遍历二叉树的每一层，然后找出每一层的最大值。具体做法是使用一个队列存储每一层的节点，遍历完一层后找出该层的最大值。

下面是使用 Java 实现的代码：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}

public class LargestValues {
    public List<Integer> largestValues(TreeNode root){
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }

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

        while (!queue.isEmpty()) {
            int levelSize = queue.size();
            // 初始化当前层最大值为最小整数
            int maxVal = Integer.MIN_VALUE;

            for(int i = 0; i < levelSize; i++) {
                TreeNode currentNode = queue.poll();
                // 更新当前层最大值
                maxVal = Math.max(maxVal, currentNode.val);

                if (currentNode.left != null) {
                    queue.offer(currentNode.left);
                }
                if (currentNode.right != null) {
                    queue.offer(currentNode.right);
                }
            }

            result.add(maxVal);
        }

        return result;
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(3);
        root.right = new TreeNode(2);
        root.left.left = new TreeNode(5);
        root.left.right = new TreeNode(3);
        root.right.right = new TreeNode(9);

        LargestValues solution = new LargestValues();
        List<Integer> result = solution.largestValues(root);
        System.out.println(result); // Output: [1, 3, 9]
    }
}

时间复杂度：

  • O(n)，其中 n 是二叉树的节点数。每个节点都被访问一次。

空间复杂度：

  • O(m)，其中 m 是二叉树的最大宽度。最坏情况下，队列存储的是树的最大宽度的节点。
例题二 二叉树的层平均值

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

leetcode637

解法：

同样可以使用层序遍历（BFS）来解这个问题，逐层计算每一层的节点平均值。我们可以使用一个队列来帮助实现层序遍历。对于每一层，计算所有节点的和，并除以该层节点的个数，最后返回结果。

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}

public class AverageOfLevels {
    public List<Double> averageOfLevels(TreeNode root){
        List<Double> result = new ArrayList<>();
        if (root == null) {
            return result;
        }

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

        while (!queue.isEmpty()) {
            int levelSize = queue.size();
            double levelSum = 0;

            for(int i = 0; i < levelSize; i++){
                TreeNode node = queue.poll();
                levelSum += node.val;

                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }

            result.add(levelSum / levelSize);
        }

        return result;
    }
}
例题三 二叉树的右视图

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

leetcode199

  • BFS遍历：我们使用一个队列 queue 来进行广度优先遍历。每次取出一层的节点，然后依次访问这一层的所有节点。

  • 每层最右节点：在遍历一层时，我们只关注该层的最右边的节点，因此在每次循环结束时，我们记录当前层的最后一个节点的值（即右侧可见的节点）。

  • 更新队列：每访问一个节点时，将它的左右子节点（如果有的话）加入队列，这样可以确保后续的层次遍历。

  • 返回结果：最终，result 列表中存储的就是每一层的最右边的节点值，这就是从右侧所能看到的节点值。

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}

public class RightSideView {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }

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

        while (!queue.isEmpty()) {
            int size = queue.size();
            TreeNode rightMostNode = null;

            for(int i = 0; i < size; i++){
                TreeNode currentNode = queue.poll();

                rightMostNode = currentNode;

                if (currentNode.left != null) {
                    queue.offer(currentNode.left);
                }
                if (currentNode.right != null) {
                    queue.offer(currentNode.right);
                }
            }

            result.add(rightMostNode.val);
        }

        return result;
    }    
}
  • 时间复杂度是 O(n)，其中 n 是二叉树中的节点数。我们需要遍历每一个节点。
  • 空间复杂度是 O(m)，其中 m 是二叉树的最大层宽度（即队列中最多存储的节点数）。
例题四 找树左下角的值

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。

假设二叉树中至少有一个节点。

leetcode513

解法：

  • 层序遍历：队列中保存着当前正在遍历的节点。对于每一层的节点，我们需要记录该层的第一个节点，这就是我们所需的“最左边的节点”。
  • leftmostValue：记录每层第一个节点的值。每次进入新的一层，i == 0 时会更新该变量为当前层的第一个节点的值。
  • 队列中的操作：从左到右遍历当前层的节点，每次加入左子节点和右子节点到队列中。
import java.util.LinkedList;
import java.util.Queue;

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}

public class FindBottomLeftValue {
    public int findBottomLeftValue(TreeNode root){
        if (root == null) {
            return -1;
        }

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

        int leftmostValue = 0;

        while (!queue.isEmpty()) {
            int levelSize = queue.size();

            for (int i = 0; i < levelSize; i++) {
                TreeNode currentNode = queue.poll();

                if (i == 0) {
                    leftmostValue = currentNode.val;
                }
                
                if (currentNode.left != null) {
                    queue.offer(currentNode.left);
                }
                if (currentNode.right != null) {
                    queue.offer(currentNode.right);
                }
            }
        }

        return leftmostValue;
    }
}
  • 时间复杂度仍然是 O(N)，因为每个节点都会被访问一次。
  • 空间复杂度是 O(N)，因为在最坏的情况下，队列需要存储二叉树的最后一层节点。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2303959.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

安全面试2

安全面试2

文章目录 简单描述一下什么是水平越权&#xff0c;什么是垂直越权&#xff0c;我要发现这两类漏洞&#xff0c;那我代码审计要注意什么地方水平越权&#xff1a;垂直越权&#xff1a;水平越权漏洞的审计重点垂直越权漏洞的审计重点 解释一下ssrf漏洞原理攻击场景修复方法 横向移…
阅读更多...
【JavaScript进阶】构造函数数据常用函数

【JavaScript进阶】构造函数数据常用函数

目录 本章节用到的所有素材都可以找到&#xff1a;素材自取~~~~ 1、深入对象 1.1创建对象三种方式 1.2 构造函数 练习 利用构造函数创建多个对象 实例化执行过程 1.3实例成员&静态成员 2. 内置构造函数 2.1 Object 2.2 Array 练习 员工涨薪计算成本 2.3 St…
阅读更多...
在PiscTrace开发者版上直接处理图像色阶分布

在PiscTrace开发者版上直接处理图像色阶分布

在图像处理和计算机视觉中&#xff0c;色阶分布&#xff08;或称灰度分布&#xff09;是描述图像中像素强度分布的一个重要概念。它对于理解图像的亮度、对比度、纹理和细节等方面具有关键作用。通过色阶分布的分析&#xff0c;我们能够获得图像的整体信息&#xff0c;从而帮助…
阅读更多...
趣味数学300题1981版-十五个正方形

趣味数学300题1981版-十五个正方形

分析&#xff1a;移动两根变成11个正方形很简单&#xff1a; 移动4根变成15个正方形&#xff0c;分析&#xff1a; 一个田字格包含5个正方形&#xff0c;若要15个正方形需要3个田字格&#xff0c;如果3个田字格完全不重合&#xff0c;需要6*318根火柴。如果合并正方形的边&…
阅读更多...
Selenium实战案例1：论文pdf自动下载

Selenium实战案例1：论文pdf自动下载

在上一篇文章中&#xff0c;我们介绍了Selenium的基础用法和一些常见技巧。今天&#xff0c;我们将通过中国科学&#xff1a;信息科学网站内当前目录论文下载这一实战案例来进一步展示Selenium的web自动化流程。 目录 中国科学&#xff1a;信息科学当期目录论文下载 1.网页内…
阅读更多...
nginx 反向代理 配置请求路由

nginx 反向代理 配置请求路由

nginx | 反向代理 | 配置请求路由 nginx简介 Nginx&#xff08;发音为“Engine-X”&#xff09;是一款高性能、开源的 Web 服务器和反向代理服务器&#xff0c;同时也支持邮件代理和负载均衡等功能。它由俄罗斯程序员伊戈尔西索夫&#xff08;Igor Sysoev&#xff09;于 2004…
阅读更多...
用户中心项目教程（十）---注册里面的重定向排查和相关的修改

用户中心项目教程（十）---注册里面的重定向排查和相关的修改

文章目录 1.注册逻辑的设计和实现2.解决自带的这个重定向的问题3.增加属性的相关操作4.关于如何修改页面上面的绿色按钮 1.注册逻辑的设计和实现 上次说到了的是登录功能&#xff0c;我们使用数据库里面存在的这个存在的账户和密码进行登录&#xff0c;但是是无法进行跳转的&a…
阅读更多...
根据音频中的不同讲述人声音进行分离音频 | 基于ai的说话人声音分离项目

根据音频中的不同讲述人声音进行分离音频 | 基于ai的说话人声音分离项目

0.研究背景 在实际的开发中可能会遇到这样的问题&#xff0c;老板让你把音频中的每个讲话人的声音分离成不同的音频片段。你可以使用au等专业的音频处理软件手动分离。但是这样效率太慢了&#xff0c;现在ai这么发达&#xff0c;我们能否借助ai之力来分离一条音频中的不同的说…
阅读更多...
【单片机】【UDS】 (单帧与多帧) 数据传输

【单片机】【UDS】 (单帧与多帧) 数据传输

对于使用 CAN 的诊断通信系统&#xff0c;每个单帧 (SF)、 第一帧 (FF)、 连续帧 (CF) 或流控 制帧 (FC) 有 8 字节数据场&#xff1b;其中单帧的 CAN_DL≤8 且第一帧的 FF_DL≤4095&#xff1b;下表 中已定义 每个报文的类型。 CAN FD 帧的数据场支持最大 64 个字节&#xff0…
阅读更多...
WebXR教学 02 配置开发环境

WebXR教学 02 配置开发环境

默认操作系统为Windows 1.VS Code VS Code 是一款轻量级、功能强大的代码编辑器&#xff0c;适用于多种编程语言。 下载 步骤 1&#xff1a;访问 VS Code 官方网站 打开浏览器&#xff08;如 Chrome、Edge 等&#xff09;。 在地址栏输入以下网址&#xff1a; https://code.v…
阅读更多...
MySql数据库运维学习笔记

MySql数据库运维学习笔记

数据库运维常识 DQL、DML、DCL 和 DDL 是 SQL&#xff08;结构化查询语言&#xff09;中的四个重要类别&#xff0c;它们分别用于不同类型的数据库操作&#xff0c;下面为你简单明了地解释这四类语句&#xff1a; 1. DQL&#xff08;数据查询语言&#xff0c;Data Query Langu…
阅读更多...
宇树科技13家核心零部件供应商梳理！

宇树科技13家核心零部件供应商梳理！

2025年2月6日&#xff0c;摩根士丹利&#xff08;Morgan Stanley&#xff09;发布最新人形机器人研报&#xff1a;Humanoid 100: Mapping the Humanoid Robot Value Chain&#xff08;人形机器人100&#xff1a;全球人形机器人产业链梳理&#xff09;。 Humanoid 100清单清单中…
阅读更多...
ARMS 助力假面科技研发运维提效，保障极致游戏体验

ARMS 助力假面科技研发运维提效，保障极致游戏体验

客户介绍与项目背景 假面科技成立于 2014 年&#xff0c;致力于打造创新的数字产品&#xff0c;火爆一时的“狼人杀”、“谁是卧底”、“足记相机”都是假面科技旗下产品&#xff0c;公司产品总数超过 40 款&#xff0c;覆盖用户数超过 2 亿人。 随着业务的持续发展&#xff…
阅读更多...
趣味数学300题1981版-八个等式、五个5等于24

趣味数学300题1981版-八个等式、五个5等于24

八个等式 分析&#xff1a;此问题的求解思路是按照最后一步运算的运算符号进行分类。示例中最后一步的运算是除法&#xff0c;只要被除数与除数相等且不为0&#xff0c;就可以得到结果1.因此我们还可以对于结果等于1的情况列出其他的算式。如果保持最后一步运算为除法运算&…
阅读更多...
关闭超时订单和七天自动确认收货+RabbitMQ规范

关闭超时订单和七天自动确认收货+RabbitMQ规范

关闭超时订单 创建订单之后的一段时间内未完成支付而关闭订单的操作&#xff0c;该功能一般要求每笔订单的超时时间是一致的 TTL&#xff08;Time To Live&#xff09;存活时间&#xff0c;只能被设置为某个固定的值&#xff0c;不能更改&#xff0c;否则抛出异常 死信&#…
阅读更多...
【多模态处理篇一】【 深度解析DeepSeek图文匹配：CLIP模型迁移实战——从原理到落地的保姆级教程】

【多模态处理篇一】【 深度解析DeepSeek图文匹配：CLIP模型迁移实战——从原理到落地的保姆级教程】

引言：当CLIP遇到DeepSeek，会发生什么化学反应？ 如果说CLIP是OpenAI为多模态领域投下的"原子弹"，那DeepSeek的迁移实战方案就是给这颗原子弹装上了精确制导系统。这个组合能让你用一张猫咪表情包搜到全网同类梗图，还能让电商平台自动生成百万级商品描述，甚至帮…
阅读更多...
水果生鲜农产品推荐系统 协同过滤余弦函数推荐水果生鲜农产品 Springboot Vue Element-UI前后端分离 代码+开发文档+视频教程

水果生鲜农产品推荐系统 协同过滤余弦函数推荐水果生鲜农产品 Springboot Vue Element-UI前后端分离 代码+开发文档+视频教程

水果生鲜农产品推荐系统 协同过滤余弦函数推荐水果生鲜农产品 Springboot Vue Element-UI前后端分离 【亮点功能】 1.SpringbootVueElement-UIMysql前后端分离 2.Echarts图表统计数据, 直观展示数据情况 3.发表评论后&#xff0c;用户可以回复评论, 回复的评论可以被再次回复, …
阅读更多...
1.vue使用vite构建初始化项目

1.vue使用vite构建初始化项目

npm create vuelatest❯ npm create vuelatest> npx > create-vueVue.js - The Progressive JavaScript Framework✔ Project name: … vue3_test ✔ Add TypeScript? … No / Yes ✔ Add JSX Support? … No / Yes ✔ Add Vue Router for Single Page Application dev…
阅读更多...
在PyCharm中运行Jupyter Notebook的.ipynb文件及其pycharm软件的基础使用

在PyCharm中运行Jupyter Notebook的.ipynb文件及其pycharm软件的基础使用

&#xff08;注意需使用PyCharm专业版&#xff0c;学生、教师可以申请免费使用&#xff1a;https://www.jetbrains.com/shop/eform/students&#xff09; 1. pycharm2024版汉化 https://blog.csdn.net/m0_74103046/article/details/144560999 2. pycharm中的python控制台和J…
阅读更多...
深度体验通义灵码2.0 AI 程序员

深度体验通义灵码2.0 AI 程序员

通义灵码2.0 作为一名开发者&#xff0c;我去年就使用过1.0&#xff0c;近期有幸体验了 2.0&#xff0c;这是一款集成了 Deepseek 大模型的智能编码助手。在这次体验中&#xff0c;我深入探索了新功能开发、跨语言编程、单元测试自动生成、图生代码等多个场景&#xff0c;深刻…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023