Pop Using Linked List Node in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after popping the head node?

Consider a singly linked list with nodes containing values 10 -> 20 -> 30 -> null. After popping the head node, what is the printed state of the list?

DSA Rust

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

fn pop_head(mut head: Option<Box<Node>>) -> Option<Box<Node>> {
    if head.is_none() {
        return None;
    }
    head.unwrap().next
}

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

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

    let new_head = pop_head(head);
    print_list(&new_head);
}

A 30 -> null

B 10 -> 20 -> 30 -> null

C null

D 20 -> 30 -> null

💡 Hint

Pop removes the first node, so the new head is the second node.

After popping, the head node with value 10 is removed. The new head points to the node with value 20, followed by 30, then null.

❓ Predict Output

intermediate

What happens when popping from an empty linked list?

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

DSA Rust

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

fn pop_head(mut head: Option<Box<Node>>) -> Option<Box<Node>> {
    if head.is_none() {
        return None;
    }
    head.unwrap().next
}

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

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

A panic at unwrap on None value

B null

C 0 -> null

D empty output

💡 Hint

Check if the list is empty before popping.

Since the list is empty, pop_head returns None. Printing the list shows just null.

🔧 Debug

advanced

Why does this pop_head function cause a panic?

Identify the cause of panic in this pop_head function when called on a non-empty list.

DSA Rust

fn pop_head(mut head: Option<Box<Node>>) -> Option<Box<Node>> {
    let next_node = head.unwrap().next;
    head = None;
    next_node
}

A head.unwrap() moves ownership, so next is invalid after unwrap

B head is None, so unwrap panics

C head is not mutable, so cannot assign None

D next_node is borrowed but head is dropped

💡 Hint

Consider ownership and moves when calling unwrap.

Calling unwrap() moves the Box out of head, so accessing next after unwrap is invalid. This causes panic or use-after-move error.

❓ Predict Output

advanced

What is the output after popping the head twice?

Given a linked list 5 -> 15 -> 25 -> null, what is the printed list after calling pop_head twice?

DSA Rust

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

fn pop_head(mut head: Option<Box<Node>>) -> Option<Box<Node>> {
    if head.is_none() {
        return None;
    }
    head.unwrap().next
}

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

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

    let head_after_first_pop = pop_head(head);
    let head_after_second_pop = pop_head(head_after_first_pop);
    print_list(&head_after_second_pop);
}

A 5 -> 15 -> 25 -> null

B 15 -> 25 -> null

C 25 -> null

D null

💡 Hint

Each pop removes the current head node.

First pop removes 5, second pop removes 15, leaving 25 -> null.

🧠 Conceptual

expert

Why is using Option> important for popping nodes in Rust linked lists?

Choose the best explanation for why linked list nodes are wrapped in Option> when implementing pop operations in Rust.

A Option<Box<Node>> allows representing empty lists and safely transferring ownership of nodes during pop operations.

B Option<Box<Node>> prevents any runtime errors by enforcing compile-time checks on node values.

C Option<Box<Node>> automatically implements copy semantics for nodes, simplifying pop logic.

D Option<Box<Node>> is used only to reduce memory usage by avoiding heap allocation.

💡 Hint

Think about how Rust handles ownership and absence of values.

Option> represents either a node (Some) or no node (None). This allows safe ownership transfer and clear empty list representation, essential for pop operations.

Practice

1. What does the pop operation do in a linked list implemented using nodes?

easy

A. Removes and returns the first node from the list

B. Adds a new node at the end of the list

C. Counts the total number of nodes in the list

D. Reverses the order of nodes in the list

Solution

1. Step 1: Understand the pop operation in linked list context

   Pop means removing an element, usually from the start or top of a data structure.

2. Step 2: Identify pop behavior for linked list nodes

   In a linked list, pop removes the first node and returns its value, updating the head pointer.

3. Final Answer:

   Removes and returns the first node from the list -> Option A

4. Quick Check:

   Pop = Remove first node [OK]

Hint: Pop removes the first node in a linked list [OK]

Common Mistakes:

• Thinking pop adds nodes instead of removing
• Confusing pop with counting nodes
• Assuming pop reverses the list

2. Which of the following Rust code snippets correctly pops a node from the head of a singly linked list?

easy

A. let popped = list.head.take(); list.head = popped.as_ref().and_then(|node| node.next.clone());

B. let popped = list.tail.take(); list.tail = popped.as_ref().and_then(|node| node.prev.clone());

C. let popped = list.head.clone(); list.head = popped.unwrap().next.clone();

D. let popped = list.head.unwrap(); list.head = popped.next.unwrap();

Solution

1. Step 1: Identify correct pop syntax for head node

   Pop removes the head node safely using take() to replace head with None temporarily.

2. Step 2: Update head to next node correctly

   After taking head, update head to the next node using as_ref() and and_then to clone next safely.

3. Final Answer:

   let popped = list.head.take(); list.head = popped.as_ref().and_then(|node| node.next.clone()); -> Option A

4. Quick Check:

   Use take() and update head to next [OK]

Hint: Use take() on head and update to next node [OK]

Common Mistakes:

• Trying to pop from tail instead of head
• Using unwrap() unsafely causing panic
• Not updating head after pop

3. Given the Rust code below, what will be printed after popping one node from the linked list?

struct Node { value: i32, next: Option }

let mut head = Some(Box::new(Node { value: 10, next: Some(Box::new(Node { value: 20, next: None })) }));

let popped = head.take();
head = popped.as_ref().and_then(|node| node.next.clone());

let mut current = &head;
while let Some(node) = current {
    print!("{} -> ", node.value);
    current = &node.next;
}
print!("null");

medium

A. 10 -> null

B. 10 -> 20 -> null

C. null

D. 20 -> null

Solution

1. Step 1: Understand initial list structure

   List has nodes 10 -> 20 -> null, head points to node with value 10.

2. Step 2: Pop removes first node and updates head

   Pop removes node 10, head now points to node 20.

3. Step 3: Print remaining list

   Loop prints node 20 followed by null.

4. Final Answer:

   20 -> null -> Option D

5. Quick Check:

   Pop removes 10, list starts at 20 [OK]

Hint: Pop removes first node; print starts from new head [OK]

Common Mistakes:

• Printing old head node after pop
• Not updating head after pop
• Confusing Option C (empty list) with actual output

4. The following Rust code attempts to pop a node from a linked list but causes a runtime panic. What is the error?

let mut head = None;
let popped = head.unwrap();
head = popped.next;

medium

A. Missing mutable borrow of head

B. Calling unwrap() on None causes panic

C. Cannot assign popped.next to head

D. next field is private and inaccessible

Solution

1. Step 1: Identify unwrap() usage on None

   head is None, calling unwrap() on None causes panic at runtime.

2. Step 2: Understand why panic occurs

   unwrap() expects Some value; None triggers panic error.

3. Final Answer:

   Calling unwrap() on None causes panic -> Option B

4. Quick Check:

   unwrap() on None = panic [OK]

Hint: Never unwrap None; check before unwrap [OK]

Common Mistakes:

• Assuming unwrap() returns None safely
• Ignoring that head is None initially
• Thinking mutable borrow causes panic

5. You have a linked list implemented with nodes in Rust. You want to pop all nodes one by one and collect their values into a vector. Which approach correctly achieves this?

hard

A. Use a for loop over head and push values, then set head to None

B. Use recursion: call pop on head until head is None, collecting values in vector

C. Use a loop: while let Some(node) = head.take() { push node.value; head = node.next; }

D. Clone the entire list, then pop nodes from the clone to preserve original

Solution

1. Step 1: Use while let loop to pop nodes safely

   Loop uses head.take() to remove head node safely each iteration.

2. Step 2: Push node values and update head

   Inside loop, push node.value to vector and update head to node.next for next iteration.

3. Step 3: Avoid recursion or incorrect iteration

   Recursion can cause stack overflow; for loop over Option is invalid; cloning wastes memory.

4. Final Answer:

   Use a loop: while let Some(node) = head.take() { push node.value; head = node.next; } -> Option C

5. Quick Check:

   Loop with take() and update head [OK]

Hint: Use while let with take() to pop all nodes [OK]

Common Mistakes:

• Using recursion causing stack overflow
• Trying to iterate Option with for loop
• Cloning list unnecessarily wasting memory