【LeetCode每日一题】94. 二叉树的中序遍历 104. 二叉树的最大深度

君万2025-09-06 8:15

每日一题：二叉树

2025.9.4

94. 二叉树的中序遍历

题目

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

示例 1：

输入：root = [1,null,2,3]

输出：[1,3,2]

示例 2：

输入：root = []

输出：[]

示例 3：

输入：root = [1]

输出：[1]

提示：

树中节点数目在范围 [0, 100] 内

-100 <= Node.val <= 100

进阶: 递归算法很简单，你可以通过迭代算法完成吗？

总体思路

迭代：栈模拟

中序遍历顺序：Left → Node → Right。

用栈来模拟递归：

  1. 用指针 cur 从根开始，一路把所有左孩子入栈，直到没有左孩子（cur == nil）。
  2. 弹栈得到当前节点 node，把它的值加入结果。
  3. 让 cur 指向 node.Right，然后继续 1~2 的循环。
  4. 终止条件：cur == nil 且 栈空。
    时间复杂度 O(n)，空间复杂度最坏 O(h)（树高，极端是 O(n)）

递归实现

采用递归（Recursive）的方式：

如果节点为空，直接返回。

否则按照 左 → 根 → 右 的顺序访问节点，把结果存到切片 res 中。

代码

golang
迭代：栈模拟

go 复制代码 
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int   // Val 存储节点的值（int 类型）
 *     Left *TreeNode   // Left 指向左子节点。
 *     Right *TreeNode   // Right 指向右子节点。
 * }
 */
// 无注释纯享：
func inorderTraversal(root *TreeNode) []int {
    res := make([]int, 0)
    stack := make([]*TreeNode, 0)
    cur := root
    for cur !=nil || len(stack) > 0 {
        for cur != nil {
            stack = append(stack,cur)
            cur=cur.Left
        }
        top := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        res = append (res, top.Val)
        cur = top.Right
    }
    return res
}

// 迭代：栈模拟
// 中序遍历（迭代版，使用切片充当栈）
func inorderTraversal(root *TreeNode) []int {
    // 结果切片：存遍历顺序
    res := make([]int, 0)

    // 用切片当栈，元素类型是 *TreeNode
    stack := make([]*TreeNode, 0)

    // cur 指向当前走到的节点
    cur := root

    // Go 没有 while，用 for 当 while：条件为"当前节点非空 或 栈非空"
    for cur != nil || len(stack) > 0 {
        // 1) 先把当前子树的"最左链"全部入栈
        for cur != nil {
            stack = append(stack, cur) // push
            cur = cur.Left
        }

        // 2) 栈顶弹出一个节点
        top := stack[len(stack)-1]      // 取顶
        stack = stack[:len(stack)-1]    // 弹出

        // 访问节点（中序的"根"）
        res = append(res, top.Val)

        // 3) 转向右子树，继续外层循环
        cur = top.Right
    }
    return res
}

递归实现

go 复制代码 
// 无注释纯享：
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{}

    // 定义递归函数 dfs
    var dfs func(*TreeNode)
    dfs = func(node *TreeNode) {
        if node == nil { // 递归终止条件：遇到空节点
            return
        }

        // 1. 先递归遍历左子树
        dfs(node.Left)

        // 2. 访问当前节点，把节点值放入结果切片
        res = append(res, node.Val)

        // 3. 再递归遍历右子树
        dfs(node.Right)
    }

    // 从根节点开始递归
    dfs(root)

    // 返回最终的遍历结果
    return res
}

基础知识

中序遍历（Inorder Traversal）是二叉树遍历的一种方式，遍历顺序为：

遍历左子树->访问根节点->遍历右子树

定义了一个结构体 TreeNode，它代表二叉树的一个节点

Val 存储节点的值（int 类型）。

go 复制代码 
type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

Left 指向左子节点。

Right 指向右子节点。

TreeNode 表示 一个结构体本身。

