Algorithm

Reverse Linked List

Linked List Pattern

Reverse Linked List

Given the head of a singly linked list, reverse it so the original last node becomes the head and every next pointer points the opposite way, then return the new head. Rewire the existing nodes in place — no new list is built. An empty list returns null; a single-node list returns itself unchanged.

CONSTRAINTS
  • The number of nodes in the list is in the range [0, 5000]
  • -5000 <= Node.val <= 5000
EXAMPLE 1
Input: head = [1,2,3,4,5]
Output: [5,4,3,2,1]
Every link is flipped, so the order is exactly reversed: the original tail 5 is now first and the original head 1 is now last.
EXAMPLE 2
Input: head = [1]
Output: [1]
A single node has nothing after it to reorder, so the reversed list is identical to the original.
EXAMPLE 3
Input: head = []
Output: []
An empty list has no nodes to reverse; the result is empty (null).
How should empty or single-node lists behave?
Both return unchanged — an empty list returns null, a one-node list returns that node. A correct pointer solution handles both automatically without special-casing them.
Am I reversing the actual nodes or just their values?
Reverse the nodes by rewiring next pointers; don't swap values. Pointer rewiring is O(1) per node, preserves node identity, and is the skill the problem is testing.
Is a recursive solution acceptable?
It's correct but uses O(N) stack space, one frame per node, which can overflow on long lists. The iterative three-pointer version is O(1) space and is the expected answer when memory matters.
Would a doubly linked list change the approach?
It makes reversal conceptually easier since each node already knows its predecessor, but the singly linked case — carrying prev yourself — is the standard interview version and the transferable technique.

We must reverse a singly linked list: the node that was last becomes the head, and every arrow that pointed forward now points backward. We want to do it in place — rewiring the existing nodes — rather than copying values into a fresh list.

Where the difficulty actually hides

"Make each node point to the one before it" sounds trivial until you notice the phrase the one before it. A singly linked list stores only forward arrows; a node has no idea who precedes it. So as we walk forward, we must carry the predecessor ourselves. And there is a sharper trap: the instant we flip a node's arrow to point back at its predecessor, we overwrite the very pointer that told us where the rest of the list was. Flip too early and the unvisited tail floats off, unreachable — the exact severed-chain failure warned about in Linked List Traversal. Every correct reversal comes down to one requirement: flip this link without losing the next one.

(Recursion, or an explicit stack, can dodge the manual bookkeeping — but both spend O(N) memory on frames or stack entries, and the whole point of this problem is the O(1)-space in-place version.)

The reframe: carry the reversed prefix behind you

Picture the walk with the list split in two: everything behind you is already reversed, everything ahead is still original. You hold the head of the reversed-so-far part in a pointer prev, and you stand on the next original node with curr. One step means: detach curr from the original chain and glue it onto the front of the reversed part. Do that N times and the whole list migrates, node by node, from "ahead, original" to "behind, reversed." prev always names the current head of the growing reversed portion — so when nothing remains ahead, prev is the head of the entire reversed list.

The mechanism: three pointers, four lines, order is everything

Each step needs three references: prev (head of the reversed part, starting at null — the reversed empty list), curr (current node), and a temporary next_temp (a cache of the rest, so flipping curr doesn't lose it).

python
prev = None
curr = head
while curr:
    next_temp = curr.next    # 1. SAVE the rest before we destroy the link
    curr.next = prev         # 2. FLIP: point current back at the reversed part
    prev = curr              # 3. the reversed part now starts at curr
    curr = next_temp         # 4. advance into the still-original tail
return prev                  # curr is null; prev is the new head
Crucial Noteline 1 must precede line 2, and that ordering is the problem. Line 2 overwrites curr.next — the only link to the unreversed tail. Without stashing it in next_temp first, that tail is lost the instant we flip, and the loop has nothing to advance into. Cache, then flip, then advance both pointers: that four-line dance, in that order, is reversal.

Why does returning prev give the right head? When the loop ends, curr has walked off the end and is null, while prev holds the node we flipped most recently — the original last node. Every node's arrow now points at its original predecessor, so the original tail, now first, is exactly prev.

Worked Example:[1, 2, 3]
- Start: prev = null, curr = 1.
- Step: next_temp = 2; flip 1 → null; prev = 1; curr = 2. Reversed part: 1.
- Step: next_temp = 3; flip 2 → 1; prev = 2; curr = 3. Reversed part: 2 → 1.
- Step: next_temp = null; flip 3 → 2; prev = 3; curr = null. Reversed part: 3 → 2 → 1.
- curr is null: stop, return prev = 3. Result: 3 → 2 → 1.

And the empty list: curr = head = null, the loop body never runs, we return prev = null — correct, with no special case.

The reversal skeleton, extracted

Strip this problem away and a reusable unit remains: walk a chain while re-pointing each node at the node behind it, held together by the cache-flip-advance order. You will reuse it unchanged as an inner routine — reverse the second half of a list to test a palindrome, reverse a fixed block in Reverse Nodes in k-Group, reverse a sublist between two positions. Three things stay constant every time (the prev/curr/next_temp trio, cache-before-flip, return prev) and only two vary per problem: where the reversal starts and when it stops (the whole list, a group of k, up to a boundary node). Fill those two slots and the rest is this same dance.

What it costs

One pass, a fixed set of pointers: O(N) time, O(1) space — beating the recursive version's O(N) call stack. Train the reflex: whenever a linked-list task needs the nodes in reverse, or needs to compare the front against the back (which a forward-only list cannot do directly), reach for this in-place reversal instead of copying into an array.

Interactive Strategy Visualization

Iterative Reversal

Strategy: 3-Pointer Window
Efficiency: O(1) Space
CURR1NEXT23
Operationprev = null, curr = head
Memory [prev]
null
1. Initialization
Pointers set: 'curr' at head, 'prev' is null.
O(N) Time · O(N) Space Recursion/Stack
→
O(N) Time · O(1) Space Three-Pointer Rewire