leetcode-go/二叉树/39-对称二叉树.md

---
tags: ["LeetCode", "二叉树", "深度优先搜索", "广度优先搜索", "递归", "迭代", "简单"]
create time: 2026-05-17 11:00
---

# 39-对称二叉树

## 题面

给你一个二叉树的根节点 `root`，检查它是否**轴对称**。

> [!question] 💡 什么是「轴对称」？
> 一棵二叉树轴对称意味着：如果沿根节点画一条垂直中线，**左半树是右半树的镜像翻转**。
>
> > [!note] 🪞 直观理解
> > - 根节点永远对称（自己是自己的镜像）
> > - 左子树的左孩子 = 右子树的右孩子（值相等）
> > - 左子树的右孩子 = 右子树的左孩子（值相等）
> > - 上述规则**递归地**适用于所有层

**示例 1：**

```
输入：root = [1,2,2,3,4,4,3]
输出：true
      1            ← 根节点
     / \
    2   2          ← 两层对称 ✅
   / \ / \
  3  4 4  3        ← 三层对称 ✅
```

**示例 2：**

```
输入：root = [1,2,2,null,3,null,3]
输出：false
      1            ← 根节点
     / \
    2   2          ← 二层对称 ✅
     \   \
      3   3        ← 三层不对称！左边是左孩子，右边是右孩子 ❌
```

> [!warning] ⚠️ 关键陷阱
> 示例 2 看起来两棵子树的「形状和值」完全一样，但**对称比较的不是两个子树各自相同，而是它们的镜像关系**。左子树的空位对应右子树的位置，不能简单地判断"两棵子树相等"。

**约束：**

- 树中节点数目在范围 `[1, 1000]` 内
- `-100 <= Node.val <= 100`

**进阶：** 你可以运用递归和迭代两种方法解决这个问题吗？

---

## 思路

### 方法一：深度优先搜索 DFS（递归）⭐⭐

#### 核心洞察

> [!question] 🤔 思考
> 我们已经知道如何判断两棵树是否完全相等——同时遍历、逐节点比较。但「对称」不是比较两棵相同的树，而是比较两棵树是否为**镜像**。这两者有什么区别？

关键区别在于遍历顺序：

| 比较方式 | 左子树遍历 | 右子树遍历 |
|---------|----------|----------|
| **相等比较** | 先左后右 | 先左后右 |
| **镜像比较** | 先左后右 | **先右后左** |

所以判断对称的本质是：编写一个辅助函数 `isMirror(left, right)`，同时遍历两棵子树，但方向相反：

```
isMirror(left, right):
    // 两个都是 nil → 对称
    // 只有一个 nil → 不对称
    // 值不等 → 不对称
    // 值相等 → 交叉比较:
    //   isMirror(left.left, right.right) && isMirror(left.right, right.left)
```

#### 递归三要素

| 要素 | 内容 |
|------|------|
| **终止条件** | ① 双 nil → true；② 单 nil → false；③ 值不等 → false |
| **递归表达式** | `left.left` 与 `right.right` 镜像 + `left.right` 与 `right.left` 镜像 |
| **返回值** | 布尔值，表示两节点是否互为镜像 |

#### 执行流程图解

以对称树 `[] (1,2,2,3,4,4,3)` 为例，展示镜像比较的配对路径：

```mermaid
flowchart TD
    S["isMirror(2L, 2R)\n值相等(2=2)"] --> P1["交叉对1:\nisMirror(3L, 3R)\n值相等(3=3)\n✅ true"]
    S --> P2["交叉对2:\nisMirror(4L, 4R)\n值相等(4=4)\n✅ true"]
    P1 --> COMBINE["2L↔2R 两边都✅\n→ true"]
    P2 --> COMBINE
    COMBINE --> ROOT["isMirror(root.Left, root.Right)\n整棵树对称 ✅🎉"]
    
    style ROOT fill:#d4edda,stroke:#28a745,stroke-width:3px
    style COMBINE fill:#d4edda,stroke:#28a745
    style P1 fill:#cce5ff,stroke:#004085
    style P2 fill:#cce5ff,stroke:#004085
    
    linkStyle 0,1,2 stroke:#28a745,stroke-width:2px
```

再看不对称的 `[] (1,2,2,null,3,null,3)`：

```mermaid
flowchart TD
    S["isMirror(2L, 2R)\n值相等(2=2)"] --> P1["交叉对1:\nisMirror(nil, 3R)\n左侧nil右侧非nil\n→ false ❌"]
    S --> P2["交叉对2:\nisMirror(4L, nil)\n左侧非nil右侧nil\n→ false ❌"]
    P1 --> FAIL["2L↔2R 至少一边❌\n→ false"]
    P2 --> FAIL
    FAIL --> ROOT["isMirror(root)\n左子树 != 右子树镜像\n→ 整棵不对称 ❌"]
    
    style FAIL fill:#f8d7da,stroke:#721c24,stroke-width:2px
    style ROOT fill:#f8d7da,stroke:#721c24,stroke-width:3px
    style P1 fill:#fff3cd,stroke:#856404
    style P2 fill:#fff3cd,stroke:#856404
```

