K个一组翻转链表最易懂的递归与迭代解法

ZBH4444

已于 2023-03-29 19:08:48 修改

阅读量200

点赞数

分类专栏：算法文章标签：链表数据结构 leetcode

于 2022-07-07 16:15:20 首次发布

本文链接：https://blog.csdn.net/weixin_43954951/article/details/125659533

版权

算法专栏收录该内容

14 篇文章 0 订阅

订阅专栏

题目描述

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。
k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例1
示例1

输入：head = [1, 2, 3, 4, 5], k = 2
输出：[2, 1, 4, 3, 5]

示例2
示例2

输入：head = [1, 2, 3, 4, 5], k = 3
输出：[3, 2, 1, 4, 5]

该题目是 LeetCode 上的第 25 题，难度为困难。
LeetCode 25. K 个一组翻转链表

解决思路

工具函数：反转链表

这个题目是 K 个一组反转链表，这就让人很自然地联想到另一道更基础的题目反转链表（Leetcode 中的第206题，是一个简单题目）。
如果能把题目反转链表的答案当作一个工具函数，用于这道题目当中，会不会可以大大简化这个题目的解法呢？

题目反转链表的解法有很多种，用哪一种都可以，这里使用一种迭代的方法，Java 代码实现如下：

/**
 * 反转链表，并返回新的头节点
 */
public ListNode reverseList(ListNode head) {
    ListNode preNode = null, nextNode;  // head指针的前一个节点和后一个节点
    while (head != null) {
        nextNode = head.next;
        head.next = preNode;  // 把 前指针 和 中指针 这一对节点反转

		// 各个指针依次后移一位
        preNode = head;
        head = nextNode;
    }
    return preNode;
}

递归的解法

总体思路

有了反转链表的函数reverseList()，该如何将其使用到本题目中呢？

用所有递归函数的思考方式： 假设已经有了递归函数，先考虑如何使用，再完善终止条件。

题目要求实现一个函数public ListNode reverseKGroup(ListNode head, int k)，该函数将输入的链表 K 个一组反转并返回新的头节点。

我们假设我们递归地实现题目要求的函数，并且已经完成了它。

于是使用函数reverseList()和函数reverseKGroup()，我们就可以解决这个问题了：

我们只需要从前往后数 K 个节点，用reverseList()反转它们。
然后把后面的所有节点扔给reverseKGroup()处理，并得到后面这些节点处理过后的“头节点”。
最后把反转了的前 K 个节点和后面那些处理好了的节点连在一起，搞定！

详细步骤

（1）首先我们进行第一步，从前往后数 K 个节点。

ListNode tail = head;  // 用于指向当前 k 个节点的最后一个
int count = k;
// 找到这 k 个节点的最后一个
while (count > 1 && tail != null) {
    tail = tail.next;
    count--;
}

题目要求如果最后一组节点不足 K 个，则不反转它们。
在上述代码中，只有当这一组不足 K 个节点时，tail指针才会指到null，因此在后面可以据此判断是否需要反转。

（2）然后，我们判断tail是否为null。
如果是，说明这一组不足 K 个，不用反转，直接返回head指针即可；如果不是，则需要进行反转，并递归处理后续节点，最后连接反转的 K 个节点和处理好了的后续节点。

if (tail != null) {
    // 递归处理后面的节点
    ListNode nextHead = reverseKGroup(tail.next, k);

    //反转这 k 个节点
    tail.next = null;
    ListNode newHead = reverseList(head);

    // 连接反转了的这 k 个节点和后面的处理好的节点
    head.next = nextHead;
    return newHead;
} else return head;  // 不足 k 个，不反转

事实上，先反转 K 个节点，还是先处理后面的节点，都是可以的，二者并不一定要有严格的先后顺序。
但是在上述代码中，我们先递归处理后面的节点，后反转当前这组中的 K 个节点。
这是因为我们在调用reverseList()函数反转从head到tail的链表时，需要让tail的next指针指向null（相当于把这 K 个节点组成的子链表从整个链表中“剪”出来），否则会使得reverseList()函数无法正确地在tail处终止循环。
然而reverseKGroup()函数又需要用tail.next作为参数，指向后面所有节点的“头节点”。
所以只能让reverseKGroup()函数先用tail.next，然后再把它指向null好让reverseList()函数可以正确运行。

