链表中的节点每k个一组翻转

核心思路是先统计链表总长度，确定需要反转的组数，再逐组局部反转并重新连接，计算出需要反转的组数s = n/k；然后循环s次，每次对当前 k 个节点进行局部反转，反转后将当前组的首尾与前后部分重新连接，最后返回处理后的链表头。
对应的代码解析如下：
class Solution {public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(!head || k == 1) return head; // 空链表或k=1无需反转 
        ListNode* dummy = new ListNode(0); // 虚拟头节点，简化头节点处理
        dummy->next = head;
        ListNode* cur = head;
        ListNode* pre = dummy; // 记录上一组的尾节点
        ListNode* next = nullptr;
        ListNode* prev = nullptr;
        ListNode* temp = nullptr; // 记录当前组反转前的头节点   
        int n = 0;
        while(cur != nullptr) {
            n++;
            cur = cur->next;
        }
        cur = head;
        if(n == 1) return head; // 只有1个节点直接返回
        int s = n / k; // 计算需要反转的组数
        while(s--) {
            for(int i = 0; i < k; i++) {
                if(i == 0) temp = cur; // 记录当前组反转前的头节点
                next = cur->next;
                cur->next = prev; // 当前节点指向前一个反转节点
                prev = cur;
                cur = next;
            }
            pre->next = prev;
            temp->next = cur;
            pre = temp; // 更新上一组的尾节点为当前组反转前的头节点
            prev = nullptr; // 重置反转前驱指针
        }
        ListNode* newhead = dummy->next;
        delete dummy; // 释放虚拟头节点，避免内存泄漏
        return newhead;
    }};
该解法的时间复杂度为 O (n)，空间复杂度为 O (1)。