Delete Node by Value in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if the list is empty before deletion.

DSA Rust

if self.head.is_[1]() {
    return;
}

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

Aempty

Bnull

Cnone

Dsome

Attempts:

3 left

💡 Hint

Common Mistakes

Using is_empty() which does not exist for Option.

Using is_some() which checks for presence, not absence.

In Rust, Option types use is_none() to check if the value is None (empty).

2fill in blank

medium

Complete the code to move to the next node in the list.

DSA Rust

while let Some(ref mut current) = current_node {
    if current.value == value {
        break;
    }
    current_node = current.[1].as_mut();
}

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

Anext

Bprev

Cchild

Dlink

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' which is for doubly linked lists.

Using 'child' or 'link' which are not standard field names.

In a singly linked list, the next node is accessed via the 'next' field.

3fill in blank

hard

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

DSA Rust

if let Some(ref mut prev_node) = prev {
    prev_node.next = current_node.[1].take();
}

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

Aprev

Bnext

Cchild

Dlink

Attempts:

3 left

💡 Hint

Common Mistakes

Using prev instead of next causes wrong pointer update.

Not using take() leads to ownership errors.

To delete a node, link the previous node's next to the current node's next.

4fill in blank

hard

Fill both blanks to correctly handle deleting the head node.

DSA Rust

if self.head.as_ref().map_or(false, |node| node.value == value) {
    self.head = self.head.as_mut().and_then(|node| node.[1].[2]());
    return;
}

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

Anext

Btake

Cclone

Dunwrap

Attempts:

3 left

💡 Hint

Common Mistakes

Using clone() which duplicates nodes unnecessarily.

Using unwrap() which can panic if next is None.

To delete the head, set head to the next node by taking ownership of it.

5fill in blank

hard

Fill all three blanks to complete the delete function safely.

DSA Rust

pub fn delete(&mut self, value: i32) {
    if self.head.is_none() {
        return;
    }
    if self.head.as_ref().unwrap().value == [1] {
        self.head = self.head.as_mut().and_then(|node| node.[2].[3]());
        return;
    }
    let mut current_node = self.head.as_mut();
    while let Some(ref mut current) = current_node {
        if let Some(ref mut next_node) = current.[2] {
            if next_node.value == value {
                current.[2] = next_node.[2].take();
                return;
            }
        }
        current_node = current.[2].as_mut();
    }
}

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

Avalue

Bnext

Ctake

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' in a singly linked list.

Not using take() causing ownership errors.

The function compares the value to delete, uses 'next' to traverse, and 'take()' to remove nodes safely.

Practice

1. What does the operation "Delete Node by Value" do in a linked list?

easy

A. Removes the first node that contains the given value

B. Adds a new node with the given value at the end

C. Reverses the linked list

D. Counts the number of nodes with the given value

Solution

1. Step 1: Understand the operation

   Deleting a node by value means finding the first node that matches the value and removing it from the list.

2. Step 2: Compare options

   Only Removes the first node that contains the given value describes removing the first node with the given value, which matches the operation.

3. Final Answer:

   Removes the first node that contains the given value -> Option A

4. Quick Check:

   Delete node by value = Remove first matching node [OK]

Hint: Delete node by value means remove first matching node [OK]

Common Mistakes:

• Confusing deletion by value with adding nodes
• Thinking it deletes all nodes with the value
• Mixing deletion by value with reversing the list

2. Which Rust code snippet correctly deletes the first node with value `val` from a singly linked list starting at `head`?

easy

A. let mut current = &mut head;
while let Some(ref mut node) = current {
if node.val == val {
*current = node.next.take();
break;
}
current = &mut node.next;
}

B. let mut current = head;
while current.is_some() {
if current.val == val {
current = current.next;
break;
}
current = current.next;
}

C. for node in head.iter() {
if node.val == val {
head.remove(node);
break;
}
}

D. while let Some(node) = head {
if node.val == val {
head = node.next;
}
}

Solution

1. Step 1: Analyze pointer usage in Rust linked list deletion

   Rust linked lists use mutable references to update links. let mut current = &mut head; while let Some(ref mut node) = current { if node.val == val { *current = node.next.take(); break; } current = &mut node.next; } uses `&mut` references and `take()` to remove the node correctly.