（3）最后，对于递归的终止条件，显然有两种情况：

最后一组有节点，但是少于 K 个，那么这就是上述代码中else的情况，无需反转，直接返回head指针即可。
最后一组没有节点，那么应该返回null，而此时传入的head即为null，所以仍然可以返回head指针。

综上两种情况，当最后一组有 $[0, k)$ 个节点时，返回head指针即可正确地终止递归，前面的代码已经满足了这一条件。

递归代码实现

完整的 Java 代码实现如下所示（时间复杂度为 $O (n)$ ，空间复杂度为 $O (n)$ ）：

public ListNode reverseKGroup(ListNode head, int k) {
    ListNode tail = head;  // 用于指向当前 k 个节点的最后一个
    int count = k;
    // 找到这 k 个节点的最后一个
    while (count > 1 && tail != null) {
        tail = tail.next;
        count--;
    }

    if (tail != null) {
        // 递归处理后面的节点
        ListNode nextHead = reverseKGroup(tail.next, k);

        //反转这 k 个节点
        tail.next = null;
        ListNode newHead = reverseList(head);

        // 连接反转了的这 k 个节点和后面的处理好的节点
        head.next = nextHead;
        return newHead;
    } else return head;  // 不足 k 个，不反转
}

/**
 * 反转链表，并返回新的头节点
 */
public ListNode reverseList(ListNode head) {
    ListNode preNode = null, nextNode;  // head指针的前一个节点和后一个节点
    while (head != null) {
        nextNode = head.next;
        head.next = preNode;  // 把 前指针 和 中指针 这一对节点反转

		// 各个指针依次后移一位
        preNode = head;
        head = nextNode;
    }
    return preNode;
}

迭代的解法

递归解法的空间复杂度为 $O (n)$ ，因而不是最优的。
迭代解法可以使空间复杂度降至 $O (1)$ 。

仍然是使用reverseList()函数翻转每一组节点。
难点在于如何正确地不断向后移动各个指针以遍历每一组节点，并且正确地处理第一组和最后一组节点。

基于递归的解法进行改进，可以得到如下的迭代解法。

public ListNode reverseKGroup(ListNode head, int k) {
    if (head == null || k == 1) return head;
    ListNode newHead = null, tail, preTail = null, nextHead;  // 四个指针分别为 反转完成后的头、当前组的尾巴、前一组的尾巴 和 下一组的头
    int counter;
    while (head != null) {
        // 先找尾巴
        tail = head;
        counter = k;
        while (--counter > 0 && tail != null) tail = tail.next;

        // 然后将该组反转
        if (tail != null) {  // 足够一组，则进行反转
            nextHead = tail.next;  // 先记录下一组的头节点，因为下一步将把 tail 节点与后面断开连接
            tail.next = null;  // 将该组节点与后面的节点断开，便于 reverseList() 函数进行翻转
            if (newHead == null) newHead = reverseList(head);  // 是第一组，则记下新的头节点
            else preTail.next = reverseList(head);  // 不是第一组，则将翻转后的链表与前一组的尾巴连接
            preTail = head;  // 此时 head 节点已经变成了该组的尾节点
            head = nextHead;
        } else {  // 不到一组，则不反转，并结束循环
            if (newHead == null) newHead = head;  // 是第一组，则记下新的头节点
            else preTail.next = head;  // 不是第一组，则将链表与前一组的尾巴连接
            break;
        }
    }
    return newHead;
}

/**
 * 反转链表，并返回新的头节点
 */
private ListNode reverseList(ListNode head) {
    ListNode preNode = null, nextNode;  // head指针的前一个节点和后一个节点
    while (head != null) {
        nextNode = head.next;
        head.next = preNode;  // 把 前指针 和 中指针 这一对节点反转

        // 各个指针依次后移一位
        preNode = head;
        head = nextNode;
    }
    return preNode;
}