如何k个一组反转链表

之前的文章「递归反转链表的一部分」讲了如何递归地反转一部分链表，有读者就问如何迭代地反转链表，这篇文章解决的问题也需要反转链表的函数，我们不妨就用迭代方式来解决。

本文要解决「K 个一组反转链表」，不难理解：

k个一组反转链表 - 图1

这个问题经常在面经中看到，而且 LeetCode 上难度是 Hard，它真的有那么难吗？

对于基本数据结构的算法问题其实都不难，只要结合特点一点点拆解分析，一般都没啥难点。下面我们就来拆解一下这个问题。

一、分析问题

首先，前文学习数据结构的框架思维提到过，链表是一种兼具递归和迭代性质的数据结构，认真思考一下可以发现这个问题具有递归性质。

什么叫递归性质？直接上图理解，比如说我们对这个链表调用 reverseKGroup(head, 2)，即以 2 个节点为一组反转链表：

k个一组反转链表 - 图2

如果我设法把前 2 个节点反转，那么后面的那些节点怎么处理？后面的这些节点也是一条链表，而且规模（长度）比原来这条链表小，这就叫子问题。

k个一组反转链表 - 图3

我们可以直接递归调用 reverseKGroup(cur, 2)，因为子问题和原问题的结构完全相同，这就是所谓的递归性质。

发现了递归性质，就可以得到大致的算法流程：

1、先反转以 head 开头的 k 个元素。

k个一组反转链表 - 图4

2、将第 k + 1 个元素作为 head 递归调用 reverseKGroup 函数。

k个一组反转链表 - 图5

3、将上述两个过程的结果连接起来。

k个一组反转链表 - 图6

整体思路就是这样了，最后一点值得注意的是，递归函数都有个 base case，对于这个问题是什么呢？

题目说了，如果最后的元素不足 k 个，就保持不变。这就是 base case，待会会在代码里体现。

二、代码实现

首先，我们要实现一个 reverse 函数反转一个区间之内的元素。在此之前我们再简化一下，给定链表头结点，如何反转整个链表？

  1. // 反转以 a 为头结点的链表
  2. ListNode reverse(ListNode a) {
  3.     ListNode pre, cur, nxt;
  4.     pre = null; cur = a; nxt = a;
  5.     while (cur != null) {
  6.         nxt = cur.next;
  7.         // 逐个结点反转
  8.         cur.next = pre;
  9.         // 更新指针位置
  10.         pre = cur;
  11.         cur = nxt;
  12.     }
  13.     // 返回反转后的头结点
  14.     return pre;
  15. }

k个一组反转链表 - 图7

这次使用迭代思路来实现的，借助动画理解应该很容易。

「反转以 a 为头结点的链表」其实就是「反转 a 到 null 之间的结点」，那么如果让你「反转 a 到 b 之间的结点」，你会不会？

只要更改函数签名，并把上面的代码中 null 改成 b 即可： labuladong 提供Java解法代码：

  1. /** 反转区间 [a, b) 的元素，注意是左闭右开 */
  2. ListNode reverse(ListNode a, ListNode b) {
  3.     ListNode pre, cur, nxt;
  4.     pre = null; cur = a; nxt = a;
  5.     // while 终止的条件改一下就行了
  6.     while (cur != b) {
  7.         nxt = cur.next;
  8.         cur.next = pre;
  9.         pre = cur;
  10.         cur = nxt;
  11.     }
  12.     // 返回反转后的头结点
  13.     return pre;
  14. }

renxiaoyao 提供C++解法代码：

  1. ListNode* reverse(ListNode* begin,ListNode* end) {
  2.     ListNode* newHead = nullptr;
  3.     ListNode* cur = begin;
  4.     while(cur != end) {
  5.         ListNode* next = cur->next;
  6.         cur->next = newHead;
  7.         newHead = cur;
  8.         cur = next;
  9.     }
  10.     return newHead;
  11. }

