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

最新推荐文章于 2025-09-05 23:16:08 发布
最新推荐文章于 2025-09-05 23:16:08 发布
阅读量524 收藏 19
点赞数 10
CC 4.0 BY-SA版权
分类专栏： LeetCode 文章标签： leetcode golang 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80103998/article/details/150564326

每日一题：二叉树


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
迭代：栈模拟

/**
 * 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
}

递归实现

// 无注释纯享：
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 类型）。

type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

Left 指向左子节点。
Right 指向右子节点。

TreeNode 表示 一个结构体本身。
*TreeNode 表示 指向 TreeNode 的指针。

函数与递归

var dfs func(*TreeNode)
dfs = func(node *TreeNode) { ... }

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

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

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

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

递归法

/**
 * 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
}

/**
 * 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
}

深度优先搜索

/**
 * 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
}

/**
 * 计算二叉树的最大深度（迭代版本）
 * 使用深度优先搜索（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
}

广度优先搜索

/**
 * 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
}

/**
 * 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
}
LeetCode #94.二叉树的中序遍历
张楚明的博客
08-05 538
LeetCode #94.二叉树的中序遍历
LeetCode94. 二叉树的中序遍历
11-29
正确掌握二叉树中序遍历的原理和实现方法，对于解决LeetCode等平台上的相关算法题是非常有帮助的。在面试或实际工作中的系统设计环节，中序遍历的思想也可以被应用到相关算法的开发中，比如二叉搜索树的查找、删除...
LeetCode 94.二叉树的中序遍历
weixin_50878507的博客
10-16 566
给定一个二叉树的根节点root，返回它的遍历。[0, 100]递归算法很简单，你可以通过迭代算法完成吗？
LeetCode —— [94. 二叉树的中序遍历]
北国觅梦
02-27 694
https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solution/shou-hua-tu-jie-yong-zhan-mo-ni-zhong-xu-bian-li-z/ https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solution/acm-xuan-shou-tu-jie-leetcode-er-cha-shu-mbxp/
【二叉树】Leetcode 94. 二叉树的中序遍历【简单】
FLGB
03-26 577
中序遍历是一种二叉树遍历方式，按照“左根右”的顺序遍历二叉树节点。给定一个二叉树的根节点 root ，返回 它的 中序 遍历。输入：root = [1,null,2,3]输出：[1,3,2]
LeetCode-94. 二叉树的中序遍历(java)
**My Coding Family**
03-18 887
金三银四，又到了刷题月。有时间的话，希望大家还是尽量刷起来咯。帮助往往不是直接体现出来的，但会让你对很多东西的底层实现了解的更深刻。
leetcode94. 二叉树的中序遍历
kkkkuuga的博客
02-05 1096
1.题目描述： 给定一个二叉树的根节点root，返回它的中序遍历。 2.递归中序遍历： /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * Tr.
【Leetcode刷题Python】94. 二叉树的中序遍历
BetterBench的博客
08-06 238
给定一个二叉树的根节点 root ，返回 它的 中序 遍历。示例 1：输入：root = [1,null,2,3]输出：[1,3,2]示例 2：输入：root = []输出：[]示例 3：输入：root = [1]输出：[1]
LeetCode 94.二叉树的中序遍历 (C++)
Xavier_97的博客
08-30 731
因为中序遍历的话我们需要一直深入到左子树底，这样就找不到最初的根节点了，因此这里的想法就是将二叉树改造为线索二叉树。由于根节点左子树中的最右下的节点一定是根节点中序遍历的前驱结点，因此只需要每往下找一层左子树的时候，将根节点赋给前驱结点的right即可，这样就可以找到根节点了。但是要注意的是，二叉树的遍历理论上不会改变二叉树结构，所以要保证遍历完之后所有前驱节点的right重新指向空才行，否则leetcode就会报stack over flow的问题。解法2：迭代，用栈来模拟递归调用的过程。...
【Leetcode】Python实现—94.二叉树的中序遍历
weixin_38615776的博客
07-05 390
目录一、题目描述题目中序遍历介绍二、递归实现递归遍历过程实现代码三、迭代实现 一、题目描述 题目 给定一个二叉树的根节点 root ，返回它的 中序 遍历。 示例1： 输入：root = [1,null,2,3] 输出：[1,3,2] 示例2： 输入：root = [] 输出：[] 示例3： 输入：root = [1,null,2] 输出：[1,2] 中序遍历介绍 二、递归实现 递归遍历过程 1. 前序遍历其左子树； 2. 访问根节点； 3. 前序遍历其右子树； 然后就是一直递归下去，在访问到.
Leetcode题库 94.二叉树的中序遍历(递归 C实现)
dc12499574的博客
03-17 998
文章目录解析代码 解析 中序遍历：先左再中后右 Func函数，接收一个节点，节点非空，则先遍历其左子树，再存入自身val值，最后遍历右子树 ret数组存储每个非空节点的val值 pos为下一个存入ret数组的数据的下标 代码 void Func(struct TreeNode* p,int* ret,int* pos){ if(p==NULL) return; Func(p->left,ret,pos); ret[(*pos)++]=p->val; Fun
wuyuejinxia#Leetcode#94.二叉树的中序遍历1
07-25
示例:输出: [1,3,2]进阶: 递归算法很简单，你可以通过迭代算法完成吗？* Definition for a binary tree node.* pub
java-leetcode题解之第94题二叉树的中序遍历.zip
06-18
中序遍历是二叉树遍历的一种方式，它遵循以下顺序： 1. 遍历左子树 2. 访问根节点 3. 遍历右子树 这种遍历方法在处理二叉搜索树（BST）时特别有用，因为对于BST，中序遍历的结果会按照升序或降序排列。对于非排序...
LeetCode 算法题库【94】——二叉树的中序遍历
12-21
二叉树的中序遍历，这里不太了解的可以看看这个博客：二叉树遍历，总结了二叉树的所有遍历情况。这道题所说的中序遍历，就是按照这个顺序：左子树—> 根结点 —> 右子树的顺序来遍历的。那么递归就很好写了，我还是...
Leetcode每日一练--11
m0_59300085的博客
09-02 180
T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2。，请返回第 n 个泰波那契数 Tn 的值。
【LeetCode&数据结构】栈和队列的应用
2302_80761497的博客
09-02 1002
本文介绍了三种数据结构相关的算法实现：1）使用栈结构判断括号有效性，通过匹配左右括号并处理边界情况；2）用两个队列实现栈功能，通过数据转移模拟栈操作；3）用两个栈实现队列功能，通过数据倒换完成队列操作。每种方法都包含完整的思路分析和代码实现，重点解决了边界条件处理问题，如空栈/队列判断、单元素处理等。这些算法展示了数据结构间的相互转换技巧，体现了栈和队列的特性差异。
【优化版-面试4家12K给了3个offer】LeetCode 热题 100刷题记录-12.最大子数组和
winnerrrrrrrr的博客
09-04 238
易错点如果题目要求的是连续的数组 是不是就意味着不需要两层遍历啊？我有时候在想。遇到好多个算法题目都是要连续的。只要是要求连续的。那么这个数组肯定有规律！这个题目我的暴力枚举，题目说不行。不行 能咋办。学呗！我打算把这个记住。当前 = Math.max(当前 ， 过往+当前)– 精髓！复杂度分析时间复杂度： O(n^2) – 到 – O(n)空间复杂度： O(1)相似题目无进阶思考无。
力扣152:乘积最大子数组
最新发布
weixin_74285822的博客
09-05 249
本文介绍了力扣152题"乘积最大子数组"的解法。该题要求找出数组中乘积最大的非空连续子数组。文章首先分析了一种基于动态规划的初步思路，指出其在处理负数时会失效的问题。随后提出更优的双向遍历解法：通过同时计算从头到尾和从尾到头的乘积，分别处理全正数、奇数个负数和偶数个负数三种情况，并特别处理0值的情况。最终代码实现中，维护两个乘积变量pre和bck，在遍历过程中比较当前值、pre和bck，同时遇到0时重置乘积，从而保证能够正确找到最大乘积。这种方法有效解决了负数乘积反转的问题，时间复杂度为
【LeetCode热题100道笔记】子集
DavidXu的笔记
09-03 799
子集问题的本质是“从n个元素中选择任意k个元素（k=0,1,…,n）”，每个元素有“选”或“不选”两种状态。除结果存储外，仅需O(n)空间存储当前子集（结果本身的空间复杂度为O(n·2ⁿ)，通常不计入算法额外空间）。，将“子集枚举”转化为“二进制数枚举”，通过迭代遍历所有可能的二进制状态，直接映射出所有子集。输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]共2ⁿ个状态，每个状态需遍历n个元素判断是否选中，总操作次数为n·2ⁿ。输出：[[],[0]]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值