*TreeNode 表示 指向 TreeNode 的指针。

函数与递归

go 复制代码 
var dfs func(*TreeNode)
dfs = func(node *TreeNode) { ... }

var dfs func(*TreeNode) 声明了一个变量 dfs，它的类型是函数，参数是 *TreeNode（指向二叉树节点的指针），无返回值。

dfs = func(node *TreeNode) { ... } 定义了这个函数的具体内容。

这种写法属于 匿名函数赋值给变量，常用于递归或闭包。

go 复制代码 
dfs(node.Left)  // 遍历左子树
dfs(node.Right) // 遍历右子树

104. 二叉树的最大深度

题目

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

示例 1：

输入：root = [3,9,20,null,null,15,7]

输出：3

示例 2：

输入：root = [1,null,2]

输出：2

提示：

树中节点的数量在 [0, 104] 区间内。

-100 <= Node.val <= 100

总体思路

递归

使用深度优先搜索 DFS的递归方法来计算二叉树的最大深度。其核心思想是：

  1. 递归地计算左子树的最大深度
  2. 递归地计算右子树的最大深度
  3. 取左右子树深度的最大值，然后加上当前节点自身的深度1
  4. 基础情况：当节点为空时，返回深度0

时间复杂度与空间复杂度

时间复杂度：O(n)

  • 每个节点恰好被访问一次，n为二叉树中的节点数量

空间复杂度：O(h)，其中h是树的高度

  • 空间复杂度主要由递归调用栈的深度决定
  • 在最坏情况下（树退化为链表），h = n，空间复杂度为O(n)
  • 在最好情况下（平衡二叉树），h = logn，空间复杂度为O(logn)
  • 平均情况下，空间复杂度为O(h)

深度优先搜索

迭代深度优先搜索（DFS） 来计算二叉树的最大深度。通过使用栈来模拟递归过程，显式地跟踪每个节点及其对应的深度，避免了递归调用的系统栈开销。

算法步骤

  1. 初始化：处理空树情况，初始化栈结构
  2. 根节点入栈：将根节点和初始深度1入栈
  3. 循环处理：不断从栈中弹出节点进行处理
  4. 深度更新：比较并更新最大深度
  5. 子节点入栈：将子节点和对应深度入栈
  6. 返回结果：栈空时返回最大深度

时间复杂度与空间复杂度

  • 时间复杂度 ：O(n)
    • 每个节点都被访问 exactly once
    • n 是树中的节点数量
    • 每个节点的入栈和出栈操作都是O(1)
  • 空间复杂度 ：O(n)
    • 最坏情况下栈的大小等于树的高度
    • 平衡二叉树：O(log n)
    • 链状二叉树（最坏情况）：O(n)
    • 平均情况：O(log n)

广度优先搜索

使用**广度优先搜索（BFS）**的方法来计算二叉树的最大深度。其核心思想是：

  1. 从根节点开始，按层级遍历树的每个节点
  2. 使用队列来存储待处理的节点及其对应的深度
  3. 每次处理一个节点时，如果当前深度大于记录的最大深度，就更新最大深度
  4. 将当前节点的子节点（如果存在）加入队列，并标记为下一层深度
  5. 当队列为空时，说明所有节点都已处理完毕，返回记录的最大深度

时间复杂度与空间复杂度

时间复杂度：O(n)

  • 每个节点恰好被访问一次，n为二叉树中的节点数量

空间复杂度：O(n)

  • 在最坏情况下（完全二叉树），队列中最多会存储约n/2个节点
  • 在最好情况下（链状树），队列中最多会存储1个节点
  • 平均情况下，空间复杂度为O(n)

代码

golang

递归法

