LC.25 | K个一组反转链表 | 链表 | 分治 / 问题分解-优快云博客

输入：单链表的头节点 head 和一个正整数 k。

要求：每 k 个节点一组进行翻转。如果最后剩余的节点数量不足 k 个，则保持不变。

输出：修改后链表的头节点。

思路：分治 / 问题分解

这道题是 LeetCode.92 “反转链表 II” 的进阶。我们完全不需要重新发明轮子，而是可以将此问题看作是重复执行 k 次 “反转指定区间” 的操作。

首先遍历链表，获取其总长度 len，从而计算出总共需要进行多少轮完整的 k 组翻转。
循环 len / k 次，对于每一轮，我们计算出需要反转的区间的 left 和 right 索引。
在循环中，我们直接调用 LeetCode.92 的 reverseBetween 函数来处理当前区间的反转。reverseBetween 的返回值将作为下一次循环的 head 输入。
reverseBetween 函数本身又调用了 LeetCode.206 的 reverseList 函数，从而形成了一个完美的解题链条：LC.25 -> LC.92 -> LC.206。

复杂度：

时间复杂度: 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:
    // LC.206: 反转整个链表
    ListNode* reverseList(ListNode* head) {
        ListNode* dummy = new ListNode(0, NULL);
        ListNode* tmp;
        while (head) {
            tmp = head->next;
            head->next = dummy->next;
            dummy->next = head;
            head = tmp;
        }
        return dummy->next;
    }

    // LC.92: 反转指定区间的链表
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        if (left == right) {
            return head;
        }
        ListNode* dummy = new ListNode(-1, head);
        ListNode* righthead = head;
        ListNode* lefthead = dummy;

        for (int i = 0; i < left - 1; ++i) {
            lefthead = lefthead->next;
        }
        for (int i = 0; i < right - 1; ++i) {
            righthead = righthead->next;
        }

        ListNode* sub_list_head = lefthead->next;
        ListNode* rest_of_list = righthead->next;
        righthead->next = nullptr;

        lefthead->next = reverseList(sub_list_head);
        
        sub_list_head->next = rest_of_list;

        return dummy->next;
    }

    // LC.25: K 个一组翻转链表
    ListNode* reverseKGroup(ListNode* head, int k) {
        if (k == 1) {
            return head;
        }
        int len = 0;
        ListNode* len_ptr = head;
        while (len_ptr) {
            len++;
            len_ptr = len_ptr->next;
        }

        int turnCount = len / k;

        ListNode* current_head = head;
        for (int i = 0; i < turnCount; i++) {
            int left = i * k + 1;
            int right = i * k + k;
            current_head = reverseBetween(current_head, left, right);
        }
        return current_head;
    }
};