单链表反转：从基础到进阶的完整指南

单链表反转是数据结构与算法中的经典问题，它不仅考察对链表结构的理解，也考验编程思维和技巧。本文将带你从基础实现到高级应用，全面掌握单链表反转。

1. 理解单链表

在深入反转算法之前，我们先回顾单链表的基本结构：

class ListNode:def __init__(self, val=0, next=None):self.val = valself.next = next

单链表的特点是每个节点包含数据和指向下一个节点的指针，只能单向遍历。

2. 基础反转方法

2.1 迭代法（最常用）

核心思想：逐个改变节点指向，从前往后反转。

def reverse_list_iterative(head):prev = Nonecurrent = headwhile current:# 保存下一个节点next_temp = current.next# 反转指针current.next = prev# 移动指针prev = currentcurrent = next_tempreturn prev  # 新的头节点

执行过程可视化：

原链表: 1 → 2 → 3 → 4 → 5 → None步骤1: None ← 1  2 → 3 → 4 → 5 → None
步骤2: None ← 1 ← 2  3 → 4 → 5 → None
步骤3: None ← 1 ← 2 ← 3  4 → 5 → None
...
结果: None ← 1 ← 2 ← 3 ← 4 ← 5

2.2 递归法

核心思想：通过递归到达链表末端，然后从后往前反转。

def reverse_list_recursive(head):# 递归终止条件if not head or not head.next:return head# 递归到最后一个节点new_head = reverse_list_recursive(head.next)# 反转指针head.next.next = headhead.next = Nonereturn new_head

递归过程分析：

reverse(1)reverse(2)reverse(3)reverse(4)reverse(5) → 返回55.next = 4, 4.next = None5.next = 3, 3.next = None5.next = 2, 2.next = None
5.next = 1, 1.next = None

3. 进阶反转技巧

3.1 反转部分链表

反转链表中从位置 m 到 n 的部分：

def reverse_between(head, m, n):if not head or m == n:return headdummy = ListNode(0)dummy.next = headprev = dummy# 移动到第m-1个节点for _ in range(m - 1):prev = prev.next# 开始反转current = prev.nextfor _ in range(n - m):temp = current.nextcurrent.next = temp.nexttemp.next = prev.nextprev.next = tempreturn dummy.next

3.2 K个一组反转链表

每 k 个节点一组进行反转，不足 k 的保持原样：

def reverse_k_group(head, k):def reverse_sublist(start, end):prev, curr = None, startwhile curr != end:next_temp = curr.nextcurr.next = prevprev = currcurr = next_tempreturn prev# 检查是否有k个节点node = headfor _ in range(k):if not node:return headnode = node.next# 反转前k个节点new_head = reverse_sublist(head, node)# 递归处理剩余部分head.next = reverse_k_group(node, k)return new_head

3.3 交替反转

第一个k个节点反转，下一个k个节点保持，如此交替：

def reverse_alternate_k_nodes(head, k):if not head or k <= 1:return headcurrent = headprev = Nonereverse = Truewhile current:if reverse:# 反转k个节点section_start = currentsection_prev = Nonecount = 0# 检查是否有足够的节点temp = currentfor _ in range(k):if not temp:breaktemp = temp.next# 反转当前段while current and count < k:next_temp = current.nextcurrent.next = section_prevsection_prev = currentcurrent = next_tempcount += 1# 连接已反转部分if prev:prev.next = section_prevelse:head = section_prevsection_start.next = currentprev = section_startreverse = Falseelse:# 跳过k个节点count = 0while current and count < k:prev = currentcurrent = current.nextcount += 1reverse = Truereturn head

4. 特殊场景反转

4.1 反转链表的前N个节点

def reverse_first_n(head, n):successor = Nonedef reverse_n(node, count):nonlocal successorif count == 1:successor = node.nextreturn nodelast = reverse_n(node.next, count - 1)node.next.next = nodenode.next = successorreturn lastreturn reverse_n(head, n)

4.2 从末尾开始反转

def reverse_from_end(head, k):# 先找到总长度length = 0current = headwhile current:length += 1current = current.next# 转换为从头开始的位置m = length - k + 1return reverse_between(head, m, length)

5. 性能分析与比较

方法	时间复杂度	空间复杂度	适用场景
迭代法	O(n)	O(1)	通用，最常用
递归法	O(n)	O(n)	代码简洁，栈深度受限
部分反转	O(n)	O(1)	局部操作
K组反转	O(n)	O(n/k)	批量处理

6. 实战技巧与注意事项

6.1 边界情况处理

• 空链表
• 单节点链表
• 反转位置超出范围
• k值大于链表长度

6.2 调试技巧

def print_list(head):"""打印链表用于调试"""result = []current = headwhile current:result.append(str(current.val))current = current.nextprint(" → ".join(result) + " → None")

6.3 常见错误

1. 忘记处理头节点的更新
2. 指针丢失（在改变next前未保存）
3. 循环链表的形成
4. 边界条件处理不完整

7. 综合练习

题目：给定链表 1→2→3→4→5→6→7，要求实现：

1. 完全反转
2. 反转2-5位置
3. 每3个一组反转
4. 交替每2个节点反转

# 测试用例
def create_sample_list():nodes = [ListNode(i) for i in range(1, 8)]for i in range(len(nodes)-1):nodes[i].next = nodes[i+1]return nodes[0]# 测试各种反转方法
head = create_sample_list()
print("原链表:")
print_list(head)print("\n完全反转:")
print_list(reverse_list_iterative(create_sample_list()))print("\n反转位置2-5:")
print_list(reverse_between(create_sample_list(), 2, 5))print("\n每3个一组反转:")
print_list(reverse_k_group(create_sample_list(), 3))

总结

单链表反转是算法学习中的重要里程碑。掌握从基础到进阶的各种反转技巧，不仅能够解决链表相关问题，更能培养严谨的编程思维和指针操作能力。建议通过大量练习来熟练掌握这些技巧，并理解每种方法适用的场景。

记住：多画图理解指针变化，多写代码加深印象，这是掌握链表问题的关键！