Pop Using Linked List Node in DSA Rust - Build from Scratch

Pop Using Linked List Node

📖 Scenario: Imagine you have a simple chain of boxes, each holding a number and a link to the next box. This is called a linked list. You want to remove the first box from the chain and see what number it held.

🎯 Goal: You will build a small Rust program that creates a linked list with three nodes, then removes (pops) the first node and prints its value.

📋 What You'll Learn

Create a linked list node struct called Node with fields value and next

Create a linked list with three nodes holding values 10, 20, and 30 linked in order

Create a mutable variable head pointing to the first node

Write a function pop that removes the first node from the list and returns its value

Print the value returned by pop

💡 Why This Matters

🌍 Real World

Linked lists are used in many programs to manage collections of items where you need to add or remove items efficiently from the front.

💼 Career

Understanding linked lists and how to manipulate nodes is fundamental for software developers working with low-level data structures, memory management, or building custom collections.

1

Create the linked list nodes

Create a struct called Node with a field value of type i32 and a field next of type Option>. Then create three nodes with values 10, 20, and 30 linked together. Finally, create a mutable variable called head that points to the first node.

DSA Rust

// Define the Node struct and create the linked list nodes
// Your code here

Hint

Use Option> for the next field to allow linking nodes. Create nodes from last to first so you can link them properly.

2

Add the pop function

Write a function called pop that takes a mutable reference to head of type Option>. The function should remove the first node from the list, update head to point to the next node, and return the value of the removed node wrapped in Some. If the list is empty, return None.

DSA Rust

struct Node {
    value: i32,
    next: Option>,
}

// Write the pop function below
// Your code here

fn main() {
    let node3 = Node { value: 30, next: None };
    let node2 = Node { value: 20, next: Some(Box::new(node3)) };
    let node1 = Node { value: 10, next: Some(Box::new(node2)) };
    let mut head = Some(Box::new(node1));
}

Hint

Use head.take() to take ownership of the first node, then update head to the next node.

3

Call pop and store the result

Call the pop function with a mutable reference to head and store the returned value in a variable called popped_value.

DSA Rust

struct Node {
    value: i32,
    next: Option>,
}

fn pop(head: &mut Option>) -> Option {
    if let Some(node) = head.take() {
        *head = node.next;
        Some(node.value)
    } else {
        None
    }
}

fn main() {
    let node3 = Node { value: 30, next: None };
    let node2 = Node { value: 20, next: Some(Box::new(node3)) };
    let node1 = Node { value: 10, next: Some(Box::new(node2)) };
    let mut head = Some(Box::new(node1));
    // Call pop and store the result in popped_value
    // Your code here
}

Hint

Pass &mut head to the pop function and assign the result to popped_value.

4

Print the popped value

Print the value inside popped_value. If it is Some, print the number. If it is None, print "List is empty".

DSA Rust

struct Node {
    value: i32,
    next: Option>,
}

fn pop(head: &mut Option>) -> Option {
    if let Some(node) = head.take() {
        *head = node.next;
        Some(node.value)
    } else {
        None
    }
}

fn main() {
    let node3 = Node { value: 30, next: None };
    let node2 = Node { value: 20, next: Some(Box::new(node3)) };
    let node1 = Node { value: 10, next: Some(Box::new(node2)) };
    let mut head = Some(Box::new(node1));
    let popped_value = pop(&mut head);
    // Print the popped_value here
    // Your code here
}

Hint

Use a match statement to check if popped_value is Some or None and print accordingly.

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