Reverse a Singly Linked List Iterative in DSA Javascript - Deep Dive

Overview - Reverse a Singly Linked List Iterative

What is it?

Reversing a singly linked list iteratively means changing the direction of the links between nodes so that the last node becomes the first. Instead of using extra memory or recursion, this method uses a simple loop to rearrange the pointers. Each node's next pointer is changed to point to the previous node until the entire list is reversed. This process transforms the list order without creating new nodes.

Why it matters

Without reversing a linked list, many problems involving backward traversal or reordering become difficult or inefficient. Reversing helps in tasks like undo operations, palindrome checks, or rearranging data streams. If this concept didn't exist, programmers would need extra memory or complex methods to process lists backward, making software slower and more resource-heavy.

Where it fits

Before learning this, you should understand what a singly linked list is and how to traverse it. After mastering iterative reversal, you can explore recursive reversal methods, doubly linked lists, and advanced linked list manipulations like cycle detection or merging sorted lists.

Mental Model

Core Idea

Reversing a singly linked list iteratively means walking through the list once and flipping each node's pointer to point backward instead of forward.

Think of it like...

Imagine a line of people holding hands forward. Reversing the list is like asking each person to let go of the hand in front and hold the hand behind instead, so the line faces the opposite direction.

Original List:
head -> [1] -> [2] -> [3] -> [4] -> null

Step-by-step reversal:
prev = null, current = head

Iteration 1:
current = [1], next = [2]
[1].next = prev (null)
prev = [1]
current = [2]

Iteration 2:
current = [2], next = [3]
[2].next = prev ([1])
prev = [2]
current = [3]

Iteration 3:
current = [3], next = [4]
[3].next = prev ([2])
prev = [3]
current = [4]

Iteration 4:
current = [4], next = null
[4].next = prev ([3])
prev = [4]
current = null

Result:
head -> [4] -> [3] -> [2] -> [1] -> null

Build-Up - 7 Steps

1

Foundation

Understanding Singly Linked List Structure

Concept: Learn what a singly linked list is and how nodes connect using pointers.

A singly linked list is a chain of nodes where each node holds data and a pointer to the next node. The last node points to null, marking the end. You can only move forward by following these pointers from the head node.

Result

You can visualize a list like: head -> [data|next] -> [data|next] -> ... -> null

Understanding the one-way connection between nodes is crucial because reversing means changing these connections carefully without losing access to the list.

2

Foundation

Traversing a Singly Linked List

Concept: Learn how to move through the list node by node using a loop.

Start at the head node. While the current node is not null, process the node's data and move to the next node using the pointer. This simple loop lets you visit every node in order.

Result

You can print or access all nodes in sequence: 1 -> 2 -> 3 -> 4 -> null

Mastering traversal is key because reversal depends on visiting each node and changing its pointer.

3

Intermediate

Reversing Pointers Step-by-Step

🤔Before reading on: do you think you need extra memory to reverse a singly linked list iteratively? Commit to yes or no.

Concept: Change each node's next pointer to point to the previous node while moving forward through the list.

Use three variables: prev (starts null), current (starts at head), and next (to store current.next). For each node, save next, point current.next to prev, then move prev and current forward. Repeat until current is null.

Result

The list pointers are flipped, so the last node becomes the new head, and the list order is reversed.

Knowing you can reverse the list in one pass without extra memory shows the power of pointer manipulation.

4

Intermediate

Implementing Iterative Reversal in JavaScript

🤔Before reading on: do you think the head pointer changes during reversal or stays the same? Commit to your answer.

Concept: Write code that uses a loop and pointer variables to reverse the list and update the head to the new first node.

