问题描述

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

问题理解

给定一个链表和一个数字 k，任务是将链表中的每 k 个节点做一次翻转，如果链表的长度不是 k 的整数倍，则剩余的节点保持原有顺序。这是一个典型的链表操作问题，涉及到链表的遍历、节点的重新链接等操作。

解题思路1

1. 确定操作单位

在理解了问题之后，首先明确操作的基本单位是“节点组”，每组包含 k 个节点。操作的核心是对这些节点组进行翻转。如果当前组节点不足 k 个，直接跳过该组，保持原样。

2. 理解翻转操作

链表的翻转是基础操作，但在此问题中，我们不是翻转整个链表，而是翻转部分连续的节点。这要求我们能够准确识别每个待翻转的节点组的起始点和终点。

3. 操作过程的细化

为了实现这一操作，我们需要细化操作过程：

• 定位节点组：从链表头部开始，向后数 k 个节点，标记为一个待翻转的节点组。
• 执行翻转：对每个节点组执行翻转操作。翻转涉及断开节点的原有连接，然后按逆序重新连接。
• 处理边界：每次翻转完成后，需要正确处理该节点组与前后节点的连接关系，确保链表的完整性。

4. 算法的选择

为了方便处理链表的头部可能变化的情况，采用了一个虚拟头节点（dummy node）。这个节点在实际链表的头部之前，使得链表头部的处理逻辑与其他部分一致。

5. 连接与继续

完成一个节点组的翻转后，需要将翻转后的尾部（翻转前的头部）连接到下一个节点组的头部。同时，更新操作指针，继续识别和处理下一个节点组。

代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if (head == nullptr || head->next == nullptr || k == 1) {
            return head;
        }

        ListNode dummy(0);
        dummy.next = head;
        ListNode* prevGroupEnd = &dummy;

        while (true) {
            // 检查是否有足够的节点来进行翻转
            ListNode* current = prevGroupEnd;
            for (int i = 0; i < k && current != nullptr; i++) {
                current = current->next;
            }
            if (current == nullptr)
                break; // 如果不够 k 个，就不进行翻转

            ListNode* groupStart = prevGroupEnd->next;
            ListNode* nextGroupStart = current->next;

            // 翻转当前的 k 个节点
            ListNode* prev = nextGroupStart;
            ListNode* curr = groupStart;
            while (curr != nextGroupStart) {
                ListNode* temp = curr->next;
                curr->next = prev;
                prev = curr;
                curr = temp;
            }

            // 将翻转后的子链表接回主链表
            prevGroupEnd->next = prev;
            prevGroupEnd = groupStart;
        }

        return dummy.next;
    }
};

进阶

你可以设计一个只用 O(1) 额外内存空间的算法解决此问题吗？

解题思路

1. 链表遍历和长度计算

首先，我们需要遍历整个链表来确定其长度，这样可以判断出能够完整进行多少次k节点的翻转。这一步是必要的，因为如果链表长度未达到k，则不应进行翻转。

2. 翻转链表的k个节点

对于链表翻转操作，我们通常会使用三个指针：prev、curr（当前节点）、nex（当前节点的下一个节点）。通过这三个指针可以实现链表的局部翻转：

• prev 指针始终指向当前k个节点组的前一个节点，以便在翻转后将翻转的部分重新连接到主链表上。
• curr 是当前正在处理的节点，也是每次k组翻转的第一个节点。
• nex 用于存储curr的下一个节点，确保在翻转过程中不会丢失链表的其余部分。

具体翻转步骤是：对于每个k节点组，我们将curr的下一个节点移到prev之后，这样原来的第二个节点就成了新的第一个节点，重复这个操作k-1次，便完成了一组的翻转。

3. 连接翻转后的部分

每次翻转完成后，需要更新prev指针到当前k组的末尾，这样在下一次循环时，它可以正确地指向下一组待翻转节点组的前一个节点。同时，更新剩余节点计数，减去已翻转的k个节点。

4. 处理不足k个的节点

在遍历链表时，如果发现剩余节点数小于k，则不进行翻转，直接将这些节点连接到已翻转部分的末尾。

5. 虚拟头节点的使用

在处理链表问题时，使用虚拟头节点可以大大简化边界条件的处理，例如当链表头部节点需要被移动或删除时。在这个问题中，虚拟头节点帮助我们更方便地处理头k个节点的翻转，以及最终返回新的头节点。

通过这样的步骤，我们可以实现题目要求的每k个节点一组的翻转，而不足k个的部分保持不变。这种方法的时间复杂度为O(n)，空间复杂度为O(1)，因为我们没有使用额外的数据结构，仅通过修改节点间的链接来达到翻转的目的。

代码实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode *prev = dummy, *curr = head, *nex = nullptr;

        // 首先计算链表长度
        int count = 0;
        while (curr) {
            curr = curr->next;
            count++;
        }

        // 当链表中至少有k个节点时进行翻转
        while (count >= k) {
            curr = prev->next;
            nex = curr->next;
            for (int i = 1; i < k; i++) {
                curr->next = nex->next;
                nex->next = prev->next;
                prev->next = nex;
                nex = curr->next;
            }
            prev = curr;
            count -= k;
        }

        ListNode* ret = dummy->next;
        delete dummy; // 释放虚拟头节点
        return ret;
    }
};