【二叉树遍历入门:从中序遍历到层序与右视图】【LeetCode 热题100】94:二叉树的中序遍历、102:二叉树的层序遍历、199:二叉树的右视图(详细解析)(Go语言版)

简介: 本文详细解析了二叉树的三种经典遍历方式:中序遍历(94题)、层序遍历(102题)和右视图(199题)。通过递归与迭代实现中序遍历,深入理解深度优先搜索(DFS);借助队列完成层序遍历和右视图,掌握广度优先搜索(BFS)。文章对比DFS与BFS的思维方式,总结不同遍历的应用场景,为后续构造树结构奠定基础。

🌳 二叉树遍历入门:从中序遍历到层序与右视图

本文涵盖 LeetCode 上的三道基础但极具代表性的二叉树遍历题:

    1. 二叉树的中序遍历
    1. 二叉树的层序遍历
    1. 二叉树的右视图

通过这些题目,我们将从 DFS 到 BFS,深入理解如何处理树结构的不同维度信息。


🧩 题目一:94. 二叉树的中序遍历

📝 题目描述

给定一棵二叉树,返回它的中序遍历
中序遍历顺序:左子树 → 根节点 → 右子树


💡 解题思路

中序遍历是深度优先搜索(DFS)中的一种经典形式。我们可以通过递归(最自然)或迭代(更贴近底层执行过程)两种方式来完成。


✅ 解法一:递归

func inorderTraversal(root *TreeNode) []int {
   
    res := []int{
   }
    var dfs func(*TreeNode)
    dfs = func(node *TreeNode) {
   
        if node == nil {
   
            return
        }
        dfs(node.Left)
        res = append(res, node.Val)
        dfs(node.Right)
    }
    dfs(root)
    return res
}

🧠 思路总结

递归的核心是“做当前,交给子问题”,结构上非常清晰。


✅ 解法二:迭代(用栈模拟)

func inorderTraversal(root *TreeNode) []int {
   
    res := []int{
   }
    stack := []*TreeNode{
   }
    curr := root
    for curr != nil || len(stack) > 0 {
   
        for curr != nil {
   
            stack = append(stack, curr)
            curr = curr.Left
        }
        curr = stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        res = append(res, curr.Val)
        curr = curr.Right
    }
    return res
}

📌 注意点:

  • 用一个 while 循环控制整体流程。
  • 用一个内嵌的 for 循环不断向左深入。
  • 弹栈后处理当前节点,再转向右子树。

🧩 题目二:102. 二叉树的层序遍历

📝 题目描述

返回一个按层次遍历(每一层从左到右)的节点值数组。


💡 解题思路

层序遍历就是经典的广度优先搜索(BFS),借助队列来完成逐层访问。


✅ 解法:使用队列 BFS

func levelOrder(root *TreeNode) [][]int {
   
    if root == nil {
   
        return [][]int{
   }
    }
    res := [][]int{
   }
    queue := []*TreeNode{
   root}
    for len(queue) > 0 {
   
        level := []int{
   }
        size := len(queue)
        for i := 0; i < size; i++ {
   
            node := queue[0]
            queue = queue[1:]
            level = append(level, node.Val)
            if node.Left != nil {
   
                queue = append(queue, node.Left)
            }
            if node.Right != nil {
   
                queue = append(queue, node.Right)
            }
        }
        res = append(res, level)
    }
    return res
}

📌 关键点:

  • 使用 queue 存储当前层的所有节点。
  • 通过 size 确定每层的边界。
  • 每层遍历完成后将其加入结果集。

🧩 题目三:199. 二叉树的右视图

📝 题目描述

从右侧观察一棵二叉树,返回你能看到的节点值。


💡 解题思路

本质还是 BFS,只不过我们只关心每一层的最后一个节点。


✅ 解法:BFS + 每层最后一个节点

func rightSideView(root *TreeNode) []int {
   
    if root == nil {
   
        return []int{
   }
    }
    res := []int{
   }
    queue := []*TreeNode{
   root}
    for len(queue) > 0 {
   
        size := len(queue)
        for i := 0; i < size; i++ {
   
            node := queue[0]
            queue = queue[1:]
            if i == size-1 {
   
                res = append(res, node.Val)
            }
            if node.Left != nil {
   
                queue = append(queue, node.Left)
            }
            if node.Right != nil {
   
                queue = append(queue, node.Right)
            }
        }
    }
    return res
}

📌 细节提示:

  • 每层的最后一个节点 i == size - 1 才加入结果。
  • 和层序遍历一样,使用 queue 来按层推进。

🧠 总结与反思

遍历类型 算法 数据结构 应用
中序遍历 DFS 栈 / 递归 搜索树性质、线索二叉树
层序遍历 BFS 队列 可视化结构、层级分析
右视图 BFS 队列 一层一个视角节点
  • DFS 与 BFS 的思维方式差异是树结构的关键入门点。
  • 掌握递归与迭代切换思维,对后续复杂结构建树、剪枝、遍历非常重要。

下一篇我们将探索如何通过遍历构造树结构(前序 + 中序 → 构造二叉树、数组 → 平衡搜索树等),敬请期待!