#### 为什么是「交叉」而不是「平行」？

> [!info] 🧠 对称 vs 相等的本质差异
>
> ```
> 判断两棵树 A 和 B 是否「相等」:
>     compare(A.left, B.left)  AND  compare(A.right, B.right)
>     ↑                          ↑
>     左 ↔ 左                     右 ↔ 右
>
> 判断两棵树 A 和 B 是否「对称/镜像」:
>     mirror(A.left,  B.right)  AND  mirror(A.right, B.left)
>     ↑                  ↑             ↑                ↑
>     A的左 ↔ B的右        A的右 ↔ B的左
>              └── 镜面反射方向 ──┘
> ```
>
> 这就是为什么「相等」用 `compare(left, left) + compare(right, right)`，而「对称」必须用 `mirror(left, right) + mirror(right, left)`——**方向交叉**是关键！

### 方法二：广度优先搜索 BFS（队列迭代）⭐

#### 核心思想

既然递归用栈隐式保存了待比较的节点对，那么 BFS 可以用显式队列来存储待比较的节点对：**每次从队列取出两个节点，比较它们是否镜像，再将它们的镜像孩子对入队。**

```
queue = [(root.left, root.right)]

while queue 非空:
    left, right = pop(queue)
    
    if both nil: continue
    if only one nil: return false
    if values differ: return false
    
    // 将镜像孩子对按交叉顺序入队
    push(queue, (left.left,  right.right))   // 外侧对
    push(queue, (left.right, right.left))    // 内侧对

return true
```

#### 执行流程图

```mermaid
flowchart LR
    A["初始: [(2L, 2R)]"] -->|"比较: 2=2 ✅"| B["入队: (3L,3R), (4L,4R)"]
    B -->|"比较: 3=3 ✅"| C["入队: (nil,nil), (nil,nil)"]
    C -->|"跳过双nil"| D["继续取 (4L,4R)"]
    D -->|"比较: 4=4 ✅"| E["入队: (nil,nil), (nil,nil)"]
    E -->|"全部完成"| F["队列为空\n返回 true ✅"]
    
    style F fill:#d4edda,stroke:#28a745,stroke-width:3px
    style B fill:#e3f2fd,stroke:#004085
    style D fill:#e3f2fd,stroke:#004085
```

### 方法三：深度优先搜索 DFS（栈迭代）⭐

除了 BFS 用队列，DFS 也可以用显式栈模拟递归过程。

> [!comparison] ⚖️ 三种写法对比
> | 维度 | DFS 递归 | BFS 队列迭代 | DFS 栈迭代 |
> |------|---------|-------------|-----------|
> | 代码简洁度 | ⭐⭐⭐ 仅需 6 行 | ⭐⭐ 需维护队列 | ⭐⭐ 需维护栈 |
> | 空间复杂度 | O(h) 递归栈 | O(n) 队列最多存一层节点对 | O(h) 栈深度 |
> | 比较顺序 | 前序（当前对→外侧→内侧） | 逐层（自顶向下） | 前序（自定义） |
> | 面试推荐度 | **首选** | 直观易懂 | 展示底层理解 |

---

## 代码提示

### 递归伪代码

```
func isMirror(left, right *TreeNode) bool:
    // 终止条件①: 两个都为空 → 对称
    if left == nil and right == nil:
        return true
    
    // 终止条件②: 只有一个为空 → 不对称
    if left == nil or right == nil:
        return false
    
    // 终止条件③: 值不等 → 不对称
    if left.Val != right.Val:
        return false
    
    // 递归: 交叉比较（外侧对外侧，内侧对内侧）
    return isMirror(left.Left, right.Right) and isMirror(left.Right, right.Left)

func isSymmetric(root *TreeNode) bool:
    return isMirror(root.Left, root.Right)
```

### BFS 迭代伪代码

```
if root == nil: return true

queue = [(root.Left, root.Right)]

while len(queue) > 0:
    left, right = pop(queue)
    
    if left == nil and right == nil: continue
    if left == nil or right == nil: return false
    if left.Val != right.Val: return false
    
    push(queue, (left.Left, right.Right))
    push(queue, (left.Right, right.Left))

return true
```

---

## 技巧

> [!tip] 🔑 「对称」和「相等」是一组好基友
> LeetCode 100. 相同的树判断两棵树是否完全相等，LeetCode 101. 对称二叉树判断两棵树是否互为镜像。两者代码结构高度相似，唯一的区别就是**参数遍历的方向**——相等是 `(左,左)+(右,右)`，对称是`(左,右)+(右,左)`。对比练习效果极佳。

> [!tip] 🔑 Go 多值赋值的优雅应用
> 虽然这道题不需要交换操作，但在类似的树问题中，Go 的多值赋值能让你避开临时变量。更重要的是，递归的两个子调用写在 `and` 两侧，Go 会在第一个结果为 false 时短路——天然优化。

