Reverse Nodes in k-Group

Intuition

Each group is only reversed when a full run of k nodes is available, so we first probe ahead to count them. If fewer than k remain, we return the group untouched, which naturally handles the trailing remainder. Reversing the block is the classic prev/curr pointer flip run exactly k times, which leaves the block's original head as its new tail. That old head must connect to whatever the rest of the list resolves to, so we recurse on the node right after the block. Returning the block's new front links everything together as the recursion unwinds.

Algorithm walkthrough

1. 1Walk up to k steps from head to confirm at least k nodes are present.
2. 2If fewer than k nodes exist, return head so the short final group stays in order.
3. 3Reverse exactly k nodes with the prev/curr flip; prev becomes the block's new head and head becomes its tail.
4. 4Recurse on curr (the first node after the block) to reverse the remainder.
5. 5Attach the block's tail (the original head) to the recursion's result via head.next.
6. 6Return prev as the new head of this reversed block.

Implementation

class Solution:
    def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        node = head
        count = 0
        while node and count < k:
            node = node.next
            count += 1
        if count < k:
            return head
        prev = None
        curr = head
        for _ in range(k):
            nxt = curr.next
            curr.next = prev
            prev = curr
            curr = nxt
        head.next = self.reverseKGroup(curr, k)
        return prev