LeetCode Hot100（28/100）——104. 二叉树的最大深度

文章目录

一、题目理解

题目链接：https://leetcode.cn/problems/maximum-depth-of-binary-tree

题目描述：

给定一个二叉树的根节点 root，返回它的 最大深度。

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

示例：

输入：

复制代码

输出：

复制代码

解释：

根节点到叶子最深的路径是 3 → 20 → 15 或 3 → 20 → 7，深度为 3。

二、问题分析

本题是一道经典的树形递归问题。二叉树每个节点都有左右子树，因此树的最大深度可由以下递推关系确定：

maxDepth(root) = 1 + max(maxDepth(root.left), maxDepth(root.right))

即：

当前节点为空时深度为0；
当前节点非空时，取左右子树的最大深度，再加上当前节点。

思维导图

二叉树最大深度
递归法
左右子树递归计算深度
深度为左右子树最大值+1
迭代法（BFS）
层序遍历统计层数
每层遍历完深度+1
DFS迭代法（栈）
模拟递归
每次入栈保存深度数据

三、解法一：递归法（最直接思路）

思路：

如果当前节点为空，返回深度 0；
否则递归地计算左右子树的最大深度；
当前节点的深度等于 max(左子树深度, 右子树深度) + 1。

递归流程图

是
否
开始
当前节点为空？
返回0
计算左子树深度
计算右子树深度
返回max(左,右)+1
结束

Java代码实现

java 复制代码

public class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) return 0;
        int left = maxDepth(root.left);
        int right = maxDepth(root.right);
        return Math.max(left, right) + 1;
    }
}

复杂度分析

项目	分析
时间复杂度	O(n)，每个节点都被访问一次
空间复杂度	O(h)，其中 h 是树的高度（递归栈深度，最坏O(n)）

四、解法二：迭代法（BFS层序遍历）

思路：

利用 队列（Queue） 实现 层序遍历（Breadth First Search）：

从根节点开始，将其加入队列；
每次遍历一层中的所有节点；
每遍历完一层，就让深度加 1；
最后返回层数即为最大深度。

BFS遍历时序图

Result 深度计数节点队列 Result 深度计数节点队列 loop $每层节点$ 入队根节点子节点入队当前层结束，深度+1 输出最大深度

Java代码实现

java 复制代码

import java.util.*;

public 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 (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++; // 完成一层遍历深度+1
        }
        return depth;
    }
}

复杂度分析

项目	分析
时间复杂度	O(n)，每个节点入队出队一次
空间复杂度	O(n)，队列最多存满一层节点

五、解法三：DFS栈迭代法（深度优先遍历）

思路：

用 栈（Stack） 来模拟递归过程，每次入栈一个节点及其当前深度。

栈顶元素弹出时，更新最大深度；
如果有左或右节点，则入栈并深度+1；
遍历结束后，最大深度即结果。

DFS流程图

否
是
否
是
否
是
初始化栈，入栈(root, depth=1)
栈是否为空？
弹出栈顶节点
更新最大深度
是否有左孩子？
入栈(左节点, depth+1)
G
是否有右孩子？
入栈(右节点, depth+1)
J
返回最大深度

Java代码实现

java 复制代码

import java.util.*;

public class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) return 0;
        Stack<TreeNode> stack = new Stack<>();
        Stack<Integer> depthStack = new Stack<>();
        stack.push(root);
        depthStack.push(1);

        int maxDepth = 0;
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            int depth = depthStack.pop();
            maxDepth = Math.max(maxDepth, depth);
            if (node.left != null) {
                stack.push(node.left);
                depthStack.push(depth + 1);
            }
            if (node.right != null) {
                stack.push(node.right);
                depthStack.push(depth + 1);
            }
        }
        return maxDepth;
    }
}

复杂度分析

项目	分析
时间复杂度	O(n)，每个节点访问一次
空间复杂度	O(n)，栈最多存储节点路径

六、三种方法对比

解法	思路	使用结构	空间复杂度	难度	特点
递归法	分治计算左右深度	系统调用栈	O(h)	★	最简洁最直观
BFS法	按层统计节点层数	队列	O(n)	★★	一层一层统计
DFS栈法	手动模拟递归过程	栈	O(n)	★★★	控制更灵活

七、总结

最大深度 可看作树的高度问题，是树类面试必备题目之一；
递归法 语义最清晰，是最推荐的写法；
迭代法（BFS/DFS） 更偏向实战应用，可用于不允许递归的场景；
掌握这题后，可以灵活应对如求最小深度、平衡二叉树、层序遍历等类似题目的扩展。