Reverse a Singly Linked List Recursive in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Recursive Reverse on a 3-Node List

What is the printed state of the linked list after running the recursive reverse function on this list?

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

DSA Javascript

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

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

// Setup list
const head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);

const reversedHead = reverseRecursive(head);

// Function to print list
function printList(node) {
  let result = '';
  while (node) {
    result += node.value + ' -> ';
    node = node.next;
  }
  result += 'null';
  console.log(result);
}

printList(reversedHead);

A 3 -> 2 -> 1 -> null

B 1 -> 2 -> 3 -> null

C null

D 3 -> 1 -> 2 -> null

💡 Hint

Think about how the recursion unwinds and reverses the links one by one.

The recursive function reverses the list by going to the end and then rewiring the next pointers backward. The final printed list is reversed: 3 -> 2 -> 1 -> null.

❓ Predict Output

intermediate

Output When Reversing a Single Node List

What will be the printed output after reversing a linked list with only one node (value 5) using the recursive reverse function?

DSA Javascript

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

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

const head = new Node(5);
const reversedHead = reverseRecursive(head);

function printList(node) {
  let result = '';
  while (node) {
    result += node.value + ' -> ';
    node = node.next;
  }
  result += 'null';
  console.log(result);
}

printList(reversedHead);

A Error: Cannot read property 'next' of null

B 5 -> 5 -> null

C 5 -> null

D null

💡 Hint

A single node reversed is still the same node.

Since the list has only one node, the base case returns the node itself without changes. The output is '5 -> null'.

❓ Predict Output

advanced

Output of Recursive Reverse on a 4-Node List with Values 10, 20, 30, 40

What is the printed state of the linked list after running the recursive reverse function on this list?

Initial list: 10 -> 20 -> 30 -> 40 -> null

DSA Javascript

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

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

const head = new Node(10);
head.next = new Node(20);
head.next.next = new Node(30);
head.next.next.next = new Node(40);

const reversedHead = reverseRecursive(head);

function printList(node) {
  let result = '';
  while (node) {
    result += node.value + ' -> ';
    node = node.next;
  }
  result += 'null';
  console.log(result);
}

printList(reversedHead);

A Error: Maximum call stack size exceeded

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

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

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

💡 Hint

The recursion reverses the list by rewiring the next pointers from the end back to the start.

The recursive function reverses the list completely. The final printed list is reversed: 40 -> 30 -> 20 -> 10 -> null.

🧠 Conceptual

advanced

Understanding the Base Case in Recursive Reverse

Why is the base case 'if (!head || !head.next) return head;' necessary in the recursive reverse function for a singly linked list?

A It stops recursion when the list is empty or has only one node, preventing infinite recursion.

B It reverses the first two nodes of the list.

C It initializes the new head of the reversed list to null.

D It skips the last node to avoid null pointer errors.

💡 Hint

Think about what happens when the function reaches the end of the list.

The base case stops recursion when the list is empty or has only one node, which is the new head of the reversed list. Without it, recursion would continue infinitely or cause errors.

❓ Predict Output

expert

Output After Recursive Reverse on a Circular Linked List

Given a circular singly linked list where the last node points back to the head, what happens when you run the standard recursive reverse function below?

Code snippet:

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

DSA Javascript

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

// Create circular list: 1 -> 2 -> 3 -> 1 ...
const head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head.next.next.next = head; // circular link

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

// Attempt to reverse circular list
const reversedHead = reverseRecursive(head);

function printList(node, limit = 10) {
  let result = '';
  let count = 0;
  while (node && count < limit) {
    result += node.value + ' -> ';
    node = node.next;
    count++;
  }
  result += '...';
  console.log(result);
}

printList(reversedHead);

A The function returns null immediately without changes.

B The function causes a stack overflow error due to infinite recursion.

C The function successfully reverses the circular list and prints: 3 -> 2 -> 1 -> ...

D The function throws a TypeError because of null pointer access.

💡 Hint

Consider what happens when the recursion never reaches a null next pointer in a circular list.

Because the list is circular, the recursion never reaches a node with null next, causing infinite recursion and eventually a stack overflow error.

Practice

1. What is the main idea behind reversing a singly linked list using recursion?

easy