2. Step 2: Check other options for correctness

   let mut current = head; while current.is_some() { if current.val == val { current = current.next; break; } current = current.next; } uses immutable references and does not update links properly. for node in head.iter() { if node.val == val { head.remove(node); break; } } uses a for loop which is invalid for linked lists. while let Some(node) = head { if node.val == val { head = node.next; } } does not handle mutable references correctly.

3. Final Answer:

   Uses `&mut` references and `take()` to remove the node correctly -> Option A

4. Quick Check:

   Use mutable references and take() to delete node [OK]

Hint: Use mutable references and take() to delete node [OK]

Common Mistakes:

• Using immutable references to modify list
• Trying to iterate with for loop on linked list
• Not updating the previous node's next pointer

3. Given the Rust code below, what will be the linked list after deleting the node with value 3?

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

let mut head = Some(Box::new(Node { val: 1, next: Some(Box::new(Node { val: 3, next: Some(Box::new(Node { val: 5, next: None })) })) }));

let val = 3;
let mut current = &mut head;
while let Some(ref mut node) = current {
  if node.val == val {
    *current = node.next.take();
    break;
  }
  current = &mut node.next;
}

medium

A. 1 -> null

B. 1 -> 3 -> 5 -> null

C. 1 -> 5 -> null

D. 3 -> 5 -> null

Solution

1. Step 1: Understand the initial list structure

   The list is 1 -> 3 -> 5 -> null.

2. Step 2: Trace deletion of node with value 3

   The loop finds node with val=3 and removes it by linking previous node's next to node 3's next (which is node 5).

3. Final Answer:

   1 -> 5 -> null -> Option C

4. Quick Check:

   Deleted node 3, list is 1 -> 5 [OK]

Hint: After deletion, previous node points to deleted node's next [OK]

Common Mistakes:

• Not updating previous node's next pointer
• Deleting wrong node due to incorrect comparison
• Confusing node values and positions

4. The following Rust code attempts to delete a node by value from a linked list but causes a compile error. What is the main issue?

let mut current = &head;
while let Some(ref node) = current {
  if node.val == val {
    current = &node.next;
    break;
  }
  current = &node.next;
}

medium

A. Missing semicolon after `current = &node.next`

B. Using immutable reference `&head` prevents modifying the list

C. Incorrect use of `while let` syntax

D. `val` is not defined in the scope

Solution

1. Step 1: Check reference mutability

   The code uses `&head` which is immutable, so it cannot modify the list links.

2. Step 2: Understand why mutable reference is needed

   To delete a node, we must change pointers, requiring `&mut` references, which are missing here.

3. Final Answer:

   Using immutable reference `&head` prevents modifying the list -> Option B

4. Quick Check:

   Modify list needs mutable references [OK]

Hint: Use &mut references to modify linked list nodes [OK]

Common Mistakes:

• Ignoring mutability requirements in Rust
• Assuming immutable references can change list
• Overlooking compiler error messages

5. You have a singly linked list with nodes: 2 -> 4 -> 6 -> 4 -> 8 -> null. You want to delete all nodes with value 4 using Rust. Which approach correctly deletes all such nodes?

hard

A. Traverse list with immutable references and skip nodes with value 4 without modifying links

B. Delete only the first node with value 4 and stop

C. Replace all node values 4 with 0 instead of deleting nodes

D. Use a loop with mutable reference to current node pointer, repeatedly deleting nodes with value 4 until none remain

Solution

1. Step 1: Understand requirement to delete all nodes with value 4

   We must remove every node containing 4, not just the first.

2. Step 2: Use mutable references to update links repeatedly

   Loop through list with mutable pointer, deleting nodes with value 4 by updating links until none remain.

3. Step 3: Reject other options

   Delete only the first node with value 4 and stop deletes only first node. Traverse list with immutable references and skip nodes with value 4 without modifying links does not modify list. Replace all node values 4 with 0 instead of deleting nodes changes values but does not delete nodes.

4. Final Answer:

   Use a loop with mutable reference to current node pointer, repeatedly deleting nodes with value 4 until none remain -> Option D

5. Quick Check:

   Delete all matching nodes by looping with mutable refs [OK]

Hint: Loop with mutable refs to delete all matching nodes [OK]

Common Mistakes:

• Deleting only first matching node
• Using immutable references to try deleting
• Confusing value replacement with deletion