链表反转是数据结构与算法中的经典高频考点，从基础的全链表反转，到反转前 n 个节点，再到进阶的区间反转，层层递进。本文将以 LeetCode 92. 反转链表 II 为核心，从基础的「反转前 n 个节点」递归实现讲起，结合虚拟头节点神器，拆解区间反转的解题逻辑，彻底掌握链表递归反转的核心思想。
引言
链表是一种线性、离散存储的数据结构，节点之间通过指针关联，无法像数组一样随机访问，这也让链表反转成为了考察指针操作与递归思维的最佳题型。
LeetCode 92 区间反转问题，并非孤立的算法题，而是「反转前 n 个节点」的进阶应用。我们的解题思路非常清晰：先攻克基础的前 n 节点反转，再将区间反转问题拆解为基础问题的组合，化繁为简，轻松破解难题。
基础：前 n 个节点递归反转
在解决区间反转之前，我们必须先实现一个核心工具函数：反转链表的前 n 个节点，这是解题的核心基石。
1. 函数定义与核心功能
我们定义递归函数 reverseN，功能如下：
- 函数签名：ListNode* reverseN(ListNode* head, int n)
- 核心功能：反转以 head 为头节点的链表的前 n 个节点，返回反转后的新链表头节点；剩余未反转节点保持原顺序。
2. 递归实现思路拆解
递归的核心是分解子问题 + 终止条件 + 回溯调整指针，严格遵循以下逻辑：
- 终止条件：当 n == 1 时，说明已经找到待反转的最后一个节点，直接返回当前节点（新头节点）；
- 递归子问题：记录当前节点的下一个节点为 tail，递归调用 reverseN 反转 head.next 开头的 n-1 个节点；
- 回溯调整指针：将当前头节点指向 tail 的后继节点，再将 tail 指向当前头节点，完成局部反转；
- 返回结果：最终返回递归得到的新头节点。
3. 直观调用示例
我们以链表 1->2->3->4 为例，通过表格直观展示函数效果：
| 原链表结构 | 输入参数 n | 反转后链表结构 |
|---|---|---|
| 1->2->3->4 | 2 | 2->1->3->4 |
| 1->2->3->4 | 3 | 3->2->1->4 |
4. 关键代码实现（C++）与详解
// 链表节点定义（通用）
struct ListNode {
int val;
ListNode *next;
ListNode() : val(0), next(nullptr) {}
ListNode(int x) : val(x), next(nullptr) {}
ListNode(int x, ListNode *next) : val(x), next(next) {}
};
// 核心函数：反转链表前 n 个节点（递归实现）
ListNode* reverseN(ListNode* head, int n) {
// 终止条件：n=1，到达待反转的最后一个节点，直接返回
if (n == 1) {
return head;
}
// 记录当前节点的下一个节点（待反转的子链表头）
ListNode* tail = head->next;
// 递归反转：反转 head.next 的前 n-1 个节点，得到新头节点
ListNode* newHead = reverseN(head->next, n - 1);
// 指针调整：当前头节点指向 tail 的后继节点
head->next = tail->next;
// tail 指向当前头节点，完成局部反转
tail->next = head;
// 返回反转后的新头节点
return newHead;
}
代码关键点解析：
- tail 保存了当前节点的直接后继，是回溯时调整指针的核心；
- 递归会一直深入到待反转的最后一个节点，回溯时从后往前调整指针，完美实现反转；
- 未反转的节点完全不影响，保证了链表的完整性。
实战：LeetCode 92 区间反转
1. 题目问题描述
LeetCode 92. 反转链表 II：
给你单链表的头指针 head 和两个整数 m、n（1 ≤ m ≤ n ≤ 链表长度），请你反转从位置 m 到位置 n 的链表节点，返回反转后的链表。
2. 神器加持：虚拟头节点（哨兵）技巧
这是链表题中解决边界问题的万能技巧！
- 定义：创建一个额外的链表节点（值任意，如 0），让它的 next 指向原链表的头节点，这个节点就是虚拟头节点（dummy）；
- 核心作用：消除「待反转区间包含原链表头节点」的特殊情况，统一所有操作逻辑，类似哨兵节点的防护作用。
我们用 Mermaid 图直观展示虚拟头节点的结构：
graph LR
subgraph 虚拟头节点
D[dummy] --> H[head]
end
H --> N1[Node 1] --> N2[Node 2]
style D fill:#f9f,stroke:#333
图表说明：虚拟头节点独立于原链表，指针 p 只需移动 m-1 步，就能精准定位到待反转区间的前驱节点，无论 m=1 还是 m>1，逻辑完全一致。
3. 整体解题思路
将区间反转问题拆解为 3 个简单步骤，完美复用我们的 reverseN 函数：
- 定位前驱节点：通过虚拟头节点，移动指针找到第 m-1 个节点（记为 p），它是待反转区间的前一个节点；
- 计算反转长度：待反转节点数 k = n - m + 1；
- 调用工具函数 + 拼接：调用 reverseN 反转 p.next 开头的 k 个节点，将 p.next 指向反转后的新头节点，完成拼接。
4. 完整代码实现（C++）与逐行解析
// LeetCode92 区间反转主函数
ListNode* reverseBetween(ListNode* head, int m, int n) {
// 1. 创建虚拟头节点，指向原链表头
ListNode* dummy = new ListNode(0);
dummy->next = head;
// 2. 定义指针 p，初始指向虚拟头节点
ListNode* p = dummy;
// 3. 移动 m-1 步，定位到待反转区间的前驱节点
for (int i = 0; i < m - 1; i++) {
p = p->next;
}
// 4. 计算需要反转的节点个数
int k = n - m + 1;
// 5. 调用 reverseN，反转 p.next 开头的 k 个节点
p->next = reverseN(p->next, k);
// 6. 返回虚拟头节点的 next（最终链表头）
return dummy->next;
}
代码关键点解析：
- 虚拟头节点彻底规避了 m=1 时头节点变化的边界问题；
- 仅通过一次循环定位前驱节点，时间复杂度极低；
- 核心反转逻辑完全复用 reverseN，代码复用性拉满。
5. 算法复杂度分析
- 时间复杂度：O(n)，仅遍历链表一次，递归操作也是线性的；
- 空间复杂度：O(n)，递归调用会占用栈空间（若改用迭代实现 reverseN，空间可优化为 O(1)）。
原理剖析
1. 递归反转的核心原理
链表递归反转的本质是后序遍历：先递归深入到子问题的终止节点，再回溯调整指针。
对于 reverseN，我们把「反转前 n 个节点」分解为「反转前 n-1 个节点」的子问题，直到 n=1 到达终点，再逐层回溯调整指针，最终完成整体反转。
2. 虚拟头节点的底层逻辑
普通链表操作中，头节点没有前驱，当反转区间包含头节点时，需要单独写判断逻辑。虚拟头节点为原链表增加了一个「公共前驱」，让所有节点的操作逻辑完全统一，代码更简洁、更健壮。
学习建议
结合本题的学习，给大家分享算法刷题的核心方法论：
- 思维与代码双管齐下：学习算法分为学思路和写代码两个过程，缺一不可。先理解递归分解、区间拆解的思维逻辑，再动手敲代码，才能真正内化；
- 基础工具优先掌握：复杂算法题都是基础工具的组合，比如本题的 reverseN 就是核心工具，吃透基础，进阶题迎刃而解；
- 实操大于空想：不要只看题解，跟着思路逐行敲代码，调试指针操作，才能攻克链表的指针难点；
- 刻意练习边界情况：链表题的坑点都在边界（如 m=1、n=链表长度），刻意针对边界测试，提升代码健壮性。
结语
LeetCode 92 区间反转，是链表递归反转的里程碑式题目。它教会我们：复杂问题拆解为基础子问题，用工具函数简化核心逻辑，用技巧规避边界问题。
从反转前 n 个节点，到区间反转，不仅是代码的进阶，更是递归思维的升华。希望大家通过本文，彻底吃透链表反转的核心，在算法刷题的路上稳步前行！
