1. 链表反转问题概述
链表反转是数据结构与算法中的经典问题，也是技术面试中的高频考点。这道题目要求我们将一个单链表的所有节点顺序完全颠倒，形成一个新的链表。比如原链表是1→2→3→4→5，反转后应该变成5→4→3→2→1。
在实际开发中，链表反转的应用场景非常广泛：
- 浏览器历史记录的回退功能
- 文本编辑器的撤销操作栈
- 消息队列的优先级反转处理
- 图算法中的邻接表操作
理解链表反转不仅能帮助我们掌握指针操作的精髓，也是学习更复杂算法（如K个一组反转链表、回文链表判断等）的重要基础。
2. 双指针法实现详解
2.1 算法核心思想
双指针法通过维护两个指针变量（pre和cur）来实现链表反转，其核心思想可以概括为"三步骤操作"：
- 保存当前节点的下一个节点（temp = cur.next）
- 反转当前节点的指向（cur.next = pre）
- 双指针同步后移（pre = cur; cur = temp）
这个过程就像是在铁轨上移动的两节车厢，每次操作都改变它们的连接方向。
2.2 完整代码实现
python复制class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
def reverseList(head: ListNode) -> ListNode:
pre = None
cur = head
while cur:
temp = cur.next # 暂存后继节点
cur.next = pre # 修改next引用指向
pre = cur # pre暂存当前节点
cur = temp # cur访问下一节点
return pre
2.3 执行过程图解
让我们以链表1→2→3→4→5为例，逐步分析反转过程：
初始状态：
pre = None, cur = 1→2→3→4→5
第一次循环：
temp = 2→3→4→5
1.next = None
pre = 1→None
cur = 2→3→4→5
第二次循环：
temp = 3→4→5
2.next = 1→None
pre = 2→1→None
cur = 3→4→5
...（中间过程省略）
最终状态：
pre = 5→4→3→2→1→None
cur = None
2.4 复杂度分析
时间复杂度：O(n)，只需遍历链表一次
空间复杂度：O(1)，只使用了常数级别的额外空间
提示：在实际面试中，建议边写代码边解释每个变量的作用，这能展现清晰的解题思路。
3. 递归法实现详解
3.1 递归思想解析
递归法的核心在于"从后向前"反转链表。假设我们已经反转了后面的部分链表，现在只需要处理当前节点和已反转部分的关系。
递归的终止条件是当前节点为空或已经是最后一个节点。递归的关键操作是将当前节点的下一个节点的next指针指向当前节点（head.next.next = head），然后断开原来的连接（head.next = None）。
3.2 完整代码实现
python复制def reverseList(head: ListNode) -> ListNode:
if not head or not head.next:
return head
new_head = reverseList(head.next)
head.next.next = head # 反转指向
head.next = None # 断开原连接
return new_head
3.3 递归调用栈分析
以链表1→2→3→4→5为例：
- 递归到最深层：节点5满足head.next为None，返回节点5
- 回到节点4：将5.next指向4，4.next置为None
- 回到节点3：将4.next指向3，3.next置为None
- 回到节点2：将3.next指向2，2.next置为None
- 回到节点1：将2.next指向1，1.next置为None
最终返回的new_head始终是节点5。
3.4 复杂度分析
时间复杂度：O(n)，需要递归n层
空间复杂度：O(n)，递归调用栈的深度
注意：当链表很长时，递归可能导致栈溢出，这是递归解法的主要限制。
4. 两种方法的对比与选择
4.1 性能对比表
| 对比维度 | 双指针法 | 递归法 |
|---|---|---|
| 时间复杂度 | O(n) | O(n) |
| 空间复杂度 | O(1) | O(n) |
| 代码简洁度 | 中等 | 简洁 |
| 适用场景 | 通用 | 短链表、教学示例 |
| 栈溢出风险 | 无 | 有 |
| 可读性 | 直观 | 需要递归思维 |
4.2 选择建议
- 面试场景：优先展示双指针法，可以讨论递归法作为补充
- 生产环境：长链表使用双指针，确保稳定性
- 学习阶段：两种方法都要掌握，理解不同思维模式
5. 常见问题与调试技巧
5.1 典型错误案例
- 指针丢失问题：
python复制# 错误写法
cur.next = pre
pre = cur
cur = cur.next # 此时cur.next已经指向pre，造成指针丢失
- 边界条件处理不当：
- 空链表输入未处理
- 单节点链表直接返回
- 忘记将原头节点的next置为None
5.2 调试技巧
- 可视化调试法：
python复制def print_list(head):
while head:
print(head.val, end="→")
head = head.next
print("None")
# 在关键位置插入打印语句
print_list(pre)
print_list(cur)
- 单元测试用例设计：
- 空链表[]
- 单节点链表[1]
- 双节点链表[1,2]
- 长链表[1,2,3,4,5]
- 含重复值链表[1,1,2,3,3]
5.3 内存管理注意事项
在C++等需要手动管理内存的语言中，特别注意：
- 不要提前释放节点内存
- 反转过程中避免内存泄漏
- 可以考虑使用智能指针
6. 扩展思考与变种问题
6.1 反转链表前N个节点
修改递归法，增加计数参数：
python复制successor = None # 后继节点
def reverseN(head: ListNode, n: int) -> ListNode:
global successor
if n == 1:
successor = head.next
return head
new_head = reverseN(head.next, n-1)
head.next.next = head
head.next = successor
return new_head
6.2 K个一组反转链表
结合双指针法和递归思想：
python复制def reverseKGroup(head: ListNode, k: int) -> ListNode:
# 先检查是否有k个节点
count = 0
curr = head
while curr and count < k:
curr = curr.next
count += 1
if count == k:
reversed_head = reverseList(head, k) # 反转前k个
head.next = reverseKGroup(curr, k) # 递归处理剩余部分
return reversed_head
return head
6.3 反转链表应用实例
- 回文链表判断：
- 找到中点
- 反转后半部分
- 比较前后两部分
- 链表相加：
- 反转两个链表
- 按位相加
- 反转结果链表
在实际编码练习中，我建议先从基础的反转实现开始，逐步挑战这些变种问题。每次成功解决一个变种，都会对链表操作有更深的理解。