function reverseList(head) { let prev = null; let current = head; while (current !== null) { let next = current.next; current.next = prev; prev = current; current = next; } return prev; // new head } // Example usage: // Input: 1 -> 2 -> 3 -> null // Output: 3 -> 2 -> 1 -> null

Result

The function returns the new head node of the reversed list.

Understanding that the head must be updated to the last processed node prevents losing the list after reversal.

5

Intermediate

Dry Run with Sample List

🤔Before reading on: after reversing 1->2->3->null, what is the new head's value? Commit to your answer.

Concept: Manually trace the reversal process on a small list to see pointer changes clearly.

Start: head = [1] -> [2] -> [3] -> null Iteration 1: prev = null, current = [1] next = [2] [1].next = null prev = [1] current = [2] Iteration 2: prev = [1], current = [2] next = [3] [2].next = [1] prev = [2] current = [3] Iteration 3: prev = [2], current = [3] next = null [3].next = [2] prev = [3] current = null Return prev as new head: [3] -> [2] -> [1] -> null

Result

The reversed list is 3 -> 2 -> 1 -> null

Walking through the process step-by-step builds confidence and reveals how pointers change at each step.

6

Advanced

Handling Edge Cases in Reversal

🤔Before reading on: what happens if the list is empty or has one node? Commit to your answer.

Concept: Understand how the reversal code naturally handles empty lists and single-node lists without extra checks.

If head is null, current starts null, so loop never runs and null is returned. If list has one node, current.next is null, so after one iteration, prev points to that node and current becomes null. No special code is needed for these cases.

Result

The function safely returns null for empty lists and the same single node for one-node lists.

Knowing that the iterative method gracefully handles edge cases reduces bugs and simplifies code.

7

Expert

Performance and Memory Implications

🤔Before reading on: does iterative reversal use more memory than recursive reversal? Commit to your answer.

Concept: Compare iterative reversal's memory use and speed to recursive reversal and understand why iterative is often preferred in production.

Iterative reversal uses constant extra memory (only a few pointers). Recursive reversal uses call stack memory proportional to list length, risking stack overflow on large lists. Iterative is faster and safer for big data. Recursive is elegant but less practical for large inputs.

Result

Iterative reversal is more efficient and reliable for real-world applications.

Understanding memory and performance trade-offs guides choosing the right reversal method in professional code.

Under the Hood

Internally, the reversal changes each node's next pointer to point backward instead of forward. The process uses three pointers: prev, current, and next. At each step, current.next is redirected to prev, then prev and current move forward. This pointer flipping continues until current reaches null, meaning the list end. The prev pointer then points to the new head. No new nodes are created; only the links between existing nodes change.

Why designed this way?

This iterative approach was designed to reverse lists efficiently using minimal memory and time. Early computer systems had limited stack space, making recursion risky for long lists. Iteration avoids stack overflow and reduces overhead. The simplicity of pointer manipulation fits well with low-level memory models and allows in-place reversal without extra data structures.

┌─────────────┐       ┌─────────────┐       ┌─────────────┐       ┌─────────────┐
│   [1]       │──────▶│   [2]       │──────▶│   [3]       │──────▶│   null      │
│ next: [2]   │       │ next: [3]   │       │ next: null  │       │             │
└─────────────┘       └─────────────┘       └─────────────┘       └─────────────┘

After reversal:

┌─────────────┐       ┌─────────────┐       ┌─────────────┐       ┌─────────────┐
│   [3]       │──────▶│   [2]       │──────▶│   [1]       │──────▶│   null      │
│ next: [2]   │       │ next: [1]   │       │ next: null  │       │             │
└─────────────┘       └─────────────┘       └─────────────┘       └─────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does reversing a singly linked list require creating new nodes? Commit to yes or no.

Common Belief: Many think reversing means making a new list with new nodes in reverse order.

Reality: Reversing changes the existing nodes' pointers in place without creating new nodes.

Why it matters: Creating new nodes wastes memory and time, making reversal inefficient and unnecessary.

Quick: Is recursion always better than iteration for reversing linked lists? Commit to yes or no.

Common Belief: Some believe recursion is simpler and always better for reversing lists.

Reality: Recursion uses extra stack memory and can cause stack overflow on large lists; iteration is safer and more efficient.

Why it matters: Using recursion blindly can crash programs or slow them down on big data.

Quick: After reversal, does the original head node still point to the first element? Commit to yes or no.

Common Belief: People often think the head pointer remains the same after reversal.

Reality: The head must be updated to the last node processed, which becomes the new head.

Why it matters: Failing to update head causes losing access to the reversed list, leading to bugs.

Quick: Can you reverse a singly linked list by only changing the data inside nodes, not pointers? Commit to yes or no.

Common Belief: Some think swapping node data is enough to reverse the list.

Reality: Swapping data is possible but inefficient and breaks abstraction; pointer reversal is the standard method.

Why it matters: Swapping data can be costly for large or complex data and ignores the true structure of the list.

Expert Zone

1

The iterative reversal can be adapted to reverse only a sublist by carefully managing pointers before and after the sublist.

2

In concurrent environments, reversing a linked list requires synchronization to avoid pointer corruption.

3

Some languages or frameworks optimize tail pointer updates, which can affect reversal performance subtly.

When NOT to use

Iterative reversal is not suitable if you need to preserve the original list order for later use; in such cases, create a reversed copy instead. Also, if the list is doubly linked, specialized reversal methods that swap both next and previous pointers are better.

Production Patterns

In real systems, iterative reversal is used in undo stacks, reversing playback queues, or reordering tasks. It is often combined with other list operations like insertion or deletion to maintain dynamic data structures efficiently.

Connections

Stack Data Structure

Reversing a linked list is conceptually similar to pushing all elements onto a stack and then popping them to get reversed order.

Understanding stacks helps grasp how reversal reverses order by changing access direction.

Pointer Manipulation in Low-Level Programming

Reversing a linked list is a fundamental example of pointer manipulation, a core skill in systems programming.

Mastering this operation builds intuition for memory management and data structure implementation.

Undo Mechanism in Text Editors

Reversing linked lists underlies how undo stacks reverse user actions in software.

Knowing reversal helps understand how software tracks and reverts changes efficiently.

Common Pitfalls

#1 Losing the rest of the list by not saving the next pointer before changing current.next.

Wrong approach:

while (current !== null) {
current.next = prev;
prev = current;
current = current.next; // WRONG: current.next was changed above
}

Correct approach:

while (current !== null) {
let next = current.next;
current.next = prev;
prev = current;
current = next;
}

Root cause:

Changing current.next before saving it causes losing the reference to the next node, breaking the traversal.

#2 Not updating the head pointer after reversal, leaving it pointing to the old first node.

Wrong approach:

function reverseList(head) {
let prev = null;
let current = head;
while (current !== null) {
let next = current.next;
current.next = prev;
prev = current;
current = next;
}
return head; // WRONG: head not updated
}

Correct approach:

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

Root cause:

Returning the original head instead of the new head causes losing the reversed list.

#3 Trying to reverse an empty list without checking, leading to errors.

Wrong approach:

function reverseList(head) {
let prev = null;
let current = head;
while (current.next !== null) { // WRONG: current could be null
let next = current.next;
current.next = prev;
prev = current;
current = next;
}
return prev;
}

Correct approach:

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

Root cause:

Not handling null current causes runtime errors when the list is empty.

Key Takeaways

Reversing a singly linked list iteratively flips the direction of pointers in one pass without extra memory.

Using three pointers--prev, current, and next--lets you safely change links while traversing the list.

Always update the head pointer to the last processed node to keep access to the reversed list.

Iterative reversal handles empty and single-node lists naturally without special cases.

Understanding pointer manipulation in reversal builds a foundation for advanced data structure operations.

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