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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the previous pointer to None.

DSA Rust

let mut prev = [1];

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

Ahead.clone()

BSome(Box::new(Node::new(0)))

CNone

DSome(head)

Attempts:

3 left

💡 Hint

Common Mistakes

Setting prev to head instead of None.

Using Some(...) incorrectly for prev initialization.

We start with prev as None because initially there is no previous node.

2fill in blank

medium

Complete the code to move the current pointer to the next node.

DSA Rust

let next = [1];

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

Acurrent.next.clone()

Bcurrent.unwrap().next

Ccurrent.next

Dcurrent.as_mut().unwrap().next.take()

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to access next directly without as_mut().

Using clone() instead of take(), which copies the list.

We use as_mut(), unwrap(), and take() to safely extract the next node by moving ownership without cloning.

3fill in blank

hard

Fix the error in assigning current's next to prev.

DSA Rust

current.as_mut().unwrap().next = [1];

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

Aprev.clone()

Bprev

CNone

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning next instead of prev.

Using prev.clone() causing ownership issues.

We assign prev directly to current's next to reverse the link.

4fill in blank

hard

Fill both blanks to update prev and current pointers correctly.

DSA Rust

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

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

Acurrent

Bnext

Cprev

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping prev and current incorrectly.

Assigning prev to next instead of current.

After reversing the link, prev moves to current, and current moves to next.

5fill in blank

hard

Fill all three blanks to complete the iterative reverse function.

DSA Rust

pub fn reverse_list(mut head: Option<Box<Node>>) -> Option<Box<Node>> {
    let mut prev = [1];
    let mut current = head;
    while current.is_some() {
        let next = current.as_mut().unwrap().next.take();
        current.as_mut().unwrap().next = [2];
        prev = [3];
        current = next;
    }
    prev
}

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

ANone

Bprev

Ccurrent

Attempts:

3 left

💡 Hint

Common Mistakes

Incorrect initialization of prev.

Wrong assignment of current's next pointer.

Not updating prev and current correctly.

Initialize prev as None, assign prev to current's next, then move prev to current.

Practice

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

easy

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

B. To sort the linked list in ascending order

C. To remove duplicate nodes from the list

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.

2. Step 2: Identify the effect of reversal

   Reversing changes the direction so the last node points to null and becomes the new head.

3. Final Answer:

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

4. Quick Check:

   Reversing = changing link directions [OK]

Hint: Reversing flips links, last node becomes first [OK]

Common Mistakes:

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

2. Which of the following Rust code snippets correctly initializes a mutable pointer for reversing a singly linked list iteratively?

easy

A. let mut prev = Some(Node::new());

B. let prev = Some(Node::new());

C. let mut prev = None;

D. let prev = None;

Solution

1. Step 1: Understand pointer initialization for reversal

   We start with a previous pointer set to None because initially no nodes are reversed.

2. Step 2: Check mutability and value

   We need mutable prev to update it during iteration, so 'let mut prev = None;' is correct.

3. Final Answer:

   let mut prev = None; -> Option C

4. Quick Check:

   Mutable prev starts as None [OK]

Hint: Start prev as mutable None to track reversed list [OK]

Common Mistakes:

• Forgetting mut keyword
• Initializing prev with a new node incorrectly
• Using immutable prev when mutation is needed

3. Given the following Rust code snippet for reversing a singly linked list iteratively, what will be the printed output after reversal?

struct Node {
    val: i32,
    next: Option,
}

fn print_list(head: &Option) {
    let mut current = head;
    while let Some(node) = current {
        print!("{} -> ", node.val);
        current = &node.next;
    }
    println!("null");
}

fn reverse_list(mut head: Option) -> Option {
    let mut prev = None;
    while let Some(mut current) = head {
        head = current.next.take();
        current.next = prev;
        prev = Some(current);
    }
    prev
}

fn main() {
    let node3 = Node { val: 3, next: None };
    let node2 = Node { val: 2, next: Some(Box::new(node3)) };
    let node1 = Node { val: 1, next: Some(Box::new(node2)) };
    let head = Some(Box::new(node1));

    let reversed_head = reverse_list(head);
    print_list(&reversed_head);
}

medium

A. null

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

C. Compilation error

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

Solution

1. Step 1: Trace the reversal process

   The list starts as 1 -> 2 -> 3 -> null. The reversal changes links so the last node (3) becomes head.

2. Step 2: Confirm print output after reversal

   After reversal, print_list prints nodes from new head: 3 -> 2 -> 1 -> null.

3. Final Answer:

   3 -> 2 -> 1 -> null -> Option D

4. Quick Check:

   Reversed list prints in reverse order [OK]

Hint: Reversed list prints nodes in reverse order [OK]

Common Mistakes:

• Assuming list prints original order after reversal
• Confusing Option C null with empty list
• Thinking code causes compilation error

4. Identify the error in the following Rust code snippet for reversing a singly linked list iteratively:

fn reverse_list(mut head: Option) -> Option {
    let mut prev = None;
    while let Some(current) = head {
        head = current.next;
        current.next = prev;
        prev = Some(current);
    }
    prev
}

medium

A. prev should be immutable

B. Missing .take() when assigning head = current.next

C. Loop condition should be while head.is_some()

D. Function should return head instead of prev

Solution

1. Step 1: Understand ownership in Rust linked list

   current.next is an Option, but to move it out, .take() is needed to avoid borrowing errors.

2. Step 2: Identify the error in head assignment

   head = current.next; tries to move without .take(), causing ownership error. Correct is head = current.next.take();

3. Final Answer:

   Missing .take() when assigning head = current.next -> Option B

4. Quick Check:

   Use .take() to move ownership safely [OK]

Hint: Use .take() to move Option ownership in Rust [OK]

Common Mistakes:

• Ignoring Rust ownership rules
• Making prev immutable by mistake
• Changing loop condition unnecessarily

5. You have a singly linked list with nodes containing integer values. You want to reverse the list iteratively and then remove all nodes with even values from the reversed list. Which approach correctly combines these two operations in Rust?

hard

A. First reverse the list iteratively, then iterate over reversed list to filter out even nodes by rebuilding a new list

B. Filter out even nodes first, then reverse the filtered list recursively

C. Reverse the list recursively and remove even nodes during reversal by skipping them

D. Use a stack to push all nodes, pop them to reverse, and skip even nodes while popping

Solution

1. Step 1: Reverse the list iteratively

   Use the iterative reversal method to get the reversed list with all nodes.

2. Step 2: Filter out even nodes from reversed list

   Iterate over reversed list and build a new list skipping nodes with even values.

3. Final Answer:

   First reverse the list iteratively, then iterate over reversed list to filter out even nodes by rebuilding a new list -> Option A

4. Quick Check:

   Reverse then filter by rebuilding list [OK]

Hint: Reverse first, then filter by rebuilding list [OK]

Common Mistakes:

• Trying to filter during reversal causing complexity
• Using recursion when iterative is required
• Using stack unnecessarily increasing space