90. Reverse a Linked List in Groups of Size K

A singly linked list is given as n node values. Reverse every consecutive group of k nodes independently and print the resulting sequence. If the final group has fewer than k nodes, reverse that group too.

Input: The first line contains an integer n. The second line contains n space-separated integers, the list's values. The third line contains k, the group size. Output: Print the resulting sequence after reversing each group of k nodes, space-separated, on one line.

1 <= k <= n <= 10^5

This builds directly on the basic 'Reverse a Linked List' technique, just applied repeatedly within bounded chunks and requiring careful stitching between chunks - mastering the single-list reversal first makes this feel like a natural extension rather than a new problem.

Reverse every consecutive group of k nodes in a linked list, independently, including a shorter final group. Brute force: Copy all values into an array, reverse each k-sized chunk of the array directly, and rebuild the list - this works but discards the existing nodes when they could simply be relinked in place. Optimised: Applying the standard single-list reversal technique repeatedly, bounded to exactly k nodes at a time, and carefully stitching each reversed chunk's END to the NEXT chunk's reversed START, achieves the grouped reversal using the existing nodes with no extra allocation.

Traverse the linked list once, copying every node's value into a plain array in order. Working on that array, reverse each consecutive block of k values in place, including a final shorter block if the list length isn't a multiple of k. Finally, write the rearranged values back into the original nodes in order (or build a new linked list from the array) and print the result. This trades linked-list pointer manipulation for simple array indexing at the cost of an entire auxiliary copy of the data. Time: O(n) Space: O(n)

Walk the list once, and for each group of up to k nodes, reverse the links within that group in place using the usual three-pointer previous/current/next technique, without recursion. Keep a reference to the tail of the previously reversed group so that once the current group is reversed, its new head can be linked from that previous tail, and continue linking as later groups are processed. Handle a final group with fewer than k nodes the same way, since the problem specifies reversing it too, and no extra memory beyond a handful of pointers is ever needed. Time: O(n) Space: O(1)

Reverse the first k nodes of the list iteratively using standard pointer reversal, producing a reversed block whose original head is now its tail, then recursively call the same function on whatever remains of the list after that first group, which returns the head of the fully processed remainder. Link the tail of the just-reversed first group to the head of the recursively processed remainder, and return the new head of this group. Each recursive call handles one group and hands off to the next, so the recursion depth equals the number of groups rather than the number of nodes. Time: O(n) Space: O(n/k)

1. Process the list k nodes at a time: for each chunk, reverse the links WITHIN that chunk only (using the standard three-pointer reversal technique, bounded to just k nodes). 2. Connect the end of the previous (already-reversed) chunk to the START of the current chunk's reversal. 3. If the final chunk has fewer than k nodes, reverse that shorter chunk too, per this problem's requirement.

Time: O(n) - every node's link is touched a constant number of times across the whole process. Space: O(1) extra space iteratively, or O(n/k) for the recursion stack if implemented recursively (one stack frame per group).

k = 1 (no visible change since each group has one node); k = n (the whole list reverses as a single group); a trailing partial group smaller than k, which must still be reversed (per the hints).

Be explicit about the trailing partial group's handling (still reversed here, per this problem's stated rule) - some similar problems leave a short final group UNREVERSED instead, so always confirm the exact requirement.