wonder/leetcode-go
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a3e5991437f5f34f4fdb3a37bfcfdfb127f7a2d5
leetcode-go/二叉树/40-二叉树的直径.md
T

421 lines
13 KiB
Markdown
Raw Normal View History

vault backup: 2026-05-17 17:24:03
2026-05-17 17:24:04 +08:00
---
tags: ["LeetCode", "二叉树", "深度优先搜索", "递归", "后序遍历"]
create time: 2026-05-17 12:00
---
# 40-二叉树的直径
## 题面
给你一棵二叉树的根节点，返回该树的 **直径**。
> [!question] 💡 核心定义
> - **直径** = 树中任意两个节点之间最长路径的 **边数**
> - 这条路径可能经过也可能 **不经过** 根节点
> - 「长度」= 路径上的 **边数**（不是节点数！）
> [!warning] ⚠️ 易混淆点
> **「深度」vs「直径」**：
> - **最大深度**：从根到最远叶子节点的单向距离（一条线）
> - **直径**：任意两节点之间的双向路径（可能穿过某个中间节点）
>
> > [!tip] 🔑 关键洞察
> > 对于任意一个节点 `node`，如果有一条最长路径恰好穿过它，那么：
> > ```
> > 穿过 node 的路径长度 = node 左子树的最大深度 + node 右子树的最大深度
> > ```
> > 而整棵树的直径就是所有节点中，「穿过它的最大路径」的 **最大值**。
**示例 1：**
```
输入：root = [1,2,3,4,5]
输出：3
解释：取路径 [4→2→1→3] 或 [5→2→1→3]，共 3 条边。
1 ← 直径穿过了 1
/ \
2 3 ← 路径可以是 4→2→1→3
/ \
4 5
```
**示例 2：**
```
输入：root = [1,2]
输出：1
解释：只有 1→2 这一条边
```
**约束：**
- 树中节点数目在范围 `[1, 10^4]` 内
- `-100 <= Node.val <= 100`
---
## 思路
### 方法一：DFS 后序遍历 + 全局最大值 ⭐⭐⭐
#### 核心洞察
> [!question] 🤔 思考
>
> 第 37 题我们求过「最大深度」——它是从根出发往下走的最远距离。
> 现在要求「直径」——它可以是树上**任意两节点**之间的距离。
>
> 想象你在树上找最长路径，它会「穿过」某个节点：从上侧一棵子树上来，再从下侧另一棵子树下去。**这个「中间节点」不一定是根！**
以 `[] (1,2,3,4,5)` 为例，逐步计算每个节点的数据：
```
1 ← 左深=2, 右深=1, 穿过它的直径=3 ✅ 答案!
/ \
2 3 ← 节点3是叶子：左深=0, 右深=0, 直径贡献=0
/ \
4 5 ← 节点4,5都是叶子：深度各为0, 直径贡献各为0
```
> [!info] 📐 DFS 返回值的约定
> 在这道题的标准解法中，`dfs(node)` 的返回值代表 **以 node 为根的树的最大深度**，约定空节点返回 0，计算公式为：
> ```
> dfs(nil) = 0
> dfs(leaf) = max(0, 0) + 1 = 1
> dfs(internal) = max(dfs(left), dfs(right)) + 1
> ```
> 此时穿过当前节点的路径长度恰好等于 `leftDepth + rightDepth`（即边数），无需额外加减。验证：节点 1 的左深度 = 2、右深度 = 1，穿过它的路径 = 2+1 = 3 条边 ✅
执行流程图解：
```mermaid
flowchart TD
Post["后序遍历：先子节点，后自身"] --> L["遍历左子树，获得左深度"]
L --> R["遍历右子树，获得右深度"]
R --> C["当前节点处更新直径\n通过此节点的路径 = 左深度 + 右深度"]
C --> Ret["返回当前节点的最大深度\n给父节点使用"]
style Post fill:#fff3e0,stroke:#e65100
style C fill:#fce4ec,stroke:#c62828
style Ret fill:#e3f2fd,stroke:#1565c0
linkStyle 0,1,2 stroke-width:3px
```
具体对 `[] (1,2,3,4,5)` 每个节点的详细计算：
```mermaid
flowchart TD
N4["节点 4\n左深=0, 右深=0\n直径贡献=0\n返回 max=0"]
N5["节点 5\n左深=0, 右深=0\n直径贡献=0\n返回 max=0"]
N3["节点 3\n左深=0, 右深=0\n直径贡献=0\n返回 max=0"]
N2["节点 2\n左深=1, 右深=1\n直径贡献=1+1=2, ans=2\n返回 max=1"]
N1["节点 1\n左深=2, 右深=1\n直径贡献=2+1=3, ans=3\n返回 max=2"]
N4 & N5 --> N2
N3 --> N1
N2 --> N1
style N4 fill:#e3f2fd
style N5 fill:#e3f2fd
style N3 fill:#e3f2fd
style N2 fill:#fff3e0,stroke:#e65100
style N1 fill:#fce4ec,stroke:#c62828,stroke-width:3px
```
执行流程图解：
```mermaid
flowchart TD
Post["后序遍历：先子节点，后自身"] --> L["遍历左子树，获得左深度"]
L --> R["遍历右子树，获得右深度"]
R --> C["当前节点处更新直径\n通过此节点的路径 = 左深度 + 右深度"]
C --> Ret["返回当前节点的最大深度\n给父节点使用"]
style Post fill:#fff3e0,stroke:#e65100
style C fill:#fce4ec,stroke:#c62828
style Ret fill:#e3f2fd,stroke:#1565c0
linkStyle 0,1,2 stroke-width:3px
```
具体对 `[] (1,2,3,4,5)` 每个节点的详细计算：
```mermaid
flowchart TD
N4["节点 4\n左深=0, 右深=0\n直径贡献=0\n返回 max=0"]
N5["节点 5\n左深=0, 右深=0\n直径贡献=0\n返回 max=0"]
N3["节点 3\n左深=0, 右深=0\n直径贡献=0\n返回 max=0"]
N2["节点 2\n左深=max(4)=1, 右深=max(5)=1\n直径贡献=1+1=2, ans=2\n返回 max=1"]
N1["节点 1\n左深=max(2)=2, 右深=max(3)=1\n直径贡献=2+1=3, ans=3\n返回 max=2"]
N4 & N5 --> N2
N3 --> N1
N2 --> N1
style N4 fill:#e3f2fd
style N5 fill:#e3f2fd
style N3 fill:#e3f2fd
style N2 fill:#fff3e0,stroke:#e65100
style N1 fill:#fce4ec,stroke:#c62828,stroke-width:3px
```
#### 算法框架
```
global ans = 0
function dfs(node):
if node == nil:
return 0
// 后序：先左右子树，再当前节点
left = dfs(node.left) // 左子树的最大深度
right = dfs(node.right) // 右子树的最大深度
// 穿过当前节点的路径长度 = 左深度 + 右深度
ans = max(ans, left + right)
// 返回当前节点向上延伸的最大深度（供父节点使用）
return max(left, right) + 1
function diameterOfBinaryTree(root):
dfs(root)
return ans
```
#### 递归三要素
| 要素 | 内容 |
|------|------|
| **终止条件** | 节点为空时，返回 0 |
| **递归表达式** | `left = dfs(node.left)`, `right = dfs(node.right)` |
| **副作用** | 在每个节点更新全局变量 `ans = max(ans, left + right)` |
| **返回值** | 以当前节点为根的树的最大深度 `max(left, right) + 1` |
#### 为什么用后序遍历？
> [!info] 🧠 自底向上的必然选择
> 要计算「穿过节点 A 的直径」，必须先知道 A 的左右子树各自有多深。这意味着**子节点的处理必须在父节点之前完成**——正是后序遍历（左 → 右 → 根）的执行顺序。
---
## 代码提示
### DFS 伪代码
```
// 全局变量：记录最大直径
ans = 0
func dfs(node):
if node == nil:
return 0
left = dfs(node.Left) // 左子树深度（边数视角下的"层数"）
right = dfs(node.Right) // 右子树深度
ans = max(ans, left + right) // 更新直径
return max(left, right) + 1 // 返回当前节点深度给父节点
func diameterOfBinaryTree(root):
dfs(root)
return ans
```
### Go 语言实现要点
> [!note] 🐹 Go 中没有真正的"全局变量"最佳实践
> 在这道题中，有几种方式传递和修改 `ans`：
| 方案 | 写法 | 推荐度 |
|------|------|--------|
| **指针传参** | `func dfs(node *TreeNode, ans *int)` | ⭐⭐⭐ 函数式风格，无副作用 |
| **闭包捕获** | 在 `diameterOfBinaryTree` 内定义 `var ans int` 然后用嵌套函数访问 | ⭐⭐⭐ 简洁直观 |
| **返回值携带** | `func dfs(...) (depth, dia int)` | ⭐⭐ 稍显繁琐 |
推荐使用 **闭包捕获** 的方式，既干净又自然。
---
## 技巧
> [!tip] 🔑 直径 vs 深度的关系速记
> - **深度**：从某节点向下到最远叶子的「单向」路径长度
> - **直径**：从某节点向「左下 + 右下」延伸的两条分支合并后的总长
> - **公式**：`diameter(node) = leftDepth + rightDepth`
> - 整棵树的直径是所有节点中这个值的 **最大值**
> [!tip] 🔑 为什么可以用一次 DFS 搞定？
> 很多人第一反应是「枚举每对节点 → BFS/DFS 求距离 → 取最大值」，这样是 O(n²)。但其实：
> - 对于每个节点，穿过它的直径 = 左深度 + 右深度
> - 左深度和右深度可以通过一次后序遍历全部算出
> - 同时更新全局最大值，只需 **O(n)** 时间
> [!warning] ⚠️ 常见错误
> 1. **误把直径当作最大深度 × 2**：只有满二叉树/完美二叉树时才碰巧相等
> 2. **忘记处理单边树的情况**：比如左斜树，右深度恒为 0，直径 = 最大深度
> 3. **把直径当成经过根的路径**：直径可能经过任何节点，不只是根
> [!info] 📊 复杂度速查
> | 维度 | 结果 |
> |------|------|
> | 时间复杂度 | **O(n)** — 每个节点恰好访问一次 |
> | 空间复杂度 | **O(h)** — h 为树高，递归栈深度；最坏 O(n)（链状），平均 O(log n)（平衡树） |
> [!connection] 🔗 与相关题目的联系
> - **[37-二叉树的最大深度](./37-二叉树的最大深度.md)**：直径问题的基础，深度是计算直径的子组件
> - **[543. Diameter of Binary Tree](https://leetcode.com/problems/diameter-of-binary-tree/)**：原题（英文）
> 两者本质相同，只是表述不同
> - **最长路径问题**：这是一般图论中「树的直径」的特例。对无权树可通过两次 BFS 求解，但二叉树场景下 DFS 更直接
> [!exercise] 💪 变体练习
> 1. 如果路径长度定义为节点数而非边数，如何修改代码？→ 只需将 `left + right` 改为 `left + right + 1`（当前节点也计入）
> 2. 如果树中有负权边（加权二叉树），还能用此方法吗？→ 不能，需要换成分治或树形 DP
> 3. N 叉树的直径如何求解？→ 取最大的两个子节点深度之和作为直径贡献
---
## 代码
### DFS + 闭包（推荐）⭐⭐⭐
```go
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func diameterOfBinaryTree(root *TreeNode) int {
// ans 通过闭包捕获，DFS 过程中不断刷新最大值
ans := 0
// dfs 返回以 node 为根的树的最大深度（层数）
var dfs func(*TreeNode) int
dfs = func(node *TreeNode) int {
if node == nil {
return 0
}
// 后序遍历：先获取左右子树的深度
left := dfs(node.Left) // 左子树的最大深度
right := dfs(node.Right) // 右子树的最大深度
// 穿过当前节点的路径 = 左深度 + 右深度
// 这就是以当前节点为"最高点"的最长路径
dia := left + right
if dia > ans {
ans = dia
}
// 返回当前节点向上传递的最大深度
// 供父节点计算穿过它的直径时使用
if left > right {
return left + 1
}
return right + 1
}
dfs(root)
return ans
}
```
> [!success] ✅ 运行验证
> 这是 LeetCode 第 543 题，通过率约 62%。核心只有一句话：**在每个节点处，用左深度+右深度更新答案，同时返回 max(左,右)+1**。面试时可先用一句话概括思路，再展开细节。
### DFS + 指针传参（函数式风格）⭐⭐
```go
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func diameterOfBinaryTree(root *TreeNode) int {
if root == nil {
return 0
}
maxDia := 0
// dfs 返回深度，通过指针修改 maxDia
var dfs func(*TreeNode) int
dfs = func(node *TreeNode) int {
if node == nil {
return 0
}
left := dfs(node.Left)
right := dfs(node.Right)
*maxDia = left + right
if d := left + right; d > *maxDia {
*maxDia = d
}
if left > right {
return left + 1
}
return right + 1
}
dfs(root)
return *maxDia
}
```
> [!note] 🐹 两种写法的选择
> 闭包方式中 `ans` 是外层函数的局部变量，内层 `dfs` 直接读取和赋值，无需额外类型声明。指针方式更"显式"地表明 `dfs` 会修改外部状态，在团队协作中可读性更强。个人偏好闭包——Go 的闭包在语法上是原生支持的，不需要像 Java/C++ 那样用 `AtomicInteger` 或引用包装类。
### 对比：错误思路（仅考虑经过根的直径）❌
```go
// ❌ 错误示范：这样做只能得到"经过根节点的直径"
func wrongApproach(root *TreeNode) int {
if root == nil {
return 0
}
// 只计算了穿过根节点的路径！
// 如果最长路径不经过根，就会返回错误结果
left := maxDepth(root.Left)
right := maxDepth(root.Right)
return left + right
}
func maxDepth(node *TreeNode) int {
if node == nil {
return 0
}
l, r := maxDepth(node.Left), maxDepth(node.Right)
if l > r {
return l + 1
}
return r + 1
}
```
> [!failure] ❌ 为什么不正确？
> 上面的代码只考虑了穿过根节点的直径，但对于 `[] (1,2,null,3,4)`：
>
> ```
> 1
> /
> 2
> / \
> 3 4
> ```
>
> 经过根的直径 = 1（左）+ 0（右）= 1
> 但正确答案是经过节点 2 的路径 3→2→4，长度为 **2**
>
> **必须用 DFS 在后序遍历过程中逐个节点尝试，才能覆盖所有可能！**
Reference in New Issue Copy Permalink