go 复制代码 
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func maxDepth(root *TreeNode) int {
    if root == nil {
        return 0
    }
    return max(maxDepth(root.Left),maxDepth(root.Right)) + 1
}
go 复制代码 
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func maxDepth(root *TreeNode) int {
    // 基础情况：如果当前节点为空，返回深度0
    // 这是递归的终止条件
    if root == nil {
        return 0
    }
    
    // 递归计算左子树的最大深度
    leftDepth := maxDepth(root.Left)
    
    // 递归计算右子树的最大深度  
    rightDepth := maxDepth(root.Right)
    
    // 返回左右子树深度的最大值 + 1（当前节点自身的深度）
    // 这里使用了max函数（需要额外定义）
    return max(leftDepth, rightDepth) + 1
}

// 辅助函数：返回两个整数中的较大值
func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

深度优先搜索

go 复制代码 
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func maxDepth(root *TreeNode) int {
    if root == nil {
        return 0
    }
    depth := 0
    stack := []struct{
        node *TreeNode
        level int
    }{}
    stack = append (stack, struct{node *TreeNode; level int}{root, 1})
    for len(stack) > 0 {
        temp := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        if temp.level > depth {
            depth = temp.level
        }
        if temp.node.Right != nil {
            stack = append(stack, struct{node *TreeNode; level int}{temp.node.Right, temp.level + 1})
        }
        if temp.node.Left != nil {
            stack = append(stack, struct{node *TreeNode; level int}{temp.node.Left, temp.level + 1})
        }
    }
    return depth
}
go 复制代码 
/**
 * 计算二叉树的最大深度（迭代版本）
 * 使用深度优先搜索（DFS）策略，通过栈实现迭代遍历
 * 
 * @param root *TreeNode 二叉树的根节点
 * @return int 树的最大深度
 */
func maxDepth(root *TreeNode) int {
    // 边界条件处理：空树深度为0
    if root == nil {
        return 0
    }
    
    // 初始化最大深度变量
    depth := 0
    
    // 定义栈元素的结构体
    // 每个栈元素包含一个树节点和该节点对应的深度
    type stackItem struct {
        node  *TreeNode  // 树节点
        level int        // 该节点所在的深度
    }
    
    // 初始化栈，使用切片模拟栈结构
    // Go语言中没有内置栈结构，使用切片实现栈功能
    stack := []stackItem{}
    
    // 将根节点和初始深度1压入栈中
    // 根节点深度为1，因为深度从1开始计数
    stack = append(stack, stackItem{root, 1})
    
    // 主循环：当栈不为空时继续处理
    // 循环条件：len(stack) > 0
    for len(stack) > 0 {
        // 弹出栈顶元素（后进先出LIFO）
        // 获取栈顶元素
        temp := stack[len(stack)-1]
        // 移除栈顶元素（切片截取）
        stack = stack[:len(stack)-1]
        
        // 更新最大深度
        // 比较当前节点的深度和已知最大深度，取较大值
        if temp.level > depth {
            depth = temp.level
        }
        
        // 处理右子节点（先压入右子节点，后处理）
        // 因为栈是LIFO结构，先压入的后弹出
        // 所以先压入右子节点，保证左子节点先被处理
        if temp.node.Right != nil {
            // 右子节点深度 = 当前节点深度 + 1
            stack = append(stack, stackItem{temp.node.Right, temp.level + 1})
        }
        
        // 处理左子节点（后压入左子节点，先处理）
        if temp.node.Left != nil {
            // 左子节点深度 = 当前节点深度 + 1
            stack = append(stack, stackItem{temp.node.Left, temp.level + 1})
        }
    }
    
    // 返回计算得到的最大深度
    return depth
}

广度优先搜索

