1. 链表反转的进阶玩法：k个一组到底难在哪
链表反转是算法入门的第一道坎，单链表整体反转几乎每个人都能写出迭代或递归版本。但把这个问题稍微拧一下——不是整体反转，而是每k个节点为一组进行局部反转——难度立刻上了一个台阶。我第一次在面试里碰到这道题的时候，写完代码自己跑测试用例，发现最后一组不足k个节点时处理逻辑完全写反了，边界条件直接崩盘。
这道题的核心价值在于：它同时考察了你对链表指针操作的熟练度、对递归与迭代两种思维模式的切换能力，以及对边界条件的敏感程度。很多人刷题刷到这道题，看题解觉得懂了，关掉编辑器自己写，指针指来指去就乱了。这不是智力问题，是没有建立起一套可复用的思维框架。
这篇文章要聊的，就是怎么用一套清晰的框架把这道题彻底吃透。不管你是刚开始刷算法的新手，还是已经刷了几百道题但碰到链表局部反转仍然心里发虚的老手，下面这套拆解方式都能让你重新理解这道题的本质。我会从思路设计、指针操作细节、递归与迭代的取舍、边界条件处理、调试技巧几个维度展开，把每一个容易踩坑的地方都摊开来讲。
提示：本文所有代码基于Python实现，但思路框架适用于任何语言。如果你用Java或C++，指针操作的本质完全一致，只是语法表达不同。
2. 问题拆解与整体思路设计
2.1 题目到底要求什么
先把问题定义清楚。给定一个单链表的头节点head，再给定一个正整数k，要求把链表每k个节点分为一组，对每一组内部进行反转。如果最后剩余的节点不足k个，则保持原有顺序不变。
举个例子：链表是 1→2→3→4→5，k=2。分组后是 [1,2] [3,4] [5]。前两组各两个节点，反转后变成 [2,1] [4,3]，最后一组只有一个节点不足k个，保持原样。最终结果是 2→1→4→3→5。
再比如 k=3，同样的链表 1→2→3→4→5。分组后是 [1,2,3] [4,5]。第一组反转变成 [3,2,1]，第二组不足3个节点保持原样。最终结果是 3→2→1→4→5。
看起来不复杂对吧？但真正写起来，问题一个接一个冒出来：怎么判断当前组够不够k个节点？反转完一组之后怎么接到上一组的尾部？怎么记录下一组的起点？递归的终止条件是什么？这些问题如果没有提前想清楚，代码写到一半就会卡住。
2.2 为什么选择递归框架
解决这道题有两种主流思路：纯迭代和递归。我个人的建议是，先把递归版本写明白，再用迭代版本做优化。原因很简单——递归能把“分组反转”这个问题的子结构暴露得非常清晰。
你想想，整个链表每k个一组反转，反转完第一组之后，剩下的部分是不是一个完全相同的子问题？剩下的链表同样要每k个一组反转。这就是递归结构的天然体现。用递归写出来的代码，逻辑层次分明，一眼就能看出在干什么。
递归的核心思路是这样的：先找到第k个节点，如果不够k个就直接返回当前头节点（不需要反转）。如果够k个，就把前k个节点反转，然后让反转后的尾节点（也就是原来的头节点）的next指向剩余部分递归处理的结果。最后返回反转后的新头节点（也就是原来的第k个节点）。
这个描述读起来可能还有点抽象，别急，后面我会一步步拆开。
2.3 递归与迭代的取舍分析
递归的优点是代码简洁、逻辑清晰，缺点是空间复杂度是O(n/k)，因为递归调用栈的深度取决于有多少组。当链表很长、k很小的时候，递归深度会很大，在Python里可能触发递归深度限制。
迭代的优点是空间复杂度O(1)，不需要额外的调用栈空间。缺点是代码相对复杂一些，需要自己维护多个指针变量，容易写错。
那实际中怎么选？如果是面试场景，我建议先写递归版本，因为写起来快、不容易出错，面试官也能快速理解你的思路。如果面试官追问“能不能优化空间复杂度”，再改成迭代版本。如果是工程场景，链表长度可能很大，那就直接用迭代版本，避免栈溢出的风险。
| 对比维度 | 递归方案 | 迭代方案 |
|---|---|---|
| 时间复杂度 | O(n) | O(n) |
| 空间复杂度 | O(n/k) | O(1) |
| 代码简洁度 | 高 | 中 |
| 调试难度 | 低 | 中高 |
| 适用场景 | 面试、短链表 | 工程、长链表 |
3. 核心细节解析与指针操作要点
3.1 单链表反转的基本功
在解决k个一组反转之前，必须先确保单链表整体反转写得滚瓜烂熟。因为k个一组反转本质上就是在局部反复执行单链表反转，然后把各段拼接起来。
单链表反转的迭代写法核心就三行代码的逻辑：用pre记录前一个节点，cur记录当前节点，每次循环先把cur.next暂存到nxt，然后让cur.next指向pre，接着pre和cur分别往后移动。循环结束时pre就是新的头节点。
def reverse_list(head): pre = None cur = head while cur: nxt = cur.next cur.next = pre pre = cur cur = nxt return pre这段代码看起来简单，但有一个容易忽略的点：反转之后，原来的头节点变成了尾节点，它的next指向None。这个特性在k个一组反转里非常关键，因为我们需要把反转后的尾节点接到下一组去。
3.2 如何判断是否够k个节点
这是整道题的第一个关键决策点。在反转每一组之前，必须先确认从当前节点开始是否有k个节点。如果没有，直接返回当前节点，不做任何反转。
判断的方法很简单：从当前节点开始往后走k步，如果中途遇到None，说明不够k个。这里有个细节——走k步的过程中不要修改任何指针，只是单纯地“探路”。
def has_k_nodes(head, k): count = 0 cur = head while cur and count < k: cur = cur.next count += 1 return count == k这个探路操作用了O(k)的时间，看起来好像增加了复杂度，但实际上总时间复杂度仍然是O(n)，因为每个节点最多被探路经过一次（每组探路k个节点，总共n/k组，合计n次）。
注意：探路的时候不要用for循环加range(k)，因为链表可能在中途就结束了，用while循环配合计数器更安全。
3.3 反转一组后如何拼接
这是整道题最容易出错的地方。反转完一组之后，你需要做两件事：第一，把反转后的尾节点（原来的头节点）指向下一组递归处理的结果；第二，返回反转后的新头节点（原来的第k个节点）。
假设当前组的头节点是head，反转前k个节点之后，新的头节点变成了原来的第k个节点。原来的head变成了这一组的尾节点。所以拼接逻辑是：原来的head.next = 递归处理剩余链表的结果。
这里有个常见的错误：很多人在反转之前没有保存第k个节点的next指针，导致反转之后找不到下一组的起点了。正确的做法是在反转之前，先记录第k+1个节点的位置，或者用递归的方式让递归函数自己处理。
3.4 递归终止条件的确定
递归终止条件其实有两个层面。第一个层面是：如果当前节点是None，直接返回None。第二个层面是：如果从当前节点开始不足k个节点，直接返回当前节点，不反转。
这两个条件缺一不可。第一个条件处理的是链表已经走到尽头的情况，第二个条件处理的是最后一组不足k个节点的情况。很多人只写了第一个条件，忘了第二个，结果最后一组不足k个节点的时候代码就出问题了。
def reverse_k_group(head, k): # 检查是否有k个节点 cur = head count = 0 while cur and count < k: cur = cur.next count += 1 if count < k: return head # 反转前k个节点 pre = None cur = head for _ in range(k): nxt = cur.next cur.next = pre pre = cur cur = nxt # 拼接：原来的head现在是尾节点，指向递归结果 head.next = reverse_k_group(cur, k) # 返回新的头节点 return pre这段代码就是递归版本的核心实现。看起来不长，但每一行都有讲究。下面我逐行拆解一下。
4. 完整实操过程与代码实现
4.1 递归版本逐行拆解
先把完整的递归代码放上来，然后逐段分析。
class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next def reverse_k_group(head, k): # 第一步：探路，检查从head开始是否有k个节点 cur = head count = 0 while cur and count < k: cur = cur.next count += 1 # 第二步：如果不足k个，直接返回head，不反转 if count < k: return head # 第三步：反转前k个节点 pre = None cur = head for _ in range(k): nxt = cur.next cur.next = pre pre = cur cur = nxt # 第四步：递归处理剩余部分，并拼接 head.next = reverse_k_group(cur, k) # 第五步：返回反转后的新头节点 return pre第一步的探路操作，我用了一个while循环从head往后走k步。注意这里的cur变量在探路结束后指向的是第k+1个节点（如果存在的话），这个位置恰好是下一组的起点。但我在第三步反转的时候重新用了cur变量，所以探路的结果没有直接用到。这是可以的，因为第三步反转结束后，cur自然就指向了第k+1个节点。
第二步的判断很关键。如果count < k，说明从head开始不足k个节点，直接返回head。注意这里返回的是head本身，不是None，因为题目要求不足k个节点时保持原有顺序。
第三步是标准的链表反转，反转范围严格限制在前k个节点。for循环执行k次，每次把cur的next指针反转。循环结束后，pre指向原来的第k个节点（新的头节点），cur指向第k+1个节点（下一组的起点）。
第四步是递归调用的关键。head现在变成了反转后的尾节点，让它的next指向递归处理剩余链表的结果。这里传入的cur就是第k+1个节点，也就是下一组的起点。
第五步返回pre，也就是反转后的新头节点。
4.2 迭代版本实现与对比
递归版本写完之后，迭代版本其实就是在递归的基础上把调用栈手动展开。核心思路是：用一个dummy节点作为整个链表的哨兵，用group_pre记录上一组的尾节点，每次处理一组，处理完之后把group_pre指向反转后的新头节点。
def reverse_k_group_iterative(head, k): dummy = ListNode(0) dummy.next = head group_pre = dummy while True: # 探路：检查从group_pre.next开始是否有k个节点 cur = group_pre.next count = 0 while cur and count < k: cur = cur.next count += 1 if count < k: break # 反转这一组 group_head = group_pre.next pre = None cur = group_head for _ in range(k): nxt = cur.next cur.next = pre pre = cur cur = nxt # 拼接 group_pre.next = pre group_head.next = cur group_pre = group_head return dummy.next迭代版本比递归版本多了几个变量，但逻辑是一一对应的。dummy节点简化了第一组的处理，因为第一组没有“上一组的尾节点”，用dummy可以统一处理。group_pre始终指向上一组的尾节点，group_head指向当前组的头节点。反转完成后，group_pre.next指向新的头节点pre，group_head.next指向下一组的起点cur，然后更新group_pre为group_head，准备处理下一组。
两种版本的时间复杂度都是O(n)，递归版本的空间复杂度是O(n/k)，迭代版本是O(1)。实际跑起来，迭代版本在长链表上的性能优势很明显。
4.3 测试用例设计与验证
写完代码不测试等于没写。这道题的测试用例需要覆盖以下几种情况：
| 测试场景 | 输入 | 期望输出 | 验证重点 |
|---|---|---|---|
| 正常分组 | 1→2→3→4→5, k=2 | 2→1→4→3→5 | 基本功能 |
| 恰好整除 | 1→2→3→4, k=2 | 2→1→4→3 | 最后一组刚好k个 |
| 不足一组 | 1→2→3, k=5 | 1→2→3 | 不足k个不反转 |
| 单节点 | 1, k=1 | 1 | 边界情况 |
| 空链表 | None, k=2 | None | 空输入 |
| k=1 | 1→2→3, k=1 | 1→2→3 | k=1不改变 |
| 两节点k=2 | 1→2, k=2 | 2→1 | 最小反转单元 |
我建议在本地测试的时候，写一个辅助函数把链表转成列表，这样比较结果更直观。
def to_list(head): result = [] while head: result.append(head.val) head = head.next return result def build_list(vals): dummy = ListNode(0) cur = dummy for v in vals: cur.next = ListNode(v) cur = cur.next return dummy.next # 测试 assert to_list(reverse_k_group(build_list([1,2,3,4,5]), 2)) == [2,1,4,3,5] assert to_list(reverse_k_group(build_list([1,2,3,4]), 2)) == [2,1,4,3] assert to_list(reverse_k_group(build_list([1,2,3]), 5)) == [1,2,3] assert to_list(reverse_k_group(build_list([1]), 1)) == [1] assert to_list(reverse_k_group(build_list([]), 2)) == []提示：测试的时候一定要覆盖“不足k个节点”的情况，这是最容易出bug的地方。我见过很多人代码逻辑都对，就是最后一组处理错了。
5. 常见问题与排查技巧实录
5.1 指针丢失与循环引用
链表题最怕的就是指针指错，导致链表断裂或者形成环。在k个一组反转里，最常见的指针问题有两个。
第一个是反转前没有保存下一组的起点。如果你在反转前k个节点的时候，没有提前记录第k+1个节点的位置，反转完之后你就找不到后面的链表了。解决办法是在反转之前用变量nxt_group = cur（探路结束后的cur）保存下一组起点，或者像递归版本那样，反转结束后cur自然就指向了下一组起点。
第二个是拼接的时候指错了方向。反转后的尾节点应该指向下一组的起点，而不是指向自己或者指向None。如果你发现输出结果少了几个节点，大概率是拼接的时候指针指错了。
排查方法：在关键步骤后面打印链表状态。比如每处理完一组，就把当前链表转成列表打印出来，看看是否符合预期。
def reverse_k_group_debug(head, k): dummy = ListNode(0) dummy.next = head group_pre = dummy group_num = 0 while True: cur = group_pre.next count = 0 while cur and count < k: cur = cur.next count += 1 if count < k: break group_head = group_pre.next pre = None cur = group_head for _ in range(k): nxt = cur.next cur.next = pre pre = cur cur = nxt group_pre.next = pre group_head.next = cur group_pre = group_head group_num += 1 print(f"第{group_num}组处理完毕: {to_list(dummy.next)}") return dummy.next5.2 递归深度超限的处理
Python默认的递归深度限制是1000。如果你的链表有10000个节点，k=1，那么递归深度就是10000，直接报RecursionError。这个问题在面试中一般不会遇到（面试的测试用例通常很短），但在实际工程中很常见。
解决办法有两个：一是改用迭代版本，彻底避免递归调用栈；二是手动调大递归深度限制，但这只是权宜之计，不推荐在生产环境使用。
import sys sys.setrecursionlimit(100000)如果你在面试中被问到“递归深度太深怎么办”，直接回答“改用迭代版本，用dummy节点和group_pre指针手动维护分组关系”，这个回答基本满分。
5.3 常见错误速查表
| 错误现象 | 可能原因 | 排查方法 | 修复方案 |
|---|---|---|---|
| 最后一组被反转了 | 终止条件只检查了None，没检查剩余节点数 | 打印最后一组的节点数 | 增加count < k的判断 |
| 输出少了几个节点 | 拼接时指针指错，链表断裂 | 每步打印链表 | 检查head.next的指向 |
| 死循环 | 链表形成了环 | 用快慢指针检测环 | 检查反转范围是否超出k个 |
| 第一组处理错误 | 没有用dummy节点 | 单独打印第一组结果 | 引入dummy哨兵节点 |
| k=1时结果不变但代码报错 | 反转逻辑对k=1不兼容 | 单独测试k=1 | 确保for循环执行1次也正确 |
5.4 面试中的高频追问
面试官在看完你的解法之后，通常会追问几个问题。提前准备好这些问题的答案，能让你在面试中更从容。
第一个追问：“能不能不用递归？”答案就是改成迭代版本，用dummy节点加group_pre指针。
第二个追问：“空间复杂度能不能优化到O(1)？”答案同样是迭代版本，递归版本的空间复杂度是O(n/k)，迭代版本是O(1)。
第三个追问：“如果k不是固定的，而是每次动态变化呢？”这个问题就变成了变体题，思路是每次先确定当前组的长度，然后再反转。核心框架不变，只是分组逻辑需要调整。
第四个追问：“如果要求从尾部开始每k个一组反转呢？”这个变体需要先找到链表的长度，确定最后一组的位置，然后从后往前处理。或者先整体反转，再每k个一组反转，最后再整体反转一次。思路转换一下就能复用现有代码。
6. 从这道题延伸出的链表思维框架
6.1 链表题的通用解题套路
刷了这么多链表题，我总结出一个通用套路：画图 → 定指针 → 处理边界 → 写代码 → 测试。这五步看起来简单，但很多人跳过前两步直接写代码，结果就是反复调试、反复出错。
画图是把链表的节点和指针画在纸上，标清楚每一步操作之后指针的指向。定指针是确定需要几个辅助指针变量，每个变量的含义是什么。处理边界是把空链表、单节点、不足k个节点这些情况提前想清楚。写代码是把前面的思考翻译成代码。测试是用各种边界用例验证。
这个套路不仅适用于k个一组反转，也适用于几乎所有链表操作题，包括合并有序链表、删除倒数第n个节点、判断是否有环、找中间节点等等。
6.2 递归思维在链表题中的应用
递归在链表题里出现的频率非常高。链表本身就是一种递归结构——一个链表要么是空的，要么是一个节点加上一个子链表。所以很多链表操作天然适合用递归来表达。
用递归解链表题的关键是找到“子问题”和“当前层要做什么”。在k个一组反转里，子问题是“剩余链表每k个一组反转”，当前层要做的是“反转前k个节点并拼接”。把这两个问题分开想，递归代码就很容易写出来。
但递归不是万能的。当递归深度可能很大的时候，迭代是更安全的选择。而且递归代码虽然简洁，但调试起来不如迭代直观。我的建议是：面试的时候先写递归，展示你的思维清晰度；工程中优先用迭代，保证代码的健壮性。
6.3 实际工程中的链表操作注意事项
在实际工程中操作链表，有几个坑是必须注意的。
第一，永远要考虑空指针。链表的next指针随时可能是None，任何访问next.val的操作之前都必须确认当前节点不是None。
第二，操作链表之前先想清楚是否需要修改原链表。有些场景下需要保留原链表不变，那就得先拷贝一份再操作。
第三，多线程环境下操作链表需要加锁。链表的指针操作不是原子性的，并发修改会导致数据结构损坏。
第四，长链表的递归操作要小心栈溢出。Python的递归深度限制是1000，超过这个深度就会报错。工程中处理长链表一律用迭代。
第五，调试链表问题的时候，打印链表是最有效的排查手段。写一个to_list辅助函数，在关键步骤打印链表状态，比单步调试快得多。
提示：如果你在工程代码里需要频繁操作链表，建议封装一个LinkedList类，把常用的操作（插入、删除、反转、查找）都封装成方法，避免在业务代码里直接操作指针。
6.4 刷题之外的算法能力提升建议
刷题不是为了背答案，而是为了建立思维框架。k个一组反转这道题，如果你只是记住了代码，下次换个变体你照样不会。但如果你理解了“分组→局部反转→拼接”这个框架，那么不管k是多少、不管是从头开始还是从尾开始、不管是反转还是其他操作，你都能快速找到思路。
我的建议是，每刷完一道题，问自己三个问题：这道题的核心框架是什么？这个框架还能解决哪些类似问题？如果题目条件变一下，框架还能不能用？这三个问题想清楚了，一道题顶十道题。
另外，链表题一定要多画图。人的大脑不擅长在脑子里模拟指针操作，画在纸上就一目了然。我见过太多人盯着屏幕硬想，想了半小时想不出来，拿张纸画了五分钟就明白了。
7. 个人实操体会与踩坑记录
我第一次写这道题的时候，用的是纯递归版本，代码写了不到20行，看起来挺优雅。结果一跑测试，最后一组不足k个节点的时候直接报错。原因是我在递归函数开头只检查了head是否为None，忘了检查剩余节点数是否够k个。这个bug花了我将近半小时才定位到，因为递归的调用栈太深，打印日志都不方便。
后来我改用迭代版本重写了一遍，虽然代码长了点，但每一步的指针变化都看得见，调试起来快多了。从那以后，我在工程代码里处理链表一律用迭代，递归只在面试的时候用。
还有一个坑是k=1的情况。k=1的时候，每组只有一个节点，反转等于不反转。但如果你在反转逻辑里写了for _ in range(k)，k=1的时候循环执行一次，cur.next指向pre（None），结果就把链表切断了。这个bug很隐蔽，因为k=1的测试用例很多人不会去测。解决办法是在函数开头加一个判断：如果k==1，直接返回head。
最后一个体会是，这道题虽然看起来是算法题，但它训练的是一种“分段处理”的思维方式。把一个大问题拆成若干个相同的小问题，逐个解决，然后拼接结果。这种思维方式在处理批量数据、分页逻辑、流式处理等工程场景中同样适用。所以刷这道题的价值，远不止于应付面试。
