Groups of k (Linked List — Reversal Sub-pattern)

// Groups of k: reverse each full block of k nodes; a short last block stays as it is.
// Count k nodes ahead first. If the block is full, reverse it, then join it to the
// previous block's tail (the old first node of this block is now its last).
ListNode* reverseKGroup(ListNode* head, int k) {
    ListNode dummy(0, head);
    ListNode* groupPrev = &dummy;              // the node just before the current block

    while (true) {
        // 1. Is there a full block of k nodes starting after groupPrev?
        ListNode* kth = groupPrev;
        for (int i = 0; i < k && kth != nullptr; i++) kth = kth->next;
        if (kth == nullptr) break;             // fewer than k left: leave the rest alone

        ListNode* groupNext = kth->next;       // the node after this block (saved before relinking)
        ListNode* first = groupPrev->next;     // the old first node; it becomes the block's last

        // 2. Reverse the block with head insertion (same as the sublist template).
        ListNode* prev = groupNext;            // the reversed block must end at groupNext
        ListNode* cur = first;
        while (cur != groupNext) {
            ListNode* nxt = cur->next;
            cur->next = prev;
            prev = cur;
            cur = nxt;
        }

        // 3. Join: the previous block now ends at the new first node (kth).
        groupPrev->next = kth;
        groupPrev = first;                     // the old first is this block's tail for the next round
    }
    return dummy.next;
}