How do you solve Reverse Linked List II using the Head-Insertion — True One Pass approach?

When to use it: Offer for the explicit 'one pass' follow-up. Repeatedly move the node after curr to the front of the window — no separate reversal phase. Head-insertion reverses the window without ever building it in isolation — it threads each node to the front as it goes, so the list stays connected the whole time. **The fixed anchor and the fixed curr.** `prevLeft` sits just before the window (again, the dummy guarantees it exists). `curr` is pinned to the window's *first* node and never moves forward — instead, the nodes behind it get pulled ahead of it. Because `curr` ends up at the back of the window, it naturally becomes the reversed segment's tail. **One splice per step.** On each iteration we grab `nxt = curr.next`, the node immediately after `curr`. Three assignments relocate it to the front of the window: 1. `curr.next = nxt.next` — unhook `nxt`, so `curr` now skips over it. 2. `nxt.next = prevLeft.next` — point `nxt` at the current front of the window. 3. `prevLeft.next = nxt` — make `nxt` the new front. After this, `nxt` has jumped to the head of the window and everything else shifted back by one. Repeating `right - left` times pulls every later window node in front of `curr`, fully reversing the segment. **Why it's genuinely one pass.** There's no 'reverse then reconnect' split: the boundary links are maintained continuously by the three assignments. `prevLeft.next` always points at the current window head, and `curr.next` always points at the suffix, so the list is valid after every step. That continuous correctness is what makes head-insertion the canonical answer to the 'can you do it in one pass?' follow-up. **The order of the three lines is fixed.** Detach before you redirect, redirect before you re-anchor. Swap any two and you either lose `nxt.next` or strand part of the window — the same discipline as the classic three-pointer flip, just applied to relocation instead of in-place reversal. Time complexity: O(n). Space complexity: O(1).

Loading…

mediumLinked ListsLC #92Frequently asked

Reverse Linked List II

LCPractice

Linked List · 11 of 24 · 10 min

Given the head of a singly linked list and two integers left and right where left <= right, reverse the nodes of the list from position left to position right, and return the reversed list.

Positions are 1-indexed: the head is position 1. The reversal is over the inclusive range [left, right].

In plain English

We reverse only the contiguous segment between 1-indexed positions left and right, leaving the prefix and suffix untouched, and splice the reversed segment back in. No nodes are created and no values copied — only next pointers change. When left == right the list is unchanged.

Examples

Example 1

Input: head = [1,2,3,4,5], left = 2, right = 4
Output: [1,4,3,2,5]
Note: The segment 2→3→4 is reversed to 4→3→2; node 1 (prefix) and node 5 (suffix) stay put.

Example 2

Input: head = [5], left = 1, right = 1
Output: [5]
Note: Single node, left == right — nothing to reverse.

Example 3

Input: head = [3,5], left = 1, right = 2
Output: [5,3]
Note: Reversing from position 1 changes the head — the dummy node makes this seamless.

Constraints

The number of nodes in the list is n
1 ≤ n ≤ 500
-500 ≤ Node.val ≤ 500
1 ≤ left ≤ right ≤ n
Follow up: can you do it in one pass?

Clarifying questions4First question: Are the positions 1-indexed, and is the range inclusive?Explore questions

Q1.Are the positions 1-indexed, and is the range inclusive?
Yes — position 1 is the head, and [left, right] is inclusive. So left=2, right=4 reverses the 2nd, 3rd, and 4th nodes.
Q2.Can left equal 1 (reversing from the head)?
Yes, and that's the tricky case because the head itself changes. A dummy node in front of head removes the special-casing entirely.
Q3.Can I mutate the nodes, and is one pass required?
In-place mutation is expected and gives O(1) space. The follow-up asks for one pass, which the head-insertion method achieves.
Q4.What if left == right?
Then there's a single node in the range and nothing to reverse — return the list unchanged. My loop runs zero times in that case.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Use a dummy node before the head so the case 'left = 1' needs no special handling. Walk a pointer to the node just before position left, then reverse only the sublist from left to right. Two clean ways: (1) reverse the sublist in place with the prev/curr flip and reconnect the three boundary links, or (2) the one-pass head-insertion trick — repeatedly pull the node after curr to the front of the sublist. Both are O(n) time, O(1) space, single traversal.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you can reverse a bounded segment in place without losing the rest of the list, handle 1-indexing and the inclusive range, and reconnect the boundary pointers correctly — especially the edge case left = 1.