A. Swap the values of the first and last nodes only

B. Reverse the rest of the list first, then fix the current node's next pointer

C. Iterate through the list using a loop and reverse pointers

D. Create a new list and copy nodes in reverse order

Solution

1. Step 1: Understand recursion on linked list

   Recursion reverses the list by first reversing the smaller list after the current node.

2. Step 2: Fix the current node's next pointer

   After recursion returns, the current node's next node points back to the current node, reversing the link.

3. Final Answer:

   Reverse the rest of the list first, then fix the current node's next pointer -> Option B

4. Quick Check:

   Recursive reversal = Reverse rest then fix current [OK]

Hint: Think: reverse smaller list first, then fix current link [OK]

Common Mistakes:

• Trying to swap node values instead of pointers
• Using iteration instead of recursion
• Not fixing the current node's next pointer after recursion

2. Which of the following is the correct base case for a recursive function that reverses a singly linked list?

easy

A. if (head === null) return head;

B. if (head.next.next === null) return head.next;

C. if (head.next === null) return head;

D. if (head === null || head.next === null) return head;

Solution

1. Step 1: Identify base cases for recursion

   The base case must handle empty list (null) and single node list (next is null).

2. Step 2: Combine conditions for base case

   Return head if it is null or if it is the last node (head.next is null).

3. Final Answer:

   if (head === null || head.next === null) return head; -> Option D

4. Quick Check:

   Base case = empty or single node list [OK]

Hint: Base case covers empty or single node list [OK]

Common Mistakes:

• Using only null check without single node check
• Returning wrong node in base case
• Checking head.next.next which may cause error if head.next is null

3. What will be the output linked list after running this recursive reverse function on the list 1 -> 2 -> 3 -> null?

function reverseList(head) {
  if (head === null || head.next === null) return head;
  const newHead = reverseList(head.next);
  head.next.next = head;
  head.next = null;
  return newHead;
}

medium

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

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

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

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

Solution

1. Step 1: Trace recursion on list 1 -> 2 -> 3

   Recursion reaches last node 3, returns it as new head.

2. Step 2: Reverse pointers on unwind

   Node 2's next (3) points back to 2, then 2's next set to null; similarly for node 1.

3. Final Answer:

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

4. Quick Check:

   Recursive reversal output = reversed list [OK]

Hint: Last node becomes new head, pointers reversed on return [OK]

Common Mistakes:

• Not setting head.next to null causing cycles
• Returning original head instead of new head
• Confusing node values with pointers

4. Identify the error in this recursive reverse function:

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

medium

A. head.next = head; creates a cycle, should be head.next.next = head;

B. Base case is missing for empty list

C. Function does not return newHead

D. head.next is set to null before recursion

Solution

1. Step 1: Analyze pointer assignment

   head.next = head sets next pointer of current node to itself, causing cycle.

2. Step 2: Correct pointer fix

   It should be head.next.next = head to reverse the link properly.

3. Final Answer:

   head.next = head; creates a cycle, should be head.next.next = head; -> Option A

4. Quick Check:

   Pointer fix must be head.next.next = head [OK]

Hint: Fix pointer with head.next.next = head, not head.next = head [OK]

Common Mistakes:

• Assigning head.next to head causing infinite loop
• Forgetting to set head.next to null
• Incorrect base case handling

5. Given a singly linked list with nodes containing values [10, 20, 30, 40, 50], how would you modify the recursive reverse function to also count the number of nodes reversed and return it along with the new head?

hard

A. Return an object {newHead, count} from recursion and increment count on unwind

B. Use a global variable to count nodes during recursion

C. Count nodes before recursion and return only new head

D. Modify nodes to store count and update during recursion

Solution

1. Step 1: Change recursion to return both head and count

   Return an object with newHead and count from each recursive call.

2. Step 2: Increment count on each unwind step

   When recursion returns, add 1 to count to track nodes reversed.

3. Final Answer:

   Return an object {newHead, count} from recursion and increment count on unwind -> Option A

4. Quick Check:

   Return combined result object with count [OK]

Hint: Return object with head and count, increment count on return [OK]

Common Mistakes:

• Using global variables causing side effects
• Counting nodes before reversal, not during recursion
• Modifying node structure unnecessarily