目录
相关文章
|
1月前
|
缓存 监控 安全
告别缓存击穿!Go 语言中的防并发神器:singleflight 包深度解析
在高并发场景中,多个请求同时访问同一资源易导致缓存击穿、数据库压力过大。Go 语言提供的 `singleflight` 包可将相同 key 的请求合并,仅执行一次实际操作,其余请求共享结果,有效降低系统负载。本文详解其原理、实现及典型应用场景,并附示例代码,助你掌握高并发优化技巧。
117 0
|
1月前
|
数据采集 JSON Go
Go语言实战案例:实现HTTP客户端请求并解析响应
本文是 Go 网络与并发实战系列的第 2 篇,详细介绍如何使用 Go 构建 HTTP 客户端,涵盖请求发送、响应解析、错误处理、Header 与 Body 提取等流程,并通过实战代码演示如何并发请求多个 URL,适合希望掌握 Go 网络编程基础的开发者。
|
3月前
|
存储 设计模式 安全
Go 语言单例模式全解析:从青铜到王者段位的实现方案
单例模式确保一个类只有一个实例,并提供全局访问点,适用于日志、配置管理、数据库连接池等场景。在 Go 中,常用实现方式包括懒汉模式、饿汉模式、双重检查锁定,最佳实践是使用 `sync.Once`,它并发安全、简洁高效。本文详解各种实现方式的优缺点,并提供代码示例与最佳应用建议。
71 5
|
3月前
|
Go
【LeetCode 热题100】DP 实战进阶:最长递增子序列、乘积最大子数组、分割等和子集(力扣300 / 152/ 416 )(Go语言版)
本文深入解析三道经典的动态规划问题:**最长递增子序列(LIS)**、**乘积最大子数组** 和 **分割等和子集**。 - **300. LIS** 通过 `dp[i]` 表示以第 `i` 个元素结尾的最长递增子序列长度,支持 O(n²) 动态规划与 O(n log n) 的二分优化。 - **152. 乘积最大子数组** 利用正负数特性,同时维护最大值与最小值的状态转移方程。 - **416. 分割等和子集** 转化为 0-1 背包问题,通过布尔型 DP 实现子集和判断。 总结对比了三题的状态定义与解法技巧,并延伸至相关变种问题,助你掌握动态规划的核心思想与灵活应用!
109 1
|
3月前
|
分布式计算 算法 Go
【LeetCode 热题100】BFS/DFS 实战:岛屿数量 & 腐烂的橘子(力扣200 / 994 )(Go语言版)
本文讲解了两道经典的图论问题:**岛屿数量(LeetCode 200)** 和 **腐烂的橘子(LeetCode 994)**,分别通过 DFS/BFS 实现。在“岛屿数量”中,利用深度或广度优先搜索遍历二维网格,标记连通陆地并计数;“腐烂的橘子”则采用多源 BFS,模拟腐烂传播过程,计算最短时间。两者均需掌握访问标记技巧,是学习网格搜索算法的绝佳实践。
115 1
|
3月前
|
Go
【LeetCode 热题100】BFS/DFS 实战:岛屿数量 & 腐烂的橘子(力扣200 / 994 )(Go语言版)
本篇博客详细解析了三道经典的动态规划问题:198. 打家劫舍(线性状态转移)、279. 完全平方数与322. 零钱兑换(完全背包问题)。通过 Go 语言实现,帮助读者掌握动态规划的核心思想及其实战技巧。从状态定义到转移方程,逐步剖析每道题的解法,并总结其异同点,助力解决更复杂的 DP 问题。适合初学者深入理解动态规划的应用场景和优化方法。
69 0
|
3月前
|
算法 Go 索引
【LeetCode 热题100】回溯:括号生成 & 组合总和(力扣22 / 39 )(Go语言版)
本文深入解析了LeetCode上的两道经典回溯算法题:**22. 括号生成**与**39. 组合总和**。括号生成通过维护左右括号数量,确保路径合法并构造有效组合;组合总和则允许元素重复选择,利用剪枝优化搜索空间以找到所有满足目标和的组合。两者均需明确路径、选择列表及结束条件,同时合理运用剪枝策略提升效率。文章附有Go语言实现代码,助你掌握回溯算法的核心思想。
88 0
|
12月前
|
Unix Shell Linux
LeetCode刷题 Shell编程四则 | 194. 转置文件 192. 统计词频 193. 有效电话号码 195. 第十行
本文提供了几个Linux shell脚本编程问题的解决方案,包括转置文件内容、统计词频、验证有效电话号码和提取文件的第十行,每个问题都给出了至少一种实现方法。
169 6
LeetCode刷题 Shell编程四则 | 194. 转置文件 192. 统计词频 193. 有效电话号码 195. 第十行
|
Python
【Leetcode刷题Python】剑指 Offer 32 - III. 从上到下打印二叉树 III
本文介绍了两种Python实现方法,用于按照之字形顺序打印二叉树的层次遍历结果,实现了在奇数层正序、偶数层反序打印节点的功能。
130 6
|
搜索推荐 索引 Python
【Leetcode刷题Python】牛客. 数组中未出现的最小正整数
本文介绍了牛客网题目"数组中未出现的最小正整数"的解法,提供了一种满足O(n)时间复杂度和O(1)空间复杂度要求的原地排序算法,并给出了Python实现代码。
282 2