现在我们迭代实现了反转部分链表的功能，接下来就按照之前的逻辑编写 reverseKGroup 函数即可： labuladong 提供Java解法代码：

  1. ListNode reverseKGroup(ListNode head, int k) {
  2.     if (head == null) return null;
  3.     // 区间 [a, b) 包含 k 个待反转元素
  4.     ListNode a, b;
  5.     a = b = head;
  6.     for (int i = 0; i < k; i++) {
  7.         // 不足 k 个，不需要反转，base case
  8.         if (b == null) return head;
  9.         b = b.next;
  10.     }
  11.     // 反转前 k 个元素
  12.     ListNode newHead = reverse(a, b);
  13.     // 递归反转后续链表并连接起来
  14.     a.next = reverseKGroup(b, k);
  15.     return newHead;
  16. }

renxiaoyao 提供C++解法代码：

  1. class Solution {
  2. public:
  3.     ListNode* reverseKGroup(ListNode* head, int k) {
  4.         if(!head)   return head;
  5.         ListNode* begin = head;
  6.         ListNode* end = head;
  7.         for(int i = 0 ; i < k ; ++i) {
  8.             if(!end)
  9.                 return head;
  10.             end = end->next;
  11.         }
  12.         ListNode* newHead = reverse(begin,end);
  13.         begin->next = reverseKGroup(end,k);
  14.         return newHead;
  15.     }
  16. private:
  17.     ListNode* reverse(ListNode* begin,ListNode* end) {
  18.         ListNode* newHead = nullptr;
  19.         ListNode* cur = begin;
  20.         while(cur != end) {
  21.             ListNode* next = cur->next;
  22.             cur->next = newHead;
  23.             newHead = cur;
  24.             cur = next;
  25.         }
  26.         return newHead;
  27.     }
  28. };

解释一下 for 循环之后的几句代码，注意 reverse 函数是反转区间 [a, b)，所以情形是这样的：

k个一组反转链表 - 图8

递归部分就不展开了，整个函数递归完成之后就是这个结果，完全符合题意：

k个一组反转链表 - 图9

三、最后说两句

从阅读量上看，基本数据结构相关的算法文章看的人都不多，我想说这是要吃亏的。

大家喜欢看动态规划相关的问题，可能因为面试很常见，但就我个人理解，很多算法思想都是源于数据结构的。我们公众号的成名之作之一，「学习数据结构的框架思维」就提过，什么动规、回溯、分治算法，其实都是树的遍历，树这种结构它不就是个多叉链表吗？你能处理基本数据结构的问题，解决一般的算法问题应该也不会太费事。

那么如何分解问题、发现递归性质呢？这个只能多练习，也许后续可以专门写一篇文章来探讨一下，本文就到此为止吧，希望对大家有帮助！

坚持原创高质量文章，致力于把算法问题讲清楚，欢迎关注我的公众号 labuladong 获取最新文章：

labuladong

KAGAWA317 提供Python3解法代码：

  1. # 反转区间 [a, b) 的元素
  2. def reverse(a, b):
  3.     pre = None
  4.     cur = a
  5.     while cur != b:
  6.         cur.next, pre, cur = pre, cur, cur.next
  7.         return pre

KAGAWA317 提供Python3解法代码：

  1. class Solution:
  2.     def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
  3.         if not head:
  4.             return
  5.         #  区间 [a, b) 包含 k 个待反转元素
  6.         a = b = head
  7.         for _ in range(k):
  8.             # 不足 k 个，不需要反转，base case
  9.             if not b:
  10.                 return head
  11.             b = b.next
  13.         # 反转区间 [a, b) 的元素
  14.         def reverse(a, b):
  15.             pre = None
  16.             cur = a
  17.             while cur != b:
  18.                 cur.next, pre, cur = pre, cur, cur.next
  19.             return pre
  21.         #  反转前 k 个元素
  22.         newHead = reverse(a, b)
  23.         # 递归反转后续链表并连接起来
  24.         a.next = self.reverseKGroup(b, k)
  25.         return newHead