go 复制代码 
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func maxDepth(root *TreeNode) int {
    if root == nil {
        return 0
    }
    depth := 0
    queue := []struct{
        node *TreeNode
        level int
    }{}
    queue = append(queue, struct{node *TreeNode; level int}{root, 1})
    for len(queue) > 0 {
        temp := queue[0]
        queue = queue[1:]
        if temp.level > depth {
            depth = temp.level
        }
        if temp.node.Left != nil {
            queue = append(queue, struct{node *TreeNode; level int}{temp.node.Left, temp.level + 1})
        }
        if temp.node.Right != nil {
            queue = append(queue, struct{node *TreeNode; level int}{temp.node.Right, temp.level + 1})
        }
    }
    return depth
}
go 复制代码 
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func maxDepth(root *TreeNode) int {
    // 如果根节点为空，直接返回深度0
    if root == nil {
        return 0
    }
    
    // 初始化最大深度
    depth := 0
    
    // 定义队列，使用结构体存储节点和对应的层级
    // 这里使用了匿名结构体：包含节点指针和层级信息
    queue := []struct{
        node  *TreeNode  // 树节点
        level int        // 该节点所在的深度层级
    }{}
    
    // 将根节点和初始深度1加入队列
    queue = append(queue, struct{node *TreeNode; level int}{root, 1})
    
    // 当队列不为空时循环处理
    for len(queue) > 0 {
        // 从队列头部取出一个元素（先进先出）
        temp := queue[0]
        queue = queue[1:]  // 移除队列头部元素
        
        // 如果当前节点的层级大于记录的最大深度，更新最大深度
        if temp.level > depth {
            depth = temp.level
        }
        
        // 如果当前节点有左子节点，将其加入队列
        // 子节点的深度为当前节点深度+1
        if temp.node.Left != nil {
            queue = append(queue, struct{node *TreeNode; level int}{temp.node.Left, temp.level + 1})
        }
        
        // 如果当前节点有右子节点，将其加入队列
        // 子节点的深度为当前节点深度+1
        if temp.node.Right != nil {
            queue = append(queue, struct{node *TreeNode; level int}{temp.node.Right, temp.level + 1})
        }
    }
    
    // 返回计算得到的最大深度
    return depth
}
相关推荐
机器学习之心5 小时前
多目标鲸鱼优化算法（NSWOA），含46种测试函数和9个评价指标，MATLAB实现
算法·matlab·多目标鲸鱼优化算法·46种测试函数·9个评价指标
max5006006 小时前
基于Meta Llama的二语习得学习者行为预测计算模型
人工智能·算法·机器学习·分类·数据挖掘·llama
王哥儿聊AI7 小时前
Lynx：新一代个性化视频生成模型，单图即可生成视频，重新定义身份一致性与视觉质量
人工智能·算法·安全·机器学习·音视频·软件工程
手握风云-8 小时前
优选算法的寻踪契合：字符串专题
算法
闭着眼睛学算法8 小时前
【华为OD机考正在更新】2025年双机位A卷真题【完全原创题解 | 详细考点分类 | 不断更新题目 | 六种主流语言Py+Java+Cpp+C+Js+Go】
java·c语言·javascript·c++·python·算法·华为od
IT古董9 小时前
【第五章:计算机视觉-项目实战之目标检测实战】2.目标检测实战:中国交通标志检测-(2)中国交通标志检测数据格式转化与读取
算法·目标检测·计算机视觉
MobotStone9 小时前
LLM 采样入门到进阶：理解与实践 Top-K、Top-P、温度控制
算法
杨小码不BUG9 小时前
CSP-J/S初赛知识点精讲-图论
c++·算法·图论·图·编码·csp-j/s初赛
数据知道10 小时前
Go基础：Go语言能用到的常用时间处理
开发语言·后端·golang·go语言
LeaderSheepH10 小时前
常见的排序算法
数据结构·算法·排序算法
热门推荐
01Multisim使用教程详尽版--(2025最新版)02UV 工具安装与国内镜像源配置指南03GitHub 镜像站点0446个Nano-banana 精选提示词，持续更新中05UV安装并设置国内源06Spec-Kit 使用指南07保姆级教程：手把手教你用Dify实现完美多轮对话（附Chatflow和提示词）08VsCode远程Copilot无法使用Claude Agent问题092025年华为杯研赛数学建模竞赛C题完整参考论文 （含模型、MATLAB和Python代码）10KGG转MP3工具|非KGM文件|解密音频