Reverse a Singly Linked List Iterative in DSA Typescript

Mental Model

We change the direction of each link in the list one by one until the whole list points backward.

Analogy: Imagine a line of people holding hands forward. We ask each person to turn around and hold the hand of the person behind them instead, one at a time.

head -> 1 -> 2 -> 3 -> null

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> null

Goal: Reverse the list so it becomes 3 -> 2 -> 1 -> null

Step 1: Start with prev = null, curr = 1 (head)

prev = null, curr = 1 -> 2 -> 3 -> null

Why: We need prev to keep track of reversed part and curr to traverse the list

Step 2: Save next = 2, change curr.next to prev (null), move prev to curr (1), curr to next (2)

1 -> null, prev = 1 -> null, curr = 2 -> 3 -> null

Why: Reverse first link and move forward

Step 3: Save next = 3, change curr.next to prev (1), move prev to curr (2), curr to next (3)

2 -> 1 -> null, prev = 2 -> 1 -> null, curr = 3 -> null

Why: Reverse second link and move forward

Step 4: Save next = null, change curr.next to prev (2), move prev to curr (3), curr to next (null)

3 -> 2 -> 1 -> null, prev = 3 -> 2 -> 1 -> null, curr = null

Why: Reverse last link; curr is now null, so stop

Result:

3 -> 2 -> 1 -> null

Annotated Code

DSA Typescript

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

function reverseList(head: ListNode | null): ListNode | null {
  let prev: ListNode | null = null;
  let curr: ListNode | null = head;
  while (curr !== null) {
    const next: ListNode | null = curr.next; // save next node
    curr.next = prev; // reverse current node's pointer
    prev = curr; // move prev forward
    curr = next; // move curr forward
  }
  return prev; // new head
}

// Driver code to test
const node3 = new ListNode(3);
const node2 = new ListNode(2, node3);
const node1 = new ListNode(1, node2);

const reversedHead = reverseList(node1);

// Print reversed list
let curr = reversedHead;
let output = '';
while (curr !== null) {
  output += curr.val + ' -> ';
  curr = curr.next;
}
output += 'null';
console.log(output);

while (curr !== null) {

loop until we reach the end of the list

const next: ListNode | null = curr.next; // save next node

keep next node safe before changing pointer

curr.next = prev; // reverse current node's pointer

reverse the link of current node to previous node

prev = curr; // move prev forward

advance prev to current node to build reversed list

curr = next; // move curr forward

advance curr to next node to continue traversal

return prev; // new head

prev is new head after full reversal

Output

3 -> 2 -> 1 -> null

Complexity Analysis

Time: O(n) because we visit each node once to reverse links

Space: O(1) because we only use a few pointers, no extra list

vs Alternative: Compared to recursive reversal which uses O(n) stack space, iterative is more space efficient

Edge Cases

empty list (head = null)

function returns null immediately without error

DSA Typescript

while (curr !== null) {

single node list

returns the same single node as reversed list

DSA Typescript

while (curr !== null) {

When to Use This Pattern

When you see a problem asking to reverse a linked list or reverse pointers, reach for the iterative reversal pattern because it efficiently reverses links in one pass.

Common Mistakes

Mistake: Not saving the next node before reversing the pointer, causing loss of the rest of the list
Fix: Always save curr.next in a temporary variable before changing curr.next

Mistake: Returning the original head instead of the new head after reversal
Fix: Return prev pointer after the loop ends, as it points to the new head

Summary

Reverses the direction of a singly linked list by changing each node's next pointer.

Use when you need to reverse the order of nodes in a singly linked list efficiently.

The key is to keep track of previous, current, and next nodes to reverse links safely.

Practice

1. What is the main purpose of reversing a singly linked list iteratively?

easy

A. To sort the linked list in ascending order

B. To change the direction of the links between nodes without using recursion

C. To delete all nodes from the linked list

D. To find the middle node of the linked list

Solution

1. Step 1: Understand the operation of reversing

   Reversing a singly linked list means changing the direction of the next pointers so the last node becomes the first.

2. Step 2: Identify iterative approach

   The iterative method changes links step-by-step using a loop without recursion.

3. Final Answer:

   To change the direction of the links between nodes without using recursion -> Option B

4. Quick Check:

   Reversing iteratively = changing links direction without recursion [OK]

Hint: Reversing means flipping links, not sorting or deleting [OK]

Common Mistakes:

• Confusing reversing with sorting
• Thinking recursion is required
• Assuming nodes are deleted

2. Which of the following TypeScript code snippets correctly initializes pointers for iterative reversal of a singly linked list?

easy

A. let prev = null; let current = head;

B. let prev = head; let current = null;

C. let prev = head; let current = head.next;

D. let prev = null; let current = null;

Solution

1. Step 1: Understand pointer roles

   Prev starts as null because the new tail points to null; current starts at head to traverse.

2. Step 2: Match initialization

   Only let prev = null; let current = head; sets prev to null and current to head correctly for iteration.

3. Final Answer:

   let prev = null; let current = head; -> Option A

4. Quick Check:

   Prev null, current head = correct start [OK]

Hint: Prev starts null, current starts at head for iteration [OK]

Common Mistakes:

• Setting prev to head initially
• Starting current as null
• Both pointers null at start

3. Given the linked list: 1 -> 2 -> 3 -> null, what will be the output after running this iterative reversal code?

function reverseList(head: ListNode | null): ListNode | null {
  let prev = null;
  let current = head;
  while (current !== null) {
    let nextTemp = current.next;
    current.next = prev;
    prev = current;
    current = nextTemp;
  }
  return prev;
}

medium

A. null

B. 1 -> 2 -> 3 -> null

C. 3 -> 2 -> 1 -> null

D. 1 -> null

Solution

1. Step 1: Trace the reversal loop

   Initially prev=null, current=1. Each iteration reverses current.next to prev and moves pointers forward.

2. Step 2: Final reversed list

   After loop, prev points to node 3, which links to 2, then 1, then null.

3. Final Answer:

   3 -> 2 -> 1 -> null -> Option C

4. Quick Check:

   Reversed list = 3 -> 2 -> 1 -> null [OK]

Hint: Follow pointers step-by-step to see reversed links [OK]

Common Mistakes:

• Returning head instead of prev
• Not updating current correctly
• Confusing next pointer updates

4. Identify the error in this iterative reversal code snippet:

function reverseList(head: ListNode | null): ListNode | null {
  let prev = head;
  let current = head.next;
  while (current !== null) {
    let nextTemp = current.next;
    current.next = prev;
    prev = current;
    current = nextTemp;
  }
  return prev;
}

medium

A. current should start at head, not head.next

B. The function should return current instead of prev

C. nextTemp should be assigned after updating current.next

D. prev should be initialized to null, not head

Solution

1. Step 1: Check pointer initialization

   Prev must start as null because the new tail points to null, not head.

2. Step 2: Understand impact of wrong initialization

   Starting prev at head causes a cycle or incorrect reversal.

3. Final Answer:

   prev should be initialized to null, not head -> Option D

4. Quick Check:

   Prev must be null at start [OK]

Hint: Prev always null at start to avoid cycles [OK]

Common Mistakes:

• Starting prev at head causing loops
• Starting current at wrong node
• Returning wrong pointer

5. You have a singly linked list with nodes containing values: 10 -> 20 -> 30 -> 40 -> null. After reversing it iteratively, you want to insert a new node with value 25 between 20 and 30 in the reversed list. What will be the correct order of nodes after insertion?

hard

A. 40 -> 30 -> 25 -> 20 -> 10 -> null

B. 40 -> 30 -> 20 -> 25 -> 10 -> null

C. 40 -> 30 -> 20 -> 10 -> 25 -> null

D. 40 -> 25 -> 30 -> 20 -> 10 -> null

Solution

1. Step 1: Reverse the original list

   Original: 10 -> 20 -> 30 -> 40 -> null reversed becomes 40 -> 30 -> 20 -> 10 -> null.

2. Step 2: Insert 25 between 30 and 20

   In reversed list, 30 points to 20, so insert 25 after 30: 30 -> 25 -> 20.

3. Step 3: Final list order

   40 -> 30 -> 25 -> 20 -> 10 -> null.

4. Final Answer:

   40 -> 30 -> 25 -> 20 -> 10 -> null -> Option A

5. Quick Check:

   Insert between 30 and 20 in reversed list = 40->30->25->20->10 [OK]

Hint: Reverse first, then insert at correct reversed position [OK]

Common Mistakes:

• Inserting 25 between wrong nodes after reversal
• Confusing original and reversed order
• Not updating next pointers correctly