Delete Node at Beginning in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after deleting the first node?

Consider a singly linked list with nodes containing values 10 -> 20 -> 30 -> null. After deleting the node at the beginning, what will be the printed list?

DSA Rust

struct Node {
    data: i32,
    next: Option<Box<Node>>,
}

fn delete_at_beginning(head: Option<Box<Node>>) -> Option<Box<Node>> {
    match head {
        None => None,
        Some(node) => node.next,
    }
}

fn print_list(head: &Option<Box<Node>>) {
    let mut current = head;
    while let Some(node) = current {
        print!("{} -> ", node.data);
        current = &node.next;
    }
    print!("null\n");
}

fn main() {
    let third = Box::new(Node { data: 30, next: None });
    let second = Box::new(Node { data: 20, next: Some(third) });
    let first = Box::new(Node { data: 10, next: Some(second) });
    let head = Some(first);

    let head = delete_at_beginning(head);
    print_list(&head);
}

A null

B 20 -> 30 -> null

C 30 -> null

D 10 -> 20 -> 30 -> null

💡 Hint

Deleting the first node means the head moves to the next node.

The function removes the first node by returning the next node as the new head. So the list starts from 20 now.

❓ Predict Output

intermediate

What happens if we delete from an empty list?

Given an empty linked list (head is None), what will be the output after calling delete_at_beginning and then printing the list?

DSA Rust

fn main() {
    let head: Option<Box<Node>> = None;
    let head = delete_at_beginning(head);
    print_list(&head);
}

A null

B panic at unwrap

C 0 -> null

D empty line

💡 Hint

Deleting from an empty list should keep it empty.

The function returns None when the list is empty, so printing shows 'null'.

🔧 Debug

advanced

Why does this code cause a compile error?

This Rust code tries to delete the first node but fails to compile. What is the cause? ```rust fn delete_at_beginning(head: Option>) -> Option> { head.next } ```

A Option<Box<Node>> has no field named 'next', must unwrap first

B Missing return statement

C Cannot move out of borrowed content

D Function signature is incorrect

💡 Hint

Option is an enum, not a struct with fields.

head is an Option, so you cannot access .next directly without unwrapping the Option first.

❓ Predict Output

advanced

What is the output after deleting the first node twice?

Given a linked list 5 -> 15 -> 25 -> null, after deleting the first node two times, what will be the printed list?

DSA Rust

fn main() {
    let third = Box::new(Node { data: 25, next: None });
    let second = Box::new(Node { data: 15, next: Some(third) });
    let first = Box::new(Node { data: 5, next: Some(second) });
    let mut head = Some(first);

    head = delete_at_beginning(head);
    head = delete_at_beginning(head);
    print_list(&head);
}

A 15 -> 25 -> null

B 5 -> 15 -> 25 -> null

C 25 -> null

D null

💡 Hint

Each deletion removes the current head node.

First deletion removes 5, second removes 15, so list starts at 25.

🧠 Conceptual

expert

Why is deleting the first node in a singly linked list efficient?

Which reason best explains why deleting the first node in a singly linked list is faster than deleting a node in the middle?

A Because the first node stores the size of the list

B Because the list is doubly linked and nodes have back pointers

C Because deleting the first node requires shifting all other nodes

D Because we only update the head pointer to the next node without traversal

💡 Hint

Think about how much work is needed to remove the first node.

Deleting the first node just moves the head pointer, no need to find previous nodes.

Practice

1. What does deleting a node at the beginning of a singly linked list do to the list?

easy

A. Deletes all nodes in the list

B. Removes the last node and updates the tail

C. Removes the first node and updates the head to the next node

D. Removes a node from the middle of the list

Solution

1. Step 1: Understand the head pointer role

   The head points to the first node in the list, so deleting the first node means changing the head.

2. Step 2: Update the head to the next node

   After removing the first node, the head should point to the second node, effectively removing the first node from the list.

3. Final Answer:

   Removes the first node and updates the head to the next node -> Option C

4. Quick Check:

   Delete at beginning = remove first node [OK]

Hint: Deleting at start means moving head to next node [OK]

Common Mistakes:

• Trying to remove the last node instead of the first
• Not updating the head pointer after deletion
• Deleting all nodes instead of just one

2. Which Rust code snippet correctly deletes the first node of a singly linked list stored in a variable head?

easy

A. head = head.take().and_then(|node| node.next);

B. head = head.unwrap().next;

C. head = head.next;

D. head.next = head;

Solution

1. Step 1: Understand Rust Option handling for linked lists

   In Rust, linked lists often use Option. To delete the first node, we take the head and replace it with its next node safely.

2. Step 2: Use take() and and_then() to update head

   head.take() removes the current head, and and_then(|node| node.next) sets head to the next node, deleting the first.

3. Final Answer:

   head = head.take().and_then(|node| node.next); -> Option A

4. Quick Check:

   Use take() and and_then() to delete first node [OK]

Hint: Use take() and and_then() to update head safely [OK]

Common Mistakes:

• Trying to assign head.next directly without handling Option
• Using unwrap() which can panic if head is None
• Assigning head.next to head causing infinite loop

3. What will be the output linked list after deleting the first node from this Rust linked list?

let mut head = Some(Box::new(Node { value: 10, next: Some(Box::new(Node { value: 20, next: Some(Box::new(Node { value: 30, next: None })) })) }));
head = head.take().and_then(|node| node.next);

Print the list values in order.

medium

A. []

B. [10, 20, 30]

C. [30]

D. [20, 30]

Solution

1. Step 1: Initial list values

   The list starts as 10 -> 20 -> 30 -> None.

2. Step 2: Delete the first node

   Using head.take().and_then(|node| node.next) removes the node with value 10 and sets head to node with value 20.

3. Final Answer:

   [20, 30] -> Option D

4. Quick Check:

   After deletion, list starts at 20 [OK]

Hint: Deleting first node removes head value [OK]

Common Mistakes:

• Forgetting to update head, so list stays same
• Assuming deletion removes last node
• Confusing node values order after deletion

4. Identify the error in this Rust code that tries to delete the first node of a linked list:

fn delete_first(mut head: Option) -> Option {
    head = head.unwrap().next;
    head
}

medium

A. Using unwrap() without checking if head is None causes panic

B. The function does not return the updated head

C. head.next is assigned incorrectly

D. The function should take &mut head instead of ownership

Solution

1. Step 1: Check unwrap() usage

   Calling unwrap() on an Option that might be None will cause the program to panic at runtime.

2. Step 2: Safe deletion requires handling None

   Before unwrap(), code should check if head is Some or use methods like take() and and_then() to avoid panic.

3. Final Answer:

   Using unwrap() without checking if head is None causes panic -> Option A

4. Quick Check:

   unwrap() on None causes panic [OK]

Hint: Never unwrap() without checking Option first [OK]

Common Mistakes:

• Ignoring possibility of empty list (None)
• Not returning updated head properly
• Confusing ownership and borrowing in function

5. Given a Rust singly linked list where each node contains an integer, write the correct way to delete the first node and return the updated list head. Which code snippet correctly handles the edge case when the list is empty?

hard

A. fn delete_first(head: Option) -> Option {
head.unwrap().next
}

B. fn delete_first(mut head: Option) -> Option {
head = head.take().and_then(|node| node.next);
head
}

C. fn delete_first(head: Option) -> Option {
if head.is_some() {
head.unwrap()
} else {
None
}
}

D. fn delete_first(head: Option) -> Option {
head.next
}

Solution

1. Step 1: Handle Option safely with take() and and_then()

   Using head.take().and_then(|node| node.next) safely removes the first node and returns the next node or None if empty.

2. Step 2: Return updated head

   Assign the result back to head and return it, ensuring the function works for empty and non-empty lists.

3. Final Answer:

   fn delete_first(mut head: Option) -> Option { head = head.take().and_then(|node| node.next); head } -> Option B

4. Quick Check:

   Use take() and and_then() for safe deletion [OK]

Hint: Use take() and and_then() to handle empty list safely [OK]

Common Mistakes:

• Using unwrap() without checking for None
• Accessing head.next directly on Option type
• Not returning the updated head after deletion