Reverse a Singly Linked List Iterative in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of reversing this linked list iteratively?

Given the linked list 1 -> 2 -> 3 -> null, what is the printed state after running the iterative reverse method?

DSA C#

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

public class LinkedList {
    public Node head;

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

    public string PrintList() {
        Node temp = head;
        string result = "";
        while (temp != null) {
            result += temp.val + " -> ";
            temp = temp.next;
        }
        return result + "null";
    }
}

var list = new LinkedList();
list.head = new Node(1);
list.head.next = new Node(2);
list.head.next.next = new Node(3);
list.ReverseIterative();
Console.WriteLine(list.PrintList());

A 3 -> 2 -> 1 -> null

B 1 -> 2 -> 3 -> null

C 1 -> null

D null

💡 Hint

Think about how the pointers change direction in the iterative reversal.

The iterative reverse method changes the next pointers of each node to point to the previous node, effectively reversing the list. So the original 1 -> 2 -> 3 -> null becomes 3 -> 2 -> 1 -> null.

❓ Predict Output

intermediate

What is the output after reversing an empty linked list?

If the linked list is empty (head is null), what will the PrintList method output after calling ReverseIterative?

DSA C#

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

public class LinkedList {
    public Node head;

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

    public string PrintList() {
        Node temp = head;
        string result = "";
        while (temp != null) {
            result += temp.val + " -> ";
            temp = temp.next;
        }
        return result + "null";
    }
}

var list = new LinkedList();
list.ReverseIterative();
Console.WriteLine(list.PrintList());

A 0 -> null

B null

C Exception thrown

D -> null

💡 Hint

Consider what happens when the list is empty and you try to reverse it.

If the list is empty, head is null. The reverse method does nothing and head remains null. Printing the list results in just 'null'.

🔧 Debug

advanced

Why does this iterative reverse code cause a runtime error?

Identify the cause of the runtime error in this iterative reverse method for a singly linked list.

DSA C#

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

A The method does not update 'current' inside the loop, causing an infinite loop.

B The variable 'prev' is not initialized properly, causing a null pointer exception.

C The assignment 'head = prev;' should be inside the loop, causing incorrect reversal.

D The loop condition should be 'current != null' instead of 'current.next != null', causing a null reference error.

💡 Hint

Check what happens when current is the last node and you access current.next.

The loop condition 'current.next != null' causes the loop to stop before processing the last node. When current becomes the last node, current.next is null, so accessing current.next in the condition is safe, but the last node is never reversed. Also, after the loop, head is set to prev which points to the second last node, losing the last node. The correct condition is 'current != null' to process all nodes.

❓ Predict Output

advanced

What is the output after reversing a single-node linked list?

Given a linked list with a single node 5 -> null, what is the printed output after calling ReverseIterative?

DSA C#

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

public class LinkedList {
    public Node head;

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

    public string PrintList() {
        Node temp = head;
        string result = "";
        while (temp != null) {
            result += temp.val + " -> ";
            temp = temp.next;
        }
        return result + "null";
    }
}

var list = new LinkedList();
list.head = new Node(5);
list.ReverseIterative();
Console.WriteLine(list.PrintList());

A 5 -> null

B null

C 5 -> 5 -> null

D Exception thrown

💡 Hint

Think about what happens when there is only one node to reverse.

Reversing a single-node list results in the same list because there is only one node. The output remains '5 -> null'.

🧠 Conceptual

expert

Why is iterative reversal of a singly linked list preferred over recursive reversal in some cases?

Select the best reason why iterative reversal of a singly linked list is often preferred over recursive reversal.

A Iterative reversal is easier to implement and understand than recursive reversal.

B Recursive reversal is always slower than iterative reversal due to extra function calls.

C Iterative reversal uses constant extra space, while recursive reversal uses stack space proportional to the list length.

D Recursive reversal cannot reverse lists with more than 100 nodes due to language limitations.

💡 Hint

Consider memory usage differences between recursion and iteration.

Recursive reversal uses the call stack for each node, which can lead to stack overflow for large lists. Iterative reversal uses a few pointers and constant extra space, making it more memory efficient.

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