Push Using Linked List Node in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new node with the given value.

DSA Rust

let new_node = Box::new(Node { data: value, next: [1] });

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

ASome(value)

BNone

Cnext

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Setting next to Some(value) instead of None

Using head instead of None for next

When creating a new node to push, its next pointer should be None initially.

2fill in blank

medium

Complete the code to link the new node to the current head of the list.

DSA Rust

new_node.next = [1];

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

Ahead.take()

BSome(value)

CNone

Dnew_node

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning None instead of head.take()

Assigning new_node to next causing self-reference

The new node's next should point to the current head, which is taken using head.take().

3fill in blank

hard

Fix the error in updating the head pointer to the new node.

DSA Rust

head = [1];

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

ASome(new_node)

Bnew_node

CNone

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning new_node directly without Some()

Assigning None or head itself

The head must be updated to point to the new node wrapped in Some().

4fill in blank

hard

Fill both blanks to complete the push function that adds a new node at the front.

DSA Rust

fn push(&mut self, value: i32) {
    let mut new_node = Box::new(Node { data: value, next: [1] });
    new_node.next = [2];
    self.head = Some(new_node);
}

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

ANone

Bself.head.take()

CSome(value)

Dself.head

Attempts:

3 left

💡 Hint

Common Mistakes

Setting next to Some(value) initially

Assigning self.head directly without take()

The new node is created with next as None, then its next is set to the current head taken by self.head.take().

5fill in blank

hard

Fill all three blanks to complete the push method that safely adds a new node at the front of the linked list.

DSA Rust

fn push(&mut self, value: i32) {
    let mut new_node = Box::new(Node { data: value, next: [1] });
    new_node.next = [2];
    self.head = [3];
}

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

ANone

Bself.head.take()

CSome(new_node)

DSome(value)

Attempts:

3 left

💡 Hint

Common Mistakes

Not using take() causing ownership errors

Assigning head directly without Some()

Setting next incorrectly

The new node is created with next as None, then linked to the old head using self.head.take(), and finally head is updated to Some(new_node).

Practice

1. What does the push operation do in a linked list when using a node?

easy

A. Adds a new node at the beginning of the list

B. Removes the last node from the list

C. Searches for a node with a specific value

D. Deletes the entire list

Solution

1. Step 1: Understand push operation in linked list

   The push operation adds a new node to the linked list.

2. Step 2: Identify where the new node is added

   In a singly linked list, push usually adds the new node at the start (head) of the list.

3. Final Answer:

   Adds a new node at the beginning of the list -> Option A

4. Quick Check:

   Push = Add at head [OK]

Hint: Push always adds node at the start of the list [OK]

Common Mistakes:

• Thinking push adds at the end
• Confusing push with pop
• Assuming push deletes nodes

2. Which of the following Rust code snippets correctly creates a new node and pushes it to the front of a linked list?

easy

A. head = Some(Node { data: 5, next: None });

B. let new_node = Node { data: 5, next: None }; head = new_node.next;

C. let new_node = Box::new(Node { data: 5, next: head }); head = Some(new_node);

D. let new_node = Box::new(Node { data: 5 }); head = new_node.next;

Solution

1. Step 1: Check node creation with Box and linking

   let new_node = Box::new(Node { data: 5, next: head }); head = Some(new_node); creates a boxed node with data 5 and next pointing to current head.

2. Step 2: Assign new node as new head

   Then head is updated to Some(new_node), correctly pushing at front.

3. Final Answer:

   let new_node = Box::new(Node { data: 5, next: head }); head = Some(new_node); -> Option C

4. Quick Check:

   Boxed node with next=head, then head=Some(new_node) [OK]

Hint: Use Box::new and set next to current head [OK]

Common Mistakes:

• Not boxing the node
• Not updating head correctly
• Setting next to None instead of head

3. What will be the printed linked list after executing this Rust code?

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

fn push(head: &mut Option, data: i32) {
    let new_node = Box::new(Node { data, next: head.take() });
    *head = Some(new_node);
}

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

fn main() {
    let mut head = None;
    push(&mut head, 10);
    push(&mut head, 20);
    push(&mut head, 30);
    print_list(&head);
}

medium

A. 10 -> 20 -> 30 -> null

B. 30 -> 20 -> 10 -> null

C. null

D. Compilation error

Solution

1. Step 1: Trace push calls and list building

   First push adds 10 as head. Second push adds 20 before 10. Third push adds 30 before 20.

2. Step 2: Print list from head

   Print starts at head (30), then 20, then 10, then null.

3. Final Answer:

   30 -> 20 -> 10 -> null -> Option B

4. Quick Check:

   Last pushed node is head, so list is 30->20->10->null [OK]

Hint: Last pushed node appears first in list [OK]

Common Mistakes:

• Assuming push adds at end
• Confusing order of nodes
• Ignoring Option and Box usage

4. Identify the error in this Rust function that tries to push a new node to the linked list head:

fn push(head: &mut Option, data: i32) {
    let new_node = Box::new(Node { data, next: head });
    *head = Some(new_node);
}

medium

A. Cannot assign &Option to next, must use head.take()

B. Missing return statement

C. Box::new cannot be used here

D. Data type i32 is incorrect

Solution

1. Step 1: Analyze next field assignment

   The next field expects Option, but head is &mut Option, a reference.

2. Step 2: Correct usage with head.take()

   Using head.take() moves the Option out, allowing ownership transfer to next.

3. Final Answer:

   Cannot assign &Option to next, must use head.take() -> Option A

4. Quick Check:

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

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

Common Mistakes:

• Assigning reference instead of owned Option
• Ignoring Rust ownership rules
• Thinking Box::new is invalid here

5. Given a linked list implemented with nodes in Rust, how would you modify the push function to prevent memory leaks when repeatedly pushing nodes?

hard

A. Use clone() on nodes to duplicate data

B. Use raw pointers instead of Box to manage nodes

C. Manually call drop() on old head before pushing

D. Use head.take() to transfer ownership and avoid dangling references

Solution

1. Step 1: Understand ownership in Rust linked list

   Each node owns the next node via Box. To avoid leaks, ownership must be properly transferred.

2. Step 2: Use head.take() to move ownership safely

   head.take() replaces head with None and moves ownership to new node's next, preventing leaks.

3. Final Answer:

   Use head.take() to transfer ownership and avoid dangling references -> Option D

4. Quick Check:

   head.take() safely moves ownership, preventing leaks [OK]

Hint: Use head.take() to transfer ownership safely [OK]

Common Mistakes:

• Using raw pointers causing unsafe code
• Calling drop manually causing double free
• Cloning nodes causing unnecessary copies