Where candidates slip

Off-by-one on the walk to prevLeft, forgetting the dummy so left = 1 breaks, or mis-stitching the boundaries (leaving a gap or a cycle between the reversed segment and the tail).

How to stand out

Use a dummy node, show the one-pass head-insertion method, and articulate exactly which three links get rewired and why the original sub-head becomes the sub-tail that must point to the node after right.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Reverse the Sublist In Place, Then Reconnect	`O(n)`	`O(1)`	Lead with this — it's the most intuitive. Phrase it as 'reverse just the [left, right] window with the standard flip, then stitch the three boundary links'.	Read
2	Head-Insertion — True One PassOptimal	`O(n)`	`O(1)`	Offer for the explicit 'one pass' follow-up. Repeatedly move the node after curr to the front of the window — no separate reversal phase.	Read

Interactive decision treeInteractiveChoose the right approachFollow the branches and learn why each constraint changes the solution.First decision previewReverse sublist [left, right]left == 1? (head changes)Yes/NoExplore the full tree

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 2

Reverse the Sublist In Place, Then Reconnect

TimeO(n)SpaceO(1)

Lead with this — it's the most intuitive. Phrase it as 'reverse just the [left, right] window with the standard flip, then stitch the three boundary links'.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Add a dummy node before head so reversing from position 1 isn't special. Walk a pointer to the node just before position left and remember it.

2Hint 2Explore hint

From there, run the ordinary prev/curr/next reversal, but only for the (right - left + 1) nodes in the window.

3Hint 3Explore hint

After reversing, you have three loose ends: the node before left, the new head of the reversed window (old position right), and the new tail (old position left) which must point to whatever followed right.

A · Core idea

This approach reuses the muscle memory from full-list reversal and confines it to a window.

The dummy node erases the head edge case. When left = 1, the reversal changes the list's head, which would otherwise require special handling. Prepending a dummy node whose next is head means the 'node before the window' always exists — even when the window starts at position 1, the node before it is simply the dummy. We return dummy.next at the end, which is the (possibly new) real head.

Find the anchor, then reverse the window. We walk beforeLeft forward left - 1 steps so it sits on the node immediately before position left. The window to reverse is then beforeLeft.next through the node at position right. We apply the classic three-pointer flip — prev, curr, next — but only right - left + 1 times, so it stops exactly at the window's end. When the loop finishes, prev points at the node that was at position right (the window's new head), and curr points at the node just past right (the start of the untouched suffix).

Reconnecting the three boundaries is the whole game. Reversing the window in isolation leaves it detached. Three links restore the list:

1
The node that was first in the window (position left) is now its tail. We captured it as subTail = beforeLeft.next before rewiring, because beforeLeft.next still points there.
2
beforeLeft.next = prev splices the prefix onto the window's new head (old right).
3
subTail.next = curr connects the window's new tail to the suffix (the node after old right).

Get any of those three wrong and you either drop the suffix, leave a gap, or create a cycle. Naming them explicitly — 'prefix → new head, new tail → suffix' — is what keeps the wiring straight under pressure.

Why capture subTail early. The original first node of the window becomes the tail after reversal, but its identity is easiest to grab before the reversal mutates pointers: it's exactly beforeLeft.next at the moment we arrive. Stash it, then reverse, then use it to attach the suffix.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

head = [1,2,3,4,5], left = 2, right = 4

Array state

anchor

beforeLeft=node1, window=[2,3,4]

beforeLeft ↓

[0]

subTail ↓

[1]

[2]

[3]

[4]

Current pointerResolved stateNot processed

Final result[1,4,3,2,5]

C · Code with teaching comments