> [!info] 📊 复杂度速查
> | 方法 | 时间复杂度 | 空间复杂度 |
> |------|-----------|-----------|
> | DFS 递归 | **O(n)** — 每个节点对访问一次 | **O(h)** — h 为树高，最坏 O(n)（链状），平均 O(log n)（平衡树） |
> | BFS 队列迭代 | **O(n)** — 每对节点入队出队各一次 | **O(n)** — 最坏情况下队列可能存 O(n)/2 个节点对 |
> | DFS 栈迭代 | **O(n)** | **O(h)** |

> [!warning] ⚠️ 常见错误：忘记处理双 nil 情况
> 有些人在写递归时只写了「左 nil 或右 nil 返回 false」，这会误判一对双 nil 叶子。双 nil 应该返回 true——因为它们都是空节点，自然是对称的。

> [!note] 🧩 延伸思考
> - **相同的树**（LeetCode 100）：比较思路几乎一致，只是参数方向不交叉
> - **二叉树的最大深度**（LeetCode 104）：对称树可以看作是求"左子树深度 == 右子树深度且结构镜像"
> - **N 叉树的对称性**：扩展到 N 叉树时，需要判断第 i 个孩子和第 (n-1-i) 个孩子是否互为镜像

---

## 代码

### DFS 递归法（推荐）⭐⭐

```go
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isSymmetric(root *TreeNode) bool {
	// 空树对称
	return isMirror(root, root)
}

// isMirror 判断两棵树是否互为镜像
func isMirror(left, right *TreeNode) bool {
	// 两个节点都为空 → 对称
	if left == nil && right == nil {
		return true
	}
	// 只有一个为空 → 不对称
	if left == nil || right == nil {
		return false
	}
	// 值不相等 → 不对称
	if left.Val != right.Val {
		return false
	}
	// 交叉比较：外侧对外侧，内侧对内侧
	return isMirror(left.Left, right.Right) && isMirror(left.Right, right.Left)
}
```

> [!success] ✅ 运行验证
> 这是 LeetCode 第 101 题，通过率约 59%。代码虽短，但包含了二叉树递归的经典范式——**定义函数语义 → 列出终止条件 → 写出递归表达式**。注意这里巧妙地把 `root` 作为两棵树的根同时传入 `isMirror(root, root)`，让根节点的左右子树成为首次比较的对象。

### BFS 队列迭代法（参考）⭐

```go
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isSymmetric(root *TreeNode) bool {
	if root == nil {
		return true
	}

	// 使用切片模拟队列，存储待比较的节点对
	type pair struct {
		left, right *TreeNode
	}
	queue := []pair{{root.Left, root.Right}}

	for len(queue) > 0 {
		// 出队
		pair := queue[0]
		queue = queue[1:]
		left, right := pair.left, pair.right

		// 两个都为空 → 继续下一对
		if left == nil && right == nil {
			continue
		}
		// 只有一个为空 → 不对称
		if left == nil || right == nil {
			return false
		}
		// 值不等 → 不对称
		if left.Val != right.Val {
			return false
		}

		// 将镜像孩子对按交叉顺序入队
		queue = append(queue, pair{left.Left, right.Right})   // 外侧对
		queue = append(queue, pair{left.Right, right.Left})   // 内侧对
	}

	return true
}
```

> [!note] 🐹 设计选择说明
> 这里使用了自定义 `pair` 结构体来存储节点对，相比 `[][]*TreeNode` 或扁平化两个队列的方式更直观。Go 的匿名结构体语法让这种配对变得简洁——在 Python 中直接用元组 `(left, right)`，在 Java 中可能需要自定义 Pair 类。

### DFS 栈迭代法（参考）⭐

```go
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isSymmetric(root *TreeNode) bool {
	if root == nil {
		return true
	}

	// 用切片模拟栈，存储待比较的节点对
	type pair struct {
		left, right *TreeNode
	}
	stack := []pair{{root.Left, root.Right}}

	for len(stack) > 0 {
		// 弹栈
		n := len(stack) - 1
		pair := stack[n]
		stack = stack[:n]
		left, right := pair.left, pair.right

		if left == nil && right == nil {
			continue
		}
		if left == nil || right == nil {
			return false
		}
		if left.Val != right.Val {
			return false
		}

		// 注意：栈是 LIFO，所以要逆序入栈才能保证比较顺序
		// 与递归的前序逻辑一致：先处理内侧再处理外侧
		stack = append(stack, pair{left.Right, right.Left})  // 内侧对先入
		stack = append(stack, pair{left.Left, right.Right})   // 外侧对后入
	}

	return true
}
```

> [!tip] 🐹 BFS vs DFS 迭代的关键区别
> BFS 用**队列**（FIFO）——先入队的先被弹出，实现逐层比较；DFS 迭代用**栈**（LIFO）——后入栈的先被弹出。在 DFS 迭代中，如果要模拟递归的「先处理外侧再处理内侧」的顺序，就必须把内侧对**先入栈**，这样它反而会被**后弹出**——这体现了栈的逆序特性。