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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the previous node pointer to null.

DSA C#

ListNode prev = [1];

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

Anew ListNode()

Bhead

Cthis

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Setting prev to head instead of null.

We start with prev as null because the reversed list's tail will point to null.

2fill in blank

medium

Complete the code to store the next node before changing links.

DSA C#

ListNode next = [1].next;

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

Acurrent

Bprev

Chead

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Using prev.next instead of current.next.

We save current.next in next to not lose the rest of the list when reversing links.

3fill in blank

hard

Fix the error in reversing the link by assigning the previous node correctly.

DSA C#

[1].next = prev;

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

Ahead

Bcurrent

Cnext

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning prev.next instead of current.next.

The current node's next pointer should point to the previous node to reverse the link.

4fill in blank

hard

Fill both blanks to move the pointers forward in the loop.

DSA C#

prev = [1];
current = [2];

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

Acurrent

Bprev

Cnext

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping the assignments or using wrong variables.

After reversing the link, move prev to current and current to next to continue.

5fill in blank

hard

Fill all three blanks to complete the iterative reverse function.

DSA C#

public ListNode ReverseList(ListNode head) {
    ListNode prev = [1];
    ListNode current = head;
    while (current != null) {
        ListNode next = current.[2];
        current.next = [3];
        prev = current;
        current = next;
    }
    return prev;
}

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

Anull

Bnext

Cprev

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to save next before changing current.next.

Returning head instead of prev.

The function starts with prev = null. Inside the loop, it saves current.next in next, then reverses the link by setting current.next = prev. Finally, it moves prev and current forward. Returning prev gives the new head of the reversed list.

Practice

1. What is the main purpose of the iterative method to reverse a singly linked list?

easy

A. To sort the nodes in ascending order

B. To delete all nodes from the list

C. To change the direction of the links between nodes one by one

D. To add new nodes at the end of the list

Solution

1. Step 1: Understand the linked list structure

   A singly linked list has nodes connected in one direction through next pointers.

2. Step 2: Purpose of iterative reversal

   The iterative method changes each node's next pointer to point backward, reversing the list.

3. Final Answer:

   To change the direction of the links between nodes one by one -> Option C

4. Quick Check:

   Reversing = changing links direction [OK]

Hint: Reversing means flipping the links one by one [OK]

Common Mistakes:

• Thinking reversal deletes nodes
• Confusing reversal with sorting
• Assuming reversal adds nodes

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

easy

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

B. Node prev = null; Node current = null;

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

D. Node prev = null; Node current = head;

Solution

1. Step 1: Initialization for reversal

   We start with prev as null because the new tail will point to null, and current at head to traverse.

2. Step 2: Check each option

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

3. Final Answer:

   Node prev = null; Node 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
• Both pointers null at start

3. What will be the output linked list after running this code snippet on list 1 -> 2 -> 3 -> null?

Node prev = null;
Node current = head;
while (current != null) {
  Node nextTemp = current.next;
  current.next = prev;
  prev = current;
  current = nextTemp;
}
head = prev;

medium

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

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

C. null

D. 1 -> null

Solution

1. Step 1: Trace the reversal loop

   Each iteration reverses the link: 1 points to null, 2 points to 1, 3 points to 2.

2. Step 2: Final linked list after loop

   After loop, prev points to 3, which is new head: 3 -> 2 -> 1 -> null.

3. Final Answer:

   3 -> 2 -> 1 -> null -> Option B

4. Quick Check:

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

Hint: Reversal flips list order completely [OK]

Common Mistakes:

• Assuming list stays same
• Forgetting to update head
• Confusing next and prev pointers

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

Node prev = head;
Node current = head.next;
while (current != null) {
  Node nextTemp = current.next;
  current.next = prev;
  prev = current;
  current = nextTemp;
}
head.next = null;
head = prev;

medium

A. prev should be initialized to null, not head

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

C. head.next should not be set to null

D. No error, code is correct

Solution

1. Step 1: Check pointer initialization

   prev must start as null to mark new tail's next as null; starting at head causes cycle.

2. Step 2: Effect of wrong initialization

   Starting prev at head causes the first node to point to itself, creating a loop.

3. Final Answer:

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

4. Quick Check:

   Prev must be null at start [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
• Starting current at wrong node

5. Given a singly linked list with nodes containing values 10 -> 20 -> 30 -> 40 -> null, write the final linked list after applying iterative reversal twice in a row.

hard

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

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

C. null

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

Solution

1. Step 1: First reversal

   Reversing 10->20->30->40 gives 40->30->20->10->null.

2. Step 2: Second reversal

   Reversing again restores original order: 10->20->30->40->null.

3. Final Answer:

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

4. Quick Check:

   Double reversal restores original list [OK]

Hint: Reversing twice returns original list [OK]

Common Mistakes:

• Assuming second reversal changes order again
• Confusing node values after reversal
• Forgetting reversal is reversible