Reference implementation previewpublic class ListNode { int val; ListNode next; ListNode() {} ListNode(int val) { this.val = val; }Explore the full code

solution.javaJava

Reverse the Sublist In Place, Then Reconnect — reference

6 teaching notes

1
public class ListNode {
2
    int val;
3
    ListNode next;
4
    ListNode() {}
5
    ListNode(int val) { this.val = val; }
6
    ListNode(int val, ListNode next) { this.val = val; this.next = next; }
7
}
8
 
9
public ListNode reverseBetween(ListNode head, int left, int right) {
10
    if (head == null || left == right) {
11
        return head;
12
    }
13
    // Dummy before head so reversing from position 1 needs no special case.
14
    ListNode dummy = new ListNode(0, head);
15
    ListNode beforeLeft = dummy;
16
    for (int i = 0; i < left - 1; i++) {
17
        beforeLeft = beforeLeft.next;
18
    }
19
    ListNode subTail = beforeLeft.next; // old position left -> becomes the tail
20
    ListNode prev = null;
21
    ListNode curr = beforeLeft.next;
22
    for (int i = 0; i <= right - left; i++) {
23
        ListNode next = curr.next;
24
        curr.next = prev;
25
        prev = curr;
26
        curr = next;
27
    }
28
    beforeLeft.next = prev;   // prefix -> new head (old position right)
29
    subTail.next = curr;      // new tail -> suffix (node after right)
30
    return dummy.next;
31
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.31 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

A bounded reversal is just the ordinary reversal with a step counter, sandwiched between two pointer hand-offs. The dummy node neutralizes the head case, and the only genuinely new idea versus full reversal is that the first node of the window becomes the node you must reattach to the suffix.

ComplexityO(n) time, O(1) space — One walk to position left (≤ n steps) plus one reversal pass over the window (≤ n steps) — a single overall traversal, so O(n) time. Only a constant number of pointers are used, so O(1) space.

E · Edge cases and pitfalls7left == 1 (reverse from head) — beforeLeft stays on the dummy; dummy.next is rewired to the new head, returned correctly.Explore edge cases

Edge cases handled

left == 1 (reverse from head)beforeLeft stays on the dummy; dummy.next is rewired to the new head, returned correctly.
left == rightGuarded up front — the function returns the list unchanged.
right == n (window reaches the tail)curr ends as null; subTail.next = null correctly terminates the list.

Pitfalls

Forgetting the dummy node — left = 1 then needs a separate code path.
Off-by-one on the walk: stopping ON position left instead of just before it.
Reversing right - left times instead of right - left + 1 (drops the last window node).
Capturing subTail after the reversal, when beforeLeft.next no longer points to it.

03.2

Approach 2 of 2 · Optimal

Head-Insertion — True One Pass

TimeO(n)SpaceO(1)

Offer for the explicit 'one pass' follow-up. Repeatedly move the node after curr to the front of the window — no separate reversal phase.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Keep curr fixed on the window's first node. Each step, take the node right after curr and splice it to the front of the window (just after prevLeft).

2Hint 2Explore hint

Doing that (right - left) times slides every later window node ahead of curr, which naturally leaves curr at the back — the window is reversed.

3Hint 3Explore hint

Three pointer assignments per step: detach curr.next, point it at prevLeft.next, then make it the new prevLeft.next.

A · Core idea

Head-insertion reverses the window without ever building it in isolation — it threads each node to the front as it goes, so the list stays connected the whole time.

The fixed anchor and the fixed curr. prevLeft sits just before the window (again, the dummy guarantees it exists). curr is pinned to the window's first node and never moves forward — instead, the nodes behind it get pulled ahead of it. Because curr ends up at the back of the window, it naturally becomes the reversed segment's tail.

One splice per step. On each iteration we grab nxt = curr.next, the node immediately after curr. Three assignments relocate it to the front of the window:

1
curr.next = nxt.next — unhook nxt, so curr now skips over it.
2
nxt.next = prevLeft.next — point nxt at the current front of the window.
3
prevLeft.next = nxt — make nxt the new front.

After this, nxt has jumped to the head of the window and everything else shifted back by one. Repeating right - left times pulls every later window node in front of curr, fully reversing the segment.

Why it's genuinely one pass. There's no 'reverse then reconnect' split: the boundary links are maintained continuously by the three assignments. prevLeft.next always points at the current window head, and curr.next always points at the suffix, so the list is valid after every step. That continuous correctness is what makes head-insertion the canonical answer to the 'can you do it in one pass?' follow-up.

The order of the three lines is fixed. Detach before you redirect, redirect before you re-anchor. Swap any two and you either lose nxt.next or strand part of the window — the same discipline as the classic three-pointer flip, just applied to relocation instead of in-place reversal.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

head = [1,2,3,4,5], left = 2, right = 4

Interactive diagram

Picking the right approach

start

Active call / nodeSupporting contextReturned stateNot active

A dummy node plus a bounded reversal; head-insertion is the elegant one-pass variant.

Final result[1,4,3,2,5]

C · Code with teaching comments

solution.javaJava

Head-Insertion — True One Pass — optimal

6 teaching notes

1
public ListNode reverseBetween(ListNode head, int left, int right) {
2
    if (head == null || left == right) {
3
        return head;
4
    }
5
    ListNode dummy = new ListNode(0, head);
6
    // Anchor that always sits just before the window — dummy handles left = 1.
7
    ListNode prevLeft = dummy;
8
    for (int i = 0; i < left - 1; i++) {
9
        prevLeft = prevLeft.next;
10
    }
11
    ListNode curr = prevLeft.next; // stays put; later nodes move ahead of it
12
    for (int i = 0; i < right - left; i++) {
13
        // The node to relocate to the front of the window this step.
14
        ListNode nxt = curr.next;
15
        curr.next = nxt.next;        // detach nxt
16
        nxt.next = prevLeft.next;    // nxt points at current window head
17
        prevLeft.next = nxt;         // nxt becomes the new window head
18
    }
19
    return dummy.next;
20
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.20 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

Head-insertion reframes 'reverse a window' as 'repeatedly move the second window node to the front'. Keeping curr stationary and sliding others past it means the list never breaks apart, so there's nothing to reconnect at the end — the elegance interviewers reward on the one-pass follow-up.

ComplexityO(n) time, O(1) space — A single walk to prevLeft plus right - left splice operations, each O(1). One overall traversal → O(n) time, O(1) space with a constant number of pointers.

E · Edge cases and pitfalls7left == 1 — prevLeft is the dummy; the new head emerges as dummy.next, returned correctly.Explore edge cases

Edge cases handled

left == 1prevLeft is the dummy; the new head emerges as dummy.next, returned correctly.
left == rightLoop runs zero times; list unchanged.
window of two nodesOne splice swaps them; list stays valid throughout.

Pitfalls

Reordering the three splice lines — detach, then redirect, then re-anchor.
Looping right - left + 1 times instead of right - left (over-rotates the window).
Advancing curr each iteration — curr must stay fixed as the window's first node.
Skipping the dummy and special-casing left = 1.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic ListNode reverseBetween(ListNode head, int left, int right) { if (head == null || left == right) { return head; } ListNode dummy = new ListNode(0, head);Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Skipping the dummy node

When left = 1 the head itself changes. Without a dummy you must branch on 'is left 1?' and reattach the head manually — error-prone. A dummy makes 'the node before the window' always exist.

Explore the code comparison

Don't write this

// no dummy: must special-case left == 1
ListNode beforeLeft = head;
for (int i = 0; i < left - 2; i++) beforeLeft = beforeLeft.next;
// ...and separate logic when left == 1 to update head

Write this instead

ListNode dummy = new ListNode(0, head);
ListNode beforeLeft = dummy;
for (int i = 0; i < left - 1; i++) beforeLeft = beforeLeft.next;
// left == 1 needs no special case; return dummy.next

Forgetting to capture the sublist tail

In the reverse-then-reconnect method, the window's first node becomes its tail and must point to the suffix. If you don't capture it before reversing, beforeLeft.next no longer points to it and the suffix is lost.

Explore the code comparison

Don't write this

prev = None
curr = before_left.next
for _ in range(right - left + 1):
    nxt = curr.next; curr.next = prev; prev = curr; curr = nxt
before_left.next = prev
# forgot to connect the old sub-head to the suffix -> tail dangles

Write this instead

sub_tail = before_left.next   # capture BEFORE reversing
prev = None
curr = before_left.next
for _ in range(right - left + 1):
    nxt = curr.next; curr.next = prev; prev = curr; curr = nxt
before_left.next = prev
sub_tail.next = curr          # reattach the suffix

Wrong iteration count on the window

The inclusive range [left, right] has right - left + 1 nodes. The reverse-then-reconnect flip runs that many times; the head-insertion method runs right - left times (one fewer, since curr stays put). Mixing them up over- or under-reverses.

Explore the code comparison

Don't write this

# head-insertion but looping one too many times
for _ in range(right - left + 1):
    nxt = curr.next
    curr.next = nxt.next; nxt.next = prev_left.next; prev_left.next = nxt

Write this instead

# head-insertion: exactly right - left splices
for _ in range(right - left):
    nxt = curr.next
    curr.next = nxt.next; nxt.next = prev_left.next; prev_left.next = nxt

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Dummy node + bounded in-place sublist reversal

Code pattern to memorize

dummy -> head; prevLeft = dummy
advance prevLeft (left-1) times
# head-insertion, repeat (right-left) times:
curr = prevLeft.next
for _ in range(right - left):
    nxt = curr.next
    curr.next = nxt.next
    nxt.next = prevLeft.next
    prevLeft.next = nxt
return dummy.next

Rules to remember

1Use a dummy node in front of head so reversing from position 1 (left = 1) isn't a special case.
2Stop the leading walk at the node just before left (prevLeft) — you need it to re-link the reversed head.
3Positions are 1-indexed and the range [left, right] is inclusive.
4Re-link three boundaries: prevLeft → new sub-head, old sub-head (now sub-tail) → the node after right.
5It's a single pass in O(1) space — no second traversal and no extra list.

Use this pattern when

Reverse only a contiguous segment of a singly linked list
Any in-place pointer rewrite bounded by two positions
Problems that reverse a window then stitch it back (k-group, partial reversals)
When a dummy node simplifies head-adjacent edge cases

Choose another pattern when

You must reverse the WHOLE list → plain Reverse Linked List (no boundaries)
Reverse in fixed-size blocks repeatedly → Reverse Nodes in k-Group
You may not mutate the input → build a new list instead of rewiring pointers

Interview takeaway

Reverse Linked List II is the partial-reversal workhorse: a dummy node erases the head edge case, and the only real subtlety is reconnecting the three boundary links. Master the head-insertion one-pass here and Reverse Nodes in k-Group becomes a short step away.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternDummy node + bounded in-place reversal. The dummy removes the head edge case; the head-insertion variant reverses a window in one pass without a reconnect step. Same family as Reverse Linked List, Reverse Nodes in k-Group, and Swap Nodes in Pairs — recognise it whenever you reverse only a segment and must stitch it back.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Reverse Linked List
The unbounded version — reverse the whole list with the prev/curr/next flip and no boundaries.
Reverse Nodes in k-Group
Reverse every consecutive block of k nodes — repeated bounded reversal stitched together.
Swap Nodes in Pairs
Coming soon
A k-group with k = 2 — reverse pairs using a dummy node and boundary relinking.
Reorder List
Find the middle, reverse the second half, then interleave — partial reversal is the core subroutine.

Same pattern

←

Palindrome Linked List

Continue · Next problem

Reverse Nodes in k-Group

mediumLinked ListsLC #92Frequently asked

Reverse Linked List II

LCPractice

Linked List · 11 of 24 · 10 min

Positions are 1-indexed: the head is position 1. The reversal is over the inclusive range [left, right].

In plain English

Examples

Example 1

Input: head = [1,2,3,4,5], left = 2, right = 4
Output: [1,4,3,2,5]
Note: The segment 2→3→4 is reversed to 4→3→2; node 1 (prefix) and node 5 (suffix) stay put.

Example 2

Input: head = [5], left = 1, right = 1
Output: [5]
Note: Single node, left == right — nothing to reverse.

Example 3

Input: head = [3,5], left = 1, right = 2
Output: [5,3]
Note: Reversing from position 1 changes the head — the dummy node makes this seamless.

Constraints

The number of nodes in the list is n
1 ≤ n ≤ 500
-500 ≤ Node.val ≤ 500
1 ≤ left ≤ right ≤ n
Follow up: can you do it in one pass?

Clarifying questions4First question: Are the positions 1-indexed, and is the range inclusive?Explore questions

Q1.Are the positions 1-indexed, and is the range inclusive?
Yes — position 1 is the head, and [left, right] is inclusive. So left=2, right=4 reverses the 2nd, 3rd, and 4th nodes.
Q2.Can left equal 1 (reversing from the head)?
Yes, and that's the tricky case because the head itself changes. A dummy node in front of head removes the special-casing entirely.
Q3.Can I mutate the nodes, and is one pass required?
In-place mutation is expected and gives O(1) space. The follow-up asks for one pass, which the head-insertion method achieves.
Q4.What if left == right?
Then there's a single node in the range and nothing to reverse — return the list unchanged. My loop runs zero times in that case.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Where candidates slip

Off-by-one on the walk to prevLeft, forgetting the dummy so left = 1 breaks, or mis-stitching the boundaries (leaving a gap or a cycle between the reversed segment and the tail).

How to stand out

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Reverse the Sublist In Place, Then Reconnect	`O(n)`	`O(1)`	Lead with this — it's the most intuitive. Phrase it as 'reverse just the [left, right] window with the standard flip, then stitch the three boundary links'.	Read
2	Head-Insertion — True One PassOptimal	`O(n)`	`O(1)`	Offer for the explicit 'one pass' follow-up. Repeatedly move the node after curr to the front of the window — no separate reversal phase.	Read

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 2

Reverse the Sublist In Place, Then Reconnect

TimeO(n)SpaceO(1)

Lead with this — it's the most intuitive. Phrase it as 'reverse just the [left, right] window with the standard flip, then stitch the three boundary links'.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Add a dummy node before head so reversing from position 1 isn't special. Walk a pointer to the node just before position left and remember it.

2Hint 2Explore hint

From there, run the ordinary prev/curr/next reversal, but only for the (right - left + 1) nodes in the window.

3Hint 3Explore hint

A · Core idea

This approach reuses the muscle memory from full-list reversal and confines it to a window.

Reconnecting the three boundaries is the whole game. Reversing the window in isolation leaves it detached. Three links restore the list:

1
The node that was first in the window (position left) is now its tail. We captured it as subTail = beforeLeft.next before rewiring, because beforeLeft.next still points there.
2
beforeLeft.next = prev splices the prefix onto the window's new head (old right).
3
subTail.next = curr connects the window's new tail to the suffix (the node after old right).

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

head = [1,2,3,4,5], left = 2, right = 4

Array state

anchor

beforeLeft=node1, window=[2,3,4]

beforeLeft ↓

[0]

subTail ↓

[1]

[2]

[3]

[4]

Current pointerResolved stateNot processed

Final result[1,4,3,2,5]

C · Code with teaching comments

Reference implementation previewpublic class ListNode { int val; ListNode next; ListNode() {} ListNode(int val) { this.val = val; }Explore the full code

solution.javaJava

Reverse the Sublist In Place, Then Reconnect — reference

6 teaching notes

1
public class ListNode {
2
    int val;
3
    ListNode next;
4
    ListNode() {}
5
    ListNode(int val) { this.val = val; }
6
    ListNode(int val, ListNode next) { this.val = val; this.next = next; }
7
}
8
 
9
public ListNode reverseBetween(ListNode head, int left, int right) {
10
    if (head == null || left == right) {
11
        return head;
12
    }
13
    // Dummy before head so reversing from position 1 needs no special case.
14
    ListNode dummy = new ListNode(0, head);
15
    ListNode beforeLeft = dummy;
16
    for (int i = 0; i < left - 1; i++) {
17
        beforeLeft = beforeLeft.next;
18
    }
19
    ListNode subTail = beforeLeft.next; // old position left -> becomes the tail
20
    ListNode prev = null;
21
    ListNode curr = beforeLeft.next;
22
    for (int i = 0; i <= right - left; i++) {
23
        ListNode next = curr.next;
24
        curr.next = prev;
25
        prev = curr;
26
        curr = next;
27
    }
28
    beforeLeft.next = prev;   // prefix -> new head (old position right)
29
    subTail.next = curr;      // new tail -> suffix (node after right)
30
    return dummy.next;
31
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.31 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

E · Edge cases and pitfalls7left == 1 (reverse from head) — beforeLeft stays on the dummy; dummy.next is rewired to the new head, returned correctly.Explore edge cases

Edge cases handled

left == 1 (reverse from head)beforeLeft stays on the dummy; dummy.next is rewired to the new head, returned correctly.
left == rightGuarded up front — the function returns the list unchanged.
right == n (window reaches the tail)curr ends as null; subTail.next = null correctly terminates the list.

Pitfalls

Forgetting the dummy node — left = 1 then needs a separate code path.
Off-by-one on the walk: stopping ON position left instead of just before it.
Reversing right - left times instead of right - left + 1 (drops the last window node).
Capturing subTail after the reversal, when beforeLeft.next no longer points to it.

03.2

Approach 2 of 2 · Optimal

Head-Insertion — True One Pass

TimeO(n)SpaceO(1)

Offer for the explicit 'one pass' follow-up. Repeatedly move the node after curr to the front of the window — no separate reversal phase.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Keep curr fixed on the window's first node. Each step, take the node right after curr and splice it to the front of the window (just after prevLeft).

2Hint 2Explore hint

Doing that (right - left) times slides every later window node ahead of curr, which naturally leaves curr at the back — the window is reversed.

3Hint 3Explore hint

Three pointer assignments per step: detach curr.next, point it at prevLeft.next, then make it the new prevLeft.next.

A · Core idea

Head-insertion reverses the window without ever building it in isolation — it threads each node to the front as it goes, so the list stays connected the whole time.

One splice per step. On each iteration we grab nxt = curr.next, the node immediately after curr. Three assignments relocate it to the front of the window:

1
curr.next = nxt.next — unhook nxt, so curr now skips over it.
2
nxt.next = prevLeft.next — point nxt at the current front of the window.
3
prevLeft.next = nxt — make nxt the new front.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

head = [1,2,3,4,5], left = 2, right = 4

Interactive diagram

Picking the right approach

start

Active call / nodeSupporting contextReturned stateNot active

A dummy node plus a bounded reversal; head-insertion is the elegant one-pass variant.

Final result[1,4,3,2,5]

C · Code with teaching comments

solution.javaJava

Head-Insertion — True One Pass — optimal

6 teaching notes

1
public ListNode reverseBetween(ListNode head, int left, int right) {
2
    if (head == null || left == right) {
3
        return head;
4
    }
5
    ListNode dummy = new ListNode(0, head);
6
    // Anchor that always sits just before the window — dummy handles left = 1.
7
    ListNode prevLeft = dummy;
8
    for (int i = 0; i < left - 1; i++) {
9
        prevLeft = prevLeft.next;
10
    }
11
    ListNode curr = prevLeft.next; // stays put; later nodes move ahead of it
12
    for (int i = 0; i < right - left; i++) {
13
        // The node to relocate to the front of the window this step.
14
        ListNode nxt = curr.next;
15
        curr.next = nxt.next;        // detach nxt
16
        nxt.next = prevLeft.next;    // nxt points at current window head
17
        prevLeft.next = nxt;         // nxt becomes the new window head
18
    }
19
    return dummy.next;
20
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.20 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

ComplexityO(n) time, O(1) space — A single walk to prevLeft plus right - left splice operations, each O(1). One overall traversal → O(n) time, O(1) space with a constant number of pointers.

E · Edge cases and pitfalls7left == 1 — prevLeft is the dummy; the new head emerges as dummy.next, returned correctly.Explore edge cases

Edge cases handled

left == 1prevLeft is the dummy; the new head emerges as dummy.next, returned correctly.
left == rightLoop runs zero times; list unchanged.
window of two nodesOne splice swaps them; list stays valid throughout.

Pitfalls

Reordering the three splice lines — detach, then redirect, then re-anchor.
Looping right - left + 1 times instead of right - left (over-rotates the window).
Advancing curr each iteration — curr must stay fixed as the window's first node.
Skipping the dummy and special-casing left = 1.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Skipping the dummy node

When left = 1 the head itself changes. Without a dummy you must branch on 'is left 1?' and reattach the head manually — error-prone. A dummy makes 'the node before the window' always exist.

Explore the code comparison

Don't write this

// no dummy: must special-case left == 1
ListNode beforeLeft = head;
for (int i = 0; i < left - 2; i++) beforeLeft = beforeLeft.next;
// ...and separate logic when left == 1 to update head

Write this instead

ListNode dummy = new ListNode(0, head);
ListNode beforeLeft = dummy;
for (int i = 0; i < left - 1; i++) beforeLeft = beforeLeft.next;
// left == 1 needs no special case; return dummy.next

Forgetting to capture the sublist tail

Explore the code comparison

Don't write this

prev = None
curr = before_left.next
for _ in range(right - left + 1):
    nxt = curr.next; curr.next = prev; prev = curr; curr = nxt
before_left.next = prev
# forgot to connect the old sub-head to the suffix -> tail dangles

Write this instead

sub_tail = before_left.next   # capture BEFORE reversing
prev = None
curr = before_left.next
for _ in range(right - left + 1):
    nxt = curr.next; curr.next = prev; prev = curr; curr = nxt
before_left.next = prev
sub_tail.next = curr          # reattach the suffix

Wrong iteration count on the window

Explore the code comparison

Don't write this

# head-insertion but looping one too many times
for _ in range(right - left + 1):
    nxt = curr.next
    curr.next = nxt.next; nxt.next = prev_left.next; prev_left.next = nxt

Write this instead

# head-insertion: exactly right - left splices
for _ in range(right - left):
    nxt = curr.next
    curr.next = nxt.next; nxt.next = prev_left.next; prev_left.next = nxt

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Dummy node + bounded in-place sublist reversal

Code pattern to memorize

dummy -> head; prevLeft = dummy
advance prevLeft (left-1) times
# head-insertion, repeat (right-left) times:
curr = prevLeft.next
for _ in range(right - left):
    nxt = curr.next
    curr.next = nxt.next
    nxt.next = prevLeft.next
    prevLeft.next = nxt
return dummy.next

Rules to remember

1Use a dummy node in front of head so reversing from position 1 (left = 1) isn't a special case.
2Stop the leading walk at the node just before left (prevLeft) — you need it to re-link the reversed head.
3Positions are 1-indexed and the range [left, right] is inclusive.
4Re-link three boundaries: prevLeft → new sub-head, old sub-head (now sub-tail) → the node after right.
5It's a single pass in O(1) space — no second traversal and no extra list.

Use this pattern when

Reverse only a contiguous segment of a singly linked list
Any in-place pointer rewrite bounded by two positions
Problems that reverse a window then stitch it back (k-group, partial reversals)
When a dummy node simplifies head-adjacent edge cases

Choose another pattern when

You must reverse the WHOLE list → plain Reverse Linked List (no boundaries)
Reverse in fixed-size blocks repeatedly → Reverse Nodes in k-Group
You may not mutate the input → build a new list instead of rewiring pointers

Interview takeaway

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Reverse Linked List
The unbounded version — reverse the whole list with the prev/curr/next flip and no boundaries.
Reverse Nodes in k-Group
Reverse every consecutive block of k nodes — repeated bounded reversal stitched together.
Swap Nodes in Pairs
Coming soon
A k-group with k = 2 — reverse pairs using a dummy node and boundary relinking.
Reorder List
Find the middle, reverse the second half, then interleave — partial reversal is the core subroutine.

Same pattern

←

Palindrome Linked List

Continue · Next problem

Reverse Nodes in k-Group