Reverse a Singly Linked List Iterative in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the previous pointer to null.

DSA Java

ListNode prev = [1];

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

Anull

Bhead

Cnew ListNode()

Dhead.next

Attempts:

3 left

💡 Hint

Common Mistakes

Setting prev to head instead of null.

Creating a new node unnecessarily.

We start reversing by setting the previous pointer to null because the new tail will point to null.

2fill in blank

medium

Complete the code to move the current pointer to the next node before changing links.

DSA Java

ListNode next = [1].next;

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

Aprev

Bhead

Cnext

Dcurrent

Attempts:

3 left

💡 Hint

Common Mistakes

Using prev instead of current.

Using next before it is defined.

We save the next node of current before changing current's next pointer.

3fill in blank

hard

Fix the error in reversing the link by assigning current.next to the correct node.

DSA Java

current.next = [1];

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

Anext

Bprev

Chead

Dcurrent

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning current.next to next, which breaks the reversal.

Assigning current.next to current, causing a cycle.

To reverse the link, current.next should point to prev, not next or itself.

4fill in blank

hard

Fill both blanks to update prev and current pointers correctly after reversing one link.

DSA Java

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 of prev and current.

Assigning current to prev instead of next.

After reversing, prev moves to current, and current moves to next to continue the loop.

5fill in blank

hard

Fill all three blanks to complete the iterative reverse function returning the new head.

DSA Java

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

Returning head instead of prev.

Not saving current.next before reversing the link.

The function starts with prev as null, saves current.next in next, reverses current.next to prev, then moves pointers forward. Finally, prev is the new head.

Practice

1. What is the main purpose of reversing a singly linked list iteratively?

easy

A. To sort the list in ascending order

B. To delete all nodes from the list

C. To change the direction of all links so the last node becomes the first

D. To add a new node 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 from head to tail.

2. Step 2: Purpose of reversing

   Reversing changes the links so the last node points to the previous one, making it the new head.

3. Final Answer:

   To change the direction of all links so the last node becomes the first -> Option C

4. Quick Check:

   Reversing = changing link directions [OK]

Hint: Reversing flips the list direction, last becomes first [OK]

Common Mistakes:

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

2. Which of the following is the correct way to initialize the previous pointer before starting the iterative reversal?

easy

A. Node prev = head;

B. Node prev = head.next;

C. Node prev = new Node();

D. Node prev = null;

Solution

1. Step 1: Understand the role of previous pointer

   Previous pointer starts as null because the new tail's next should be null after reversal.

2. Step 2: Initialization

   Setting prev to null ensures the first node processed points to null, ending the reversed list properly.

3. Final Answer:

   Node prev = null; -> Option D

4. Quick Check:

   Prev starts null to mark new tail [OK]

Hint: Prev pointer starts null to mark list end [OK]

Common Mistakes:

• Initializing prev to head causes cycle
• Creating new node wastes memory
• Starting prev at head.next skips first node

3. What will be the output linked list after reversing the list 1 -> 2 -> 3 -> null iteratively?

medium

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

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

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

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

Solution

1. Step 1: Trace the reversal process

   Initially: 1 -> 2 -> 3 -> null. After reversal, links point backward: 3 -> 2 -> 1 -> null.

2. Step 2: Confirm final head and tail

   Node 3 becomes new head, node 1 becomes tail pointing to null.

3. Final Answer:

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

4. Quick Check:

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

Hint: Last node becomes first after reversal [OK]

Common Mistakes:

• Assuming list stays same after reversal
• Confusing null placement
• Mixing node order

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

Node prev = head;
Node current = head.next;
while (current != null) {
  Node nextNode = current.next;
  current.next = prev;
  prev = current;
  current = nextNode;
}
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. Loop condition should be current.next != null

Solution

1. Step 1: Check initialization of prev pointer

   Prev must start as null to mark new tail's next as null after reversal.

2. Step 2: Effect of wrong initialization

   Starting prev at head causes a cycle, breaking reversal logic.

3. Final Answer:

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

4. Quick Check:

   Prev = null to avoid cycles [OK]

Hint: Prev must start null to avoid cycles [OK]

Common Mistakes:

• Starting prev at head causes infinite loop
• Wrong loop condition misses last node
• Forgetting to set old head next to null

5. Given a singly linked list with nodes containing values 10 -> 20 -> 30 -> 40 -> null, which iterative code snippet correctly reverses it and prints the reversed list?

hard

A. Node prev = null;
Node current = head;
while (current != null) {
Node next = current.next;
current.next = prev;
prev = current;
current = next;
}
head = prev;
// Print list starting from head

B. Node prev = head;
Node current = head.next;
while (current != null) {
Node next = current.next;
current.next = prev;
prev = current;
current = next;
}
head = prev;
// Print list starting from head

C. Node current = head;
while (current != null) {
Node next = current.next;
current.next = null;
current = next;
}
// Print list starting from head

D. Node prev = null;
Node current = head;
while (current.next != null) {
Node next = current.next;
current.next = prev;
prev = current;
current = next;
}
head = prev;
// Print list starting from head

Solution

1. Step 1: Verify initialization of pointers

   Prev must start as null, current at head to reverse all nodes correctly.

2. Step 2: Check loop condition and pointer updates

   Loop runs while current != null to process all nodes; inside loop, links reversed properly.

3. Step 3: Confirm final head assignment and printing

   After loop, head is set to prev (new head). Printing from head shows reversed list.

4. Final Answer:

   Option A code correctly reverses and prints the list -> Option A

5. Quick Check:

   Prev=null, loop full list, head=prev [OK]

Hint: Prev null, loop full list, head = prev after reversal [OK]

Common Mistakes:

• Starting prev at head causes cycle
• Loop condition misses last node
• Setting current.next = null inside loop breaks links