Linked List Reversal

The Intuition

You have a chain of paper clips linked together. You want to reverse the chain. Here's what you do: hold the first clip, unhook it from the second, and set it aside to start a new chain. Now pick up the second clip, unhook it from the third, and attach it before the first clip in your new chain. Keep going. Every clip you detach gets placed at the front of the new chain.

When you're done, the clip you picked up last is at the front, and the clip you picked up first is at the back. Reversed.

In code, you need three pointers to pull this off. current is the clip you're about to detach. prev is the growing reversed chain behind you. And you need to save next before you break the link, because once you point current.next to prev, you've lost your reference to the rest of the original chain. Save it, break it, move on. That's the entire loop: save next, reverse the pointer, advance both prev and current one step forward.

When to use

Reversing entire or partial linked lists, checking palindromes, reordering nodes, or any problem requiring reversed traversal of a singly linked list.

When NOT to use

Need random access by index (use array)
Need to reverse based on values not position (use sorting)
Circular linked list without clear start/end

Pattern Recognition

reverse a portionpalindrome linked list

Edge Cases

empty list
single node
two nodes

Practice Problems

EasyReverse Linked List

MediumReverse Linked List II

EasyPalindrome Linked List

HardReverse Nodes in k-Group

Key Points

•Use three pointers: prev, current, next
•Save next before breaking the link
•Iterative approach is preferred for O(1) space
•For partial reversal, track the node before the segment
•Recursive approach uses O(n) call stack space

Code Template

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def reverse_list(head):
    """Reverse entire linked list iteratively."""
    prev = None
    current = head
    while current:
        next_node = current.next
        current.next = prev
        prev = current
        current = next_node
    return prev

def reverse_between(head, left, right):
    """Reverse nodes from position left to right (1-indexed)."""
    dummy = ListNode(0, head)
    prev = dummy
    for _ in range(left - 1):
        prev = prev.next

    current = prev.next
    for _ in range(right - left):
        next_node = current.next
        current.next = next_node.next
        next_node.next = prev.next
        prev.next = next_node

    return dummy.next

type ListNode struct {
    Val  int
    Next *ListNode
}

func reverseList(head *ListNode) *ListNode {
    // Reverse entire linked list iteratively.
    var prev *ListNode
    current := head
    for current != nil {
        next := current.Next
        current.Next = prev
        prev = current
        current = next
    }
    return prev
}

func reverseBetween(head *ListNode, left, right int) *ListNode {
    // Reverse nodes from position left to right (1-indexed).
    dummy := &ListNode{Next: head}
    prev := dummy
    for i := 0; i < left-1; i++ {
        prev = prev.Next
    }

    current := prev.Next
    for i := 0; i < right-left; i++ {
        next := current.Next
        current.Next = next.Next
        next.Next = prev.Next
        prev.Next = next
    }
    return dummy.Next
}

public ListNode reverseList(ListNode head) {
    // Reverse entire linked list iteratively.
    ListNode prev = null;
    ListNode current = head;
    while (current != null) {
        ListNode next = current.next;
        current.next = prev;
        prev = current;
        current = next;
    }
    return prev;
}

public ListNode reverseBetween(ListNode head,
                                int left, int right) {
    // Reverse nodes from position left to right (1-indexed).
    ListNode dummy = new ListNode(0, head);
    ListNode prev = dummy;
    for (int i = 0; i < left - 1; i++) {
        prev = prev.next;
    }

    ListNode current = prev.next;
    for (int i = 0; i < right - left; i++) {
        ListNode next = current.next;
        current.next = next.next;
        next.next = prev.next;
        prev.next = next;
    }
    return dummy.next;
}

Common Mistakes

Losing reference to the next node before reassigning
Not returning the new head (previously the tail)
Off-by-one when reversing a sub-section of the list

Related Patterns

CrackingWalnuts

Linked ListsTemplate 1 of 2

Linked ListBasicO(n) time, O(1) space