Reversing a Linked List

Reversing a singly linked list in place is the most-asked linked-list problem. Get it right and the rest of the section follows.

Iterative reversal

Walk the list with three pointers: $prev$, $curr$, $next$. At each step: save $curr.next$ into $next$, point $curr.next$ to $prev$, advance $prev$ to $curr$, advance $curr$ to $next$. When $curr$ is null, $prev$ is the new head. $O(n)$ time, $O(1)$ space.

Recursive reversal

Recursively reverse the rest of the list, then point the next node's $next$ back to the current node and current's $next$ to null. Elegant but uses $O(n)$ stack space — usually preferred only for whiteboard clarity, not production code.

Reverse a sublist (positions $m$ to $n$)

Walk to position $m-1$, save that as the anchor, then perform an in-place reversal of the next $n - m + 1$ nodes, then splice the reversed segment back. Easy to get the boundary cases wrong — use a dummy head sentinel.

Reverse in groups of $k$

Walk the list, take $k$ nodes at a time, reverse them, splice. If fewer than $k$ remain at the tail, leave them as-is. Combines reversal with careful boundary handling.

Why these problems matter

Reversal forces you to manipulate raw pointers correctly under pressure. Almost every harder linked-list problem (palindrome check, merge sort on a list, even/odd separation) reduces to "reverse a segment" or "reverse + compare." Drill until you can write the four-line iterative version without looking.