Reverse a Linked List

Before we start

Reversing a linked list is the single most tested linked list operation in interviews. It also appears as a sub-step inside palindrome checking, reorder list, and k-group reversal. Get this so automatic that you can write it without thinking — then the harder problems become tractable. By the end you will be able to:

• Write the full reversal from memory, correctly, in under 60 seconds.
• Trace the three-pointer dance node by node on any example.
• Handle the partial reversal (reverse positions m to n) by extending the same skeleton.

Picture this first (no code yet)

First, the slow way (so you feel the pain)

You could copy all node values into an array, reverse the array, then copy values back. O(n) time — but O(n) space for the array. For a linked list of 10 million nodes, that is 40–80 MB of extra memory just to flip directions. The three-pointer approach uses O(1) extra space — just three pointer variables, no matter how long the list.

The turning point

The one idea to remember

The code, line by line

def reverseList(head):
    prev = None      # the node that current should now point to
    curr = head      # the node we are currently processing

    while curr:
        nxt       = curr.next   # ① save next (don't lose the rest of the list)
        curr.next = prev        # ② reverse the pointer
        prev      = curr        # ③ advance prev
        curr      = nxt         # ④ advance curr

    return prev      # curr is None; prev is the new head

Four lines inside the loop. Commit them as a sequence: save, reverse, advance-prev, advance-curr.

Watch it happen, frame by frame

List: 1 → 2 → 3 → 4 → 5

Initial: prev=None, curr=1

Iteration 1:
  nxt       = 2
  curr.next = None   →   1 → None
  prev      = 1
  curr      = 2

  State: None ← 1    2 → 3 → 4 → 5

Iteration 2:
  nxt       = 3
  curr.next = 1      →   2 → 1 → None
  prev      = 2
  curr      = 3

  State: None ← 1 ← 2    3 → 4 → 5

Iteration 3:
  nxt       = 4
  curr.next = 2      →   3 → 2 → 1 → None
  prev      = 3
  curr      = 4

Iteration 4:
  nxt       = 5
  curr.next = 3
  prev      = 4
  curr      = 5

Iteration 5:
  nxt       = None
  curr.next = 4
  prev      = 5
  curr      = None

While exits (curr = None).
Return prev = 5.

Final: 5 → 4 → 3 → 2 → 1 → None  ✅

Recursive version (for completeness)

def reverseList_recursive(head):
    if not head or not head.next:
        return head                       # base case: 0 or 1 node

    new_head = reverseList_recursive(head.next)   # reverse the rest
    head.next.next = head                # the node after head should point back to head
    head.next      = None                # head no longer points forward
    return new_head                      # new head is unchanged throughout recursion

The recursive version uses O(n) stack space — avoid it for very long lists. Iterative is O(1) space and preferred in interviews.

Variant: Reverse Linked List II — positions m to n (LC #92)

Reverse only the nodes from position m to position n (1-indexed).

1 → 2 → 3 → 4 → 5,  m=2, n=4   →   1 → 4 → 3 → 2 → 5

The approach: walk to position m−1 (call it tail_before), then perform a standard reversal for n − m + 1 nodes, then reconnect.

def reverseBetween(head, m: int, n: int):
    dummy      = ListNode(0)     # dummy makes edge cases (m=1) uniform
    dummy.next = head
    prev       = dummy

    # Step 1: walk to the node just before position m
    for _ in range(m - 1):
        prev = prev.next
    # prev is now at position m-1

    # Step 2: reverse n-m+1 nodes starting at position m
    curr = prev.next   # this is the node at position m
    for _ in range(n - m):
        nxt        = curr.next
        curr.next  = nxt.next   # remove nxt from its current position
        nxt.next   = prev.next  # wire nxt to the front of the reversed section
        prev.next  = nxt        # update prev to point to nxt (new front)

    return dummy.next

Frame-by-frame: 1 → 2 → 3 → 4 → 5, m=2, n=4

After walk: prev=node1, curr=node2

Iteration 1 (move node3 to front of sublist):
  nxt       = node3
  curr.next = node4   →   sublist so far: node2 → node4 → node5
  nxt.next  = node2   →   node3 → node2 → node4 → node5
  prev.next = node3   →   node1 → node3 → node2 → node4 → node5

Iteration 2 (move node4 to front of sublist):
  nxt       = node4
  curr.next = node5   →   sublist: node2 → node5
  nxt.next  = node3   →   node4 → node3 → node2 → node5
  prev.next = node4   →   node1 → node4 → node3 → node2 → node5

Done. Answer: 1 → 4 → 3 → 2 → 5  ✅

Where to spot this pattern

Trigger words:

• "reverse a linked list" (full or partial)
• "reverse nodes in k-group" (Variant: reverse every k nodes — LC #25)
• "palindrome linked list" — step 2 is a reversal
• "reorder list" — step 2 is a reversal of the second half

Common traps

prev, curr = None, head
while curr:
    nxt       = curr.next   # ① save
    curr.next = prev        # ② flip
    prev      = curr        # ③ advance prev
    curr      = nxt         # ④ advance curr
return prev                 # new head

# walk to position m-1 (prev), curr = node at m
for _ in range(n - m):
    nxt       = curr.next
    curr.next = nxt.next    # skip nxt in chain
    nxt.next  = prev.next   # wire nxt to front
    prev.next = nxt         # update entry point

Check yourself

Practice problems

Next up: Merge Two Sorted Lists — the compare-heads, pick-smaller, advance-pointer dance that is the merge step in merge sort and the foundation for Merge K Sorted Lists.