Reverse a Linked List: Python and TypeScript, Explained

The Reverse a Linked List Problem

You are given the head of a singly linked list, where each node holds a value and a pointer to the next node. Reverse the list in place and return the new head. You should not create new nodes or copy the values into an array and back; the point of the exercise is to rewire the pointers.

Example 1

Input: 1 → 2 → 3 → 4 → 5
Output: 5 → 4 → 3 → 2 → 1
Why: every arrow now points the other way, and the old tail is the new head.

Example 2

Input: an empty list (head is null)
Output: null
Why: there is nothing to reverse. A one-node list also comes back unchanged.

Assumptions to confirm

• Is it singly linked? (Assume yes. A doubly linked list needs you to swap both pointers on every node.)
• May I modify the list in place? (Usually yes, and that is what makes O(1) space possible.)
• Does the interviewer want iterative, recursive, or both? (Offer iterative first and mention recursion.)

Start With the Brute Force

The simplest working idea is to copy every value into an array, then walk the list again and write the values back in reverse order. It is O(n) time but O(n) extra space, and it changes values rather than structure, which many interviewers will not accept as a reversal.

Mention it in one sentence, then explain why you want better: the list already has all the links you need, and each one only has to be pointed the other way. That needs a constant number of pointers, not a copy of the list.

The Optimal Approach: Iterative Pointer Reversal

Reverse a Linked List in Python and TypeScript

The iterative version is the expected answer. The recursive version is a common follow-up, so it is shown too.

Python

from typing import Optional


class ListNode:
    def __init__(self, val: int = 0, next: "Optional[ListNode]" = None):
        self.val = val
        self.next = next


def reverse_list(head: Optional[ListNode]) -> Optional[ListNode]:
    prev = None
    curr = head
    while curr:
        nxt = curr.next   # remember the rest of the list
        curr.next = prev  # point this node backwards
        prev = curr
        curr = nxt
    return prev


def reverse_list_recursive(head: Optional[ListNode]) -> Optional[ListNode]:
    if head is None or head.next is None:
        return head
    new_head = reverse_list_recursive(head.next)
    head.next.next = head
    head.next = None
    return new_head

TypeScript

class ListNode {
  val: number;
  next: ListNode | null;
  constructor(val = 0, next: ListNode | null = null) {
    this.val = val;
    this.next = next;
  }
}

function reverseList(head: ListNode | null): ListNode | null {
  let prev: ListNode | null = null;
  let curr = head;
  while (curr) {
    const next = curr.next; // remember the rest of the list
    curr.next = prev;       // point this node backwards
    prev = curr;
    curr = next;
  }
  return prev;
}

function reverseListRecursive(head: ListNode | null): ListNode | null {
  if (!head || !head.next) return head;
  const newHead = reverseListRecursive(head.next);
  head.next.next = head;
  head.next = null;
  return newHead;
}

The recursive version reverses everything after the head, then hooks the head onto the end: head.next.next = head makes the old second node point back at the head, and head.next = null stops it pointing forward. It is elegant, but it uses O(n) call-stack space and can overflow on very long lists.

Time and Space Complexity

How to Talk Through It in an Interview

1. Clarify: "Singly linked? In place is fine? Should I handle an empty list?"
2. Brute force: "I could copy the values into an array and write them back reversed, but that is O(n) space and only moves values."
3. Optimise: "Each link just needs to point the other way. If I walk the list with a previous and a current pointer, I can flip one link per step, using O(1) space."
4. Code: say "save next first" out loud before you overwrite the pointer. It is the most common bug, and naming it shows you have seen it.
5. Test: draw 1 → 2 → 3 and move the three pointers through each step, then check null and a single node.

Drawing the boxes and arrows while you talk, even in a comment, makes pointer problems much easier for the interviewer to follow.

Edge Cases and Common Follow-Ups

Practise linked list reversal in a Mock Coding Round

Reading a solution is not the same as producing one with someone listening. The gap shows up as long silences, a jump straight to code without a brute force, or a bug you only spot after the interviewer asks you to test. The fix is to rehearse problems like linked list reversal out loud, under time pressure, while explaining each decision.

MockIF runs mock coding interviews with a voice AI interviewer in a real in-browser editor, in Python and TypeScript. It runs your code against tests, asks you to explain your approach, adds follow-up questions the way a real interviewer would, and then scores your answer and gives specific feedback. Each session costs 2 credits. It is free to start with 5 credits, then monthly or 3-monthly plans, or one-off credit packs (see pricing).

Frequently Asked Questions