Linked List Group Reverse

You are given the head of a singly linked list and an integer k. Reverse the nodes of the list k at a time and return the head of the modified list.

Walk the list from the front and split it into consecutive blocks of k nodes. Reverse the order of nodes within each block, while keeping the blocks themselves in their original left-to-right order.

If the number of nodes is not a multiple of k, the left-out nodes at the end form a final block that must also be reversed.

Only the links between nodes change — you should not need to allocate any new nodes.

Hints

· Stuck? Reveal one nudge at a time.

You already know how to reverse an entire linked list. What if you let that reversal run for only k steps before stopping?

After reversing one block of k, the node you originally started from becomes that block's tail — you'll need it to attach the next block.

Keep three things per group: the new head (prev), the old-first-now-tail node, and the start of the next group. Stitch tails to heads as you go.

Common doubts

It is still reversed. This variant treats the leftover nodes as a full group, so a trailing block of 1 stays the same (reversing one node is a no-op) but a trailing block of 3 with k = 4 is flipped.

If k is larger than the number of nodes, the entire list is a single group and gets fully reversed.

No. The optimal approach only rewires existing next pointers, so no new nodes are created.

Interview follow-ups

· What an interviewer asks next.

That is the stricter variant: count k nodes ahead first, and only reverse a group when a full k nodes remain; otherwise stop and leave the tail untouched.

Yes — reverse the first k nodes, recurse on the rest, then attach. The catch is O(n/k) call-stack depth, which can overflow for large n with small k; the iterative version keeps O(1) space.

Fun facts

The three-pointer reversal at the core here is the exact maneuver used to reverse an entire list — group reverse is just that trick with a counter and a stitch.
This 'reverse a sublist and re-link' pattern reappears when reversing nodes between two positions and when rotating a list.

Asked at

AmazonMicrosoftFlipkartGoogleAdobe

Frequently Sometimes Occasionally

Example 1

Input: head = [1,2,3,4,5,6], k = 2
Output: [2,1,4,3,6,5]
Each block of 2 nodes is reversed: (1,2) -> (2,1), (3,4) -> (4,3), (5,6) -> (6,5).

Example 2

Input: head = [1,2,3,4,5,6], k = 4
Output: [4,3,2,1,6,5]
The first block of 4 is reversed to 4,3,2,1; the leftover block (5,6) is reversed to 6,5.

Constraints

- 1 <= size of the linked list <= 10^5 - 0 <= node value <= 10^6 - 1 <= k <= size of the linked list

Reversing a whole linked list is a rite of passage. This problem asks for something sharper: reverse the list in bite-sized blocks of k, then re-link the blocks so nothing is lost. Master the stitch and you own a whole family of linked-list problems.

Prerequisites

Before you start

· Concepts used directly in the solution.

Reversing a linked list. The three-pointer prev/cur/next dance that turns a list around in one pass — here we run it only k steps at a time.

Pointer manipulation. Comfort rewiring next fields without losing the rest of the list.

Boundary tracking. Handling the very first group's head and the seam between two consecutive groups.

Understand the problem

In plain English: break the list into consecutive chunks of k nodes (the last chunk may be shorter), reverse the order of nodes inside each chunk, and keep the chunks in their original sequence. Return the new head.

Formally: given head and integer k, produce a list where nodes [0, k) are reversed, then [k, 2k), and so on — including a final, possibly shorter, block.

Worked example — head = 1 → 2 → 3 → 4 → 5, k = 2

group [1,2] → 2 → 1
group [3,4] → 4 → 3
group [5]   → 5        (leftover — still a group; reversing a lone node is a no-op)

result: 2 → 1 → 4 → 3 → 5

Clarifying questions

Asking before coding shows you probe the contract instead of assuming it.

Questions to ask first

· Signals seniority before you write a line of code.

The leftover rule

“If the node count is not a multiple of k, is the final partial group reversed or left as-is?”

This flips the whole solution: here the leftover block is reversed, unlike the stricter variant that leaves the tail untouched.

Input validity

“Is k guaranteed to be at least 1?”

A k of 0 would be undefined; confirming the lower bound lets you skip a guard or add one deliberately.

“Can k be larger than the list length?”

If so, the entire list is a single group and is fully reversed.

Constraints and scale

“How large can the list get?”

Up to 1e5 nodes rules out anything worse than linear and warns against deep recursion.

The ideal opening — say it like this

Before I code, a few quick checks on the contract.

Most importantly — if the last group is shorter than k, I should still reverse it, correct?

And k is always at least 1, and may exceed the list length, in which case the whole list reverses?

Given up to 1e5 nodes, I'll aim for a single linear pass with constant extra space, done iteratively to avoid stack depth.

Key observations

1Aha

Group reverse is whole-list reverse on a leash

The standard reversal walks prev/cur/next until the list ends. Cap that walk at k steps and you have reversed exactly one group — the same loop, stopped early.

repeat up to k times:  next ← cur.next; cur.next ← prev; prev ← cur; cur ← next
after: prev = new head of the block, the node you started from = new tail

2Aha

The node you start from becomes the group's tail

Before reversing, the first node of a block leads it. After reversing, it trails. That trailing node is exactly where the next reversed block must be welded on — so remember it.

3Aha

There are only two seams to manage

Everything reduces to: capture the first group's new head once (it's the answer), and for every later group, connect the previous group's saved tail to this group's new head. The leftover group needs no special case — the same k-capped loop simply runs out early and reverses whatever remains.

Brute force vs optimal

	Brute force (value copy)	Optimal (pointer reversal)
Time	O(n)	O(n)
Space	O(n)	O(1)
Idea	flip values in an array	rewire next pointers

Both are linear in time; the optimal wins on space by never copying the data. Full code for each is in the Approaches selector below.

Summary

Key takeaway

Reverse-in-a-window, then re-stitch: run the classic three-pointer reversal but cap it at k, track each group's new head and new tail, and weld consecutive groups together. This one template powers most "operate on groups of a list" problems.

cur ← head; newHead ← null; prevTail ← null
while cur:
    reverse up to k nodes from cur → newGroupHead; groupTail ← old cur; node ← rest
    if newHead is null: newHead ← newGroupHead
    if prevTail: prevTail.next ← newGroupHead
    prevTail ← groupTail; cur ← node
return newHead