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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the previous pointer to None.

DSA Python

def reverse_linked_list(head):
    prev = [1]
    current = head
    while current:
        next_node = current.next
        current.next = prev
        prev = current
        current = next_node
    return prev

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

ANone

Bhead

Ccurrent

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Setting prev to head instead of None

Using current instead of None

We start with prev as None because the new tail of the reversed list points to nothing.

2fill in blank

medium

Complete the code to save the next node before changing the current node's next pointer.

DSA Python

def reverse_linked_list(head):
    prev = None
    current = head
    while current:
        [1] = current.next
        current.next = prev
        prev = current
        current = next_node
    return prev

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

Acurrent

Bhead

Cnext_node

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Not saving next node before changing links

Using prev or current instead of next_node

We save the next node in next_node before changing links to avoid losing the rest of the list.

3fill in blank

hard

Fix the error in updating the current pointer to the next node.

DSA Python

def reverse_linked_list(head):
    prev = None
    current = head
    while current:
        next_node = current.next
        current.next = prev
        prev = current
        current = [1]
    return prev

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

Ahead

Bnext_node

Cprev

Dcurrent.next

Attempts:

3 left

💡 Hint

Common Mistakes

Setting current to prev or current.next

Using head instead of next_node

After reversing the link, we move current to the saved next_node to continue traversal.

4fill in blank

hard

Fill both blanks to complete the loop condition and return statement correctly.

DSA Python

def reverse_linked_list(head):
    prev = None
    current = head
    while [1]:
        next_node = current.next
        current.next = prev
        prev = current
        current = next_node
    return [2]

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

Acurrent

Bprev

Chead

Dnext_node

Attempts:

3 left

💡 Hint

Common Mistakes

Using head or next_node in loop or return

Returning current instead of prev

The loop runs while current is not None, and we return prev which is the new head of the reversed list.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps node values to their reversed positions.

DSA Python

def map_reversed_positions(head):
    reversed_list = reverse_linked_list(head)
    position_map = { [1]: index for index, node in enumerate(iter_nodes(reversed_list)) if node.value [2] 0 and node.value [3] 100 }
    return position_map

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

Anode.value

B>

C<

Dindex

Attempts:

3 left

💡 Hint

Common Mistakes

Using index as key

Wrong comparison operators

Mixing up > and <

The dictionary maps each node's value to its index if the value is greater than 0 and less than 100.

Practice

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

easy

A. To remove duplicate nodes from the list

B. To sort the list in ascending order

C. To change the direction of all links so the list order is reversed

D. To find the middle node of the list

Solution

1. Step 1: Understand the linked list structure

   A singly linked list has nodes pointing only to the next node, so reversing means changing these pointers to point backwards.

2. Step 2: Purpose of iterative reversal

   The iterative method changes each node's next pointer to the previous node, effectively reversing the list order.

3. Final Answer:

   To change the direction of all links so the list order is reversed -> Option C

4. Quick Check:

   Reversing means flipping links direction [OK]

Hint: Reversing flips all next pointers to previous nodes [OK]

Common Mistakes:

• Confusing reversal with sorting
• Thinking reversal deletes nodes
• Assuming reversal finds middle node

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

easy

A. prev = head; current = head.next

B. prev = null; current = head

C. prev = head; current = null

D. prev = null; current = null

Solution

1. Step 1: Understand pointer roles

   Prev starts as null because the new tail will point to null; current starts at head to traverse the list.

2. Step 2: Correct initialization

   Setting prev = null and current = head allows iteration from the start with no previous node initially.

3. Final Answer:

   prev = null; current = head -> Option B

4. Quick Check:

   Prev null, current at head to start [OK]

Hint: Prev starts null, current starts at head [OK]

Common Mistakes:

• Setting prev to head initially
• Starting current as null
• Both pointers as null

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

medium

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

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

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

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

Solution

1. Step 1: Trace reversal process

   Initially: prev=null, current=1. After first iteration, 1 points to null. Then 2 points to 1, then 3 points to 2.

2. Step 2: Final reversed list

   The list becomes 3 -> 2 -> 1 -> null after all nodes reverse their next pointers.

3. Final Answer:

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

4. Quick Check:

   Reversed list order is 3, 2, 1 [OK]

Hint: Last node becomes new head after reversal [OK]

Common Mistakes:

• Not updating pointers correctly
• Confusing original and reversed order
• Including null as a node

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

def reverse(head):
    prev = head
    current = null
    while current:
        next_node = current.next
        current.next = prev
        prev = current
        current = next_node
    return prev

medium

A. prev should start as null, current as head

B. The loop condition should be 'while prev' instead of 'while current'

C. current.next assignment is reversed, should be 'prev.next = current'

D. Function should return current instead of prev

Solution

1. Step 1: Check pointer initialization

   Prev should be null initially because the new tail points to null; current should start at head to traverse.

2. Step 2: Loop condition and pointer updates

   Loop runs while current is not null; current.next is set to prev correctly; returning prev gives new head.

3. Final Answer:

   prev should start as null, current as head -> Option A

4. Quick Check:

   Prev null, current head to start loop [OK]

Hint: Prev null, current head to avoid skipping nodes [OK]

Common Mistakes:

• Starting prev at head causes cycle
• Loop condition incorrect
• Returning wrong pointer

5. Given a singly linked list with nodes containing values [10, 20, 30, 40, 50], which iterative reversal step correctly updates the pointers after processing the first two nodes?

hard

A. After first node: 10 -> 20; After second node: 20 -> null

B. After first node: 10 -> 20 -> null; After second node: 20 -> 10 -> null

C. After first node: null -> 10; After second node: 10 -> 20

D. After first node: 10 -> null; After second node: 20 -> 10 -> null

Solution

1. Step 1: Reverse first node pointer

   Initially, prev=null, current=10. After first iteration, 10.next = null, so list is 10 -> null.

2. Step 2: Reverse second node pointer

   Next, current=20. Set 20.next = prev (which is 10), so list is 20 -> 10 -> null.

3. Final Answer:

   After first node: 10 -> null; After second node: 20 -> 10 -> null -> Option D

4. Quick Check:

   Each node points back to previous [OK]

Hint: Each step points current node to previous node [OK]

Common Mistakes:

• Not setting first node's next to null
• Linking nodes forward instead of backward
• Confusing order of pointer updates