Reverse a Singly Linked List Recursive in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check the base case for recursion in reversing a singly linked list.

DSA C#

if (head == [1] || head.next == null) return head;

Drag options to blanks, or click blank then click option'

Ahead.next

Bnull

Chead

Dthis

Attempts:

3 left

💡 Hint

Common Mistakes

Using head instead of null for empty list check.

The base case for recursion is when the list is empty (head is null) or has only one node (head.next is null). Here, we check if head is null.

2fill in blank

medium

Complete the code to recursively reverse the rest of the list after the head.

DSA C#

ListNode newHead = [1](head.next);

Drag options to blanks, or click blank then click option'

AReverseRecursive

BReverse

CReverseLinkedList

DReverseList

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect method names or forgetting to pass head.next.

The recursive call should call the same method name, here assumed as ReverseList, passing head.next to reverse the rest of the list.

3fill in blank

hard

Fix the error in linking the next node back to the current head during reversal.

DSA C#

head.next.next = [1];

Drag options to blanks, or click blank then click option'

Ahead

BnewHead

Cnull

Dhead.next

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning null or newHead instead of head.

To reverse the link, the next node's next pointer should point back to the current head.

4fill in blank

hard

Fill both blanks to complete the reversal step and break the old link.

DSA C#

head.next = [1];
return [2];

Drag options to blanks, or click blank then click option'

Anull

Bhead

CnewHead

Dhead.next

Attempts:

3 left

💡 Hint

Common Mistakes

Returning head instead of newHead.

Not breaking the old link.

After reversing, set head.next to null to break old link, and return newHead as the new head of reversed list.

5fill in blank

hard

Fill all three blanks to complete the full recursive reverse method.

DSA C#

public ListNode ReverseList(ListNode head) {
    if (head == [1] || head.next == null) return head;
    ListNode newHead = ReverseList([2]);
    head.next.next = [3];
    head.next = null;
    return newHead;
}

Drag options to blanks, or click blank then click option'

Anull

Bhead.next

Chead

DnewHead

Attempts:

3 left

💡 Hint

Common Mistakes

Wrong base case check.

Passing wrong argument in recursion.

Incorrect link reversal.

The base case checks if head is null. The recursive call passes head.next. Then, head.next.next points back to head to reverse the link.

Practice

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

easy

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

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

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

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

Solution

1. Step 1: Understand recursion on linked list

   Recursion works by solving a smaller part first, here reversing from the next node onward.

2. Step 2: Fix current node's pointer after recursion

   After reversing the rest, the current node's next node points back to it, reversing the link.

3. Final Answer:

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

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
• Not fixing the current node's next pointer after recursion
• Using iteration instead of 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 new Node();

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

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

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

Solution

1. Step 1: Identify when recursion should stop

   The base case is when the list is empty or has only one node, so no reversal needed.

2. Step 2: Check the correct base case syntax

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

3. Final Answer:

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

4. Quick Check:

   Base case = empty or single node returns head [OK]

Hint: Base case: empty or single node returns itself [OK]

Common Mistakes:

• Returning null when list has one node
• Accessing head.next without checking if head is null
• Creating new nodes unnecessarily

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

Node Reverse(Node head) {
  if (head == null || head.next == null) return head;
  Node newHead = Reverse(head.next);
  head.next.next = head;
  head.next = null;
  return newHead;
}

medium

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

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

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

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

Solution

1. Step 1: Trace recursion calls

   Reverse(1) calls Reverse(2), which calls Reverse(3). Reverse(3) returns node 3 as base case.

2. Step 2: Fix pointers on return

   head.next.next = head reverses link: 3.next = 2, then 2.next = 1, and 1.next = null.

3. Final Answer:

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

4. Quick Check:

   Recursive reversal output = reversed list [OK]

Hint: Follow recursion bottom-up to see pointer reversal [OK]

Common Mistakes:

• Not setting head.next to null causing cycle
• Confusing node values with pointers
• Returning wrong node as new head

4. Identify the error in this recursive reverse function and choose the fix:

Node Reverse(Node head) {
  if (head == null) return null;
  Node newHead = Reverse(head.next);
  head.next.next = head;
  return newHead;
}

medium

A. Should return head instead of newHead

B. Missing base case for single node; add 'head.next == null' check

C. head.next.next = head causes null pointer; fix by checking head.next

D. No error; code is correct

Solution

1. Step 1: Check base case correctness

   Base case only checks head == null, missing single node case (head.next == null).

2. Step 2: Consequence of missing base case

   Without single node base case, head.next may be null causing head.next.next to throw error.

3. Final Answer:

   Missing base case for single node; add 'head.next == null' check -> Option B

4. Quick Check:

   Base case must handle empty and single node [OK]

Hint: Base case must cover empty and single node to avoid errors [OK]

Common Mistakes:

• Ignoring single node base case
• Not setting head.next = null after reversal
• Returning wrong node as new head

5. Given a singly linked list with nodes containing values 10 -> 20 -> 30 -> 40 -> null, what will be the printed output after applying this recursive reverse function?

Node Reverse(Node head) {
  if (head == null || head.next == null) return head;
  Node newHead = Reverse(head.next);
  head.next.next = head;
  head.next = null;
  return newHead;
}

// After reversal, print list from newHead

hard

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

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

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

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

Solution

1. Step 1: Trace recursive reversal on given list

   Recursion reverses from last node 40 back to 10, fixing pointers step-by-step.

2. Step 2: Confirm final reversed list order

   After reversal, list order is 40 -> 30 -> 20 -> 10 -> null.

3. Final Answer:

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

4. Quick Check:

   Recursive reversal reverses entire list order [OK]

Hint: Reversal flips list order completely [OK]

Common Mistakes:

• Printing original list instead of reversed
• Forgetting to set head.next = null causing cycle
• Misreading pointer changes as value swaps