Reverse Linked List

Reverse a singly linked list in place. Walk the list with three pointers: save next, point curr.next back at prev, then step both forward. When curr falls off the end, prev is the new head.

Traced input: head = [1, 2, 3, 4, 5] → [5, 4, 3, 2, 1]. Original problem: neetcode.io/problems/reverse-a-linked-list

Complexity

Each node's pointer is flipped once.

Key idea

• Everything before curr is already reversed and starts at prev.
• Save curr.next before overwriting it, or the rest of the list is lost.
• The loop ends with curr == null; return prev.
• The recursive version is elegant but uses O(n) stack.

Common mistakes

• Overwriting curr.next before saving it.
• Returning head (now the tail) instead of prev.
• Forgetting that the old head's next must become null.

Solution

ListNode reverseList(ListNode head) {
    ListNode prev = null, curr = head;
    while (curr != null) {
        ListNode next = curr.next;
        curr.next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

def reverseList(head: Optional[ListNode]) -> Optional[ListNode]:
    prev, curr = None, head
    while curr:
        nxt = curr.next
        curr.next = prev
        prev = curr
        curr = nxt
    return prev

ListNode* reverseList(ListNode* head) {
    ListNode *prev = nullptr, *curr = head;
    while (curr) {
        ListNode* next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

Edge cases

Each one has its own trace in the interactive view.