Reverse a Singly Linked List Iterative in DSA Javascript

Mental Model

We change the direction of each link in the list one by one, so the last node becomes the first.

Analogy: Imagine walking backward on a path by turning around at each step, so you end up facing the start instead of the end.

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: Initialize prev as null and curr at head (node 1)

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

Why: We start with no previous node and current at the first node to begin reversing links

Step 2: Save next node (2), reverse curr's pointer to prev (null), move prev to curr (1), curr to next (2)

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

Why: We reverse the first link and move forward to continue reversing

Step 3: Save next node (3), reverse curr's pointer to prev (1), move prev to curr (2), curr to next (3)

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

Why: We reverse the second link and move forward

Step 4: Save next node (null), reverse curr's pointer to prev (2), move prev to curr (3), curr to next (null)

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

Why: We reverse the last link; curr is now null, so reversal is complete

Result:

3 -> 2 -> 1 -> null

Annotated Code

DSA Javascript

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

function reverseList(head) {
  let prev = null;
  let curr = head;
  while (curr !== null) {
    const nextTemp = curr.next; // save next node
    curr.next = prev;          // reverse pointer
    prev = curr;               // move prev forward
    curr = nextTemp;           // move curr forward
  }
  return prev; // new head
}

// Driver code
const head = new ListNode(1, new ListNode(2, new ListNode(3)));
const reversedHead = reverseList(head);

// 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) {

continue reversing until we reach the end of the list

const nextTemp = curr.next; // save next node

store next node to not lose track after reversing

curr.next = prev; // reverse pointer

reverse current node's pointer to previous node

prev = curr; // move prev forward

advance prev to current node for next iteration

curr = nextTemp; // 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 its pointer

Space: O(1) because we only use a few extra variables regardless of list size

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

Edge Cases

empty list (head is null)

function returns null immediately, no reversal needed

DSA Javascript

while (curr !== null) {

single node list

pointer reversal does nothing visible, returns the same single node

DSA Javascript

while (curr !== null) {

When to Use This Pattern

When you need to reverse the order of nodes in a singly linked list, use the iterative reversal pattern by changing pointers step-by-step.

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 after the loop finishes, 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 want to invert 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 does reversing a singly linked list iteratively mean?
head -> 1 -> 2 -> 3 -> null becomes?

easy

A. head -> 3 -> 2 -> 1 -> null

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

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

D. head -> 2 -> 3 -> 1 -> null

Solution

1. Step 1: Understand the linked list order

   The original list goes from 1 to 3 in order: 1 -> 2 -> 3 -> null.

2. Step 2: Reverse the pointers iteratively

   Reversing means the last node becomes first, so the list becomes 3 -> 2 -> 1 -> null.

3. Final Answer:

   head -> 3 -> 2 -> 1 -> null -> Option A

4. Quick Check:

   Reverse order = head -> 3 -> 2 -> 1 -> null [OK]

Hint: Reversing flips the list order completely [OK]

Common Mistakes:

• Thinking the list stays the same after reverse
• Confusing node values with pointers
• Assuming null moves to front

2. Which of the following is the correct way to initialize pointers for iterative reversal of a singly linked list in JavaScript?

easy

A. let prev = null, current = null;

B. let prev = head, current = null;

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

D. let prev = null, current = head;

Solution

1. Step 1: Initialize previous pointer to null

   Before reversal, previous node is null because head has no previous.

2. Step 2: Initialize current pointer to head

   Current starts at head to traverse the list.

3. Final Answer:

   let prev = null, current = head; -> Option D

4. Quick Check:

   Start prev=null, current=head [OK]

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

Common Mistakes:

• Setting prev to head initially
• Setting current to null at start
• Swapping initialization order

3. What is the output of the following code?

class Node {
  constructor(val) {
    this.val = val;
    this.next = null;
  }
}

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

// Create list: 1 -> 2 -> 3 -> null
let head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);

let reversedHead = reverseList(head);

let result = [];
let node = reversedHead;
while (node) {
  result.push(node.val);
  node = node.next;
}
console.log(result);

medium

A. []

B. [3, 2, 1]

C. [null]

D. [1, 2, 3]

Solution

1. Step 1: Trace reversal loop

   Each iteration reverses the next pointer: 1->2->3 becomes 3->2->1.

2. Step 2: Collect values from reversed list

   After reversal, traversing from prev (new head) gives values 3, 2, 1.

3. Final Answer:

   [3, 2, 1] -> Option B

4. Quick Check:

   Reversed list values = [3, 2, 1] [OK]

Hint: Reversed list values appear in reverse order [OK]

Common Mistakes:

• Returning original head instead of prev
• Not updating current pointer correctly
• Collecting values before reversal

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

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

medium

A. head.next should not be set to null

B. current should start as head, not head.next

C. prev should start as null, not head

D. nextTemp should be assigned after changing current.next

Solution

1. Step 1: Check initial pointer setup

   prev must start as null because head has no previous node before reversal.

2. Step 2: Understand impact of wrong prev initialization

   Starting prev as head causes a cycle or incorrect links during reversal.

3. Final Answer:

   prev should start as null, not head -> Option C

4. Quick Check:

   prev=null start fixes reversal [OK]

Hint: Prev must start null to avoid cycles [OK]

Common Mistakes:

• Starting prev at head causing loops
• Not setting head.next to null after reversal
• Changing nextTemp after modifying current.next

5. Given a singly linked list with nodes containing values 1 -> 2 -> 3 -> 4 -> 5 -> null, write an iterative function to reverse only the first 3 nodes. What will be the list after reversal?

hard

A. 3 -> 2 -> 1 -> 4 -> 5 -> null

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

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

D. 1 -> 2 -> 3 -> 4 -> 5 -> null

Solution

1. Step 1: Reverse first 3 nodes iteratively

   Reverse nodes 1, 2, 3 to get 3 -> 2 -> 1.

2. Step 2: Connect reversed part to remaining list

   Node 1 (now last in reversed part) points to node 4, preserving rest of list.

3. Final Answer:

   3 -> 2 -> 1 -> 4 -> 5 -> null -> Option A

4. Quick Check:

   Partial reversal keeps rest intact [OK]

Hint: Reverse only first k nodes, link rest after [OK]

Common Mistakes:

• Reversing entire list instead of first 3 nodes
• Not reconnecting reversed part to rest
• Breaking list by losing tail connections