Insert at Beginning Head Insert in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new node and insert it at the beginning of the linked list.

DSA Rust

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

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

ASome(value)

Bhead

CNone

Dnew_node

Attempts:

3 left

💡 Hint

Common Mistakes

Setting next to None breaks the list.

Setting next to new_node causes a cycle.

Using Some(value) is incorrect because next expects an Option>.

The new node's next pointer should point to the current head of the list to insert it at the beginning.

2fill in blank

medium

Complete the code to update the head pointer after inserting the new node.

DSA Rust

head = [1];

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

Ahead

BNone

CSome(new_node)

Dnew_node

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning head to new_node without Some causes a type error.

Assigning head to None removes the list.

Assigning head to itself does not update the list.

After insertion, head should point to the new node wrapped in Some.

3fill in blank

hard

Fix the error in the function signature to accept a mutable reference to the head pointer.

DSA Rust

fn insert_at_beginning(head: [1], value: i32) {

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

ABox<Node>

B&Option<Box<Node>>

COption<Box<Node>>

D&mut Option<Box<Node>>

Attempts:

3 left

💡 Hint

Common Mistakes

Using &Option> does not allow modification.

Using Option> passes ownership, not reference.

Using Box is incorrect for the head pointer.

The function needs a mutable reference to modify the head pointer.

4fill in blank

hard

Fill both blanks to complete the insertion function that updates the head pointer correctly.

DSA Rust

fn insert_at_beginning(head: [1], value: i32) {
    let new_node = Box::new(Node { data: value, next: [2] });
    *head = Some(new_node);
}

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

A&mut Option<Box<Node>>

Bhead.clone()

C*head

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Using head.clone() for next causes unnecessary cloning.

Using None for next breaks the list.

Not dereferencing head causes type mismatch.

The function takes a mutable reference to head, and the new node's next points to the current head value dereferenced.

5fill in blank

hard

Fill all three blanks to implement a safe insert at beginning function with proper ownership and updating.

DSA Rust

fn insert_at_beginning(head: [1], value: i32) {
    let new_node = Box::new(Node { data: value, next: [2] });
    *head = [3];
}

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

A&mut Option<Box<Node>>

B*head

CSome(new_node)

Dhead.clone()

Attempts:

3 left

💡 Hint

Common Mistakes

Using head.clone() causes unnecessary cloning.

Assigning *head = head.clone() causes infinite loop.

Not wrapping new_node in Some causes type error.

The function takes a mutable reference to head, sets new_node.next to the current list by dereferencing head, and updates head to Some(new_node).

Practice

1. What does the "Insert at Beginning" operation do in a linked list?

easy

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

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

C. Deletes the first node of the list

D. Deletes the last node of the list

Solution

1. Step 1: Understand the operation

   Inserting at the beginning means adding a new node before the current first node.

2. Step 2: Effect on linked list

   The new node becomes the head, pushing existing nodes after it.

3. Final Answer:

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

4. Quick Check:

   Insert at beginning = Add node at start [OK]

Hint: Insert at beginning means new head node [OK]

Common Mistakes:

• Confusing insert at beginning with insert at end
• Thinking it deletes nodes
• Assuming it modifies middle nodes

2. Which of the following is the correct Rust syntax to insert a new node at the beginning of a singly linked list?

easy

A. self.head = Some(Box::new(Node { data, next: self.head.take() }));

B. self.head.push(Node { data, next: None });

C. self.head.append(Node { data, next: None });

D. self.head.insert(0, Node { data, next: None });

Solution

1. Step 1: Understand Rust linked list insertion

   In Rust, to insert at head, create a new node with next pointing to current head, then update head.

2. Step 2: Match syntax

   self.head = Some(Box::new(Node { data, next: self.head.take() })); uses Some(Box::new(Node { data, next: self.head.take() })) which correctly sets new node's next to old head.

3. Final Answer:

   self.head = Some(Box::new(Node { data, next: self.head.take() })); -> Option A

4. Quick Check:

   Rust head insert = new node points to old head [OK]

Hint: Use Some(Box::new(Node { data, next: old_head })) [OK]

Common Mistakes:

• Using push or append on Option type
• Not using Box::new for heap allocation
• Forgetting to update head pointer

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

let mut list = LinkedList::new();
list.insert_at_beginning(10);
list.insert_at_beginning(20);
list.insert_at_beginning(30);
list.print();

Assuming print() shows nodes from head to tail.

medium

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

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

C. 30 -> 20 -> 10 -> null

D. 20 -> 30 -> 10 -> null

Solution

1. Step 1: Trace insertions

   First insert 10 at beginning: list = 10 -> null Second insert 20 at beginning: list = 20 -> 10 -> null Third insert 30 at beginning: list = 30 -> 20 -> 10 -> null

2. Step 2: Confirm print output

   Print shows from head to tail, so output is 30 -> 20 -> 10 -> null.

3. Final Answer:

   30 -> 20 -> 10 -> null -> Option C

4. Quick Check:

   Last inserted at head appears first [OK]

Hint: Last inserted at head appears first in list [OK]

Common Mistakes:

• Assuming insertion adds at tail
• Reading list backwards
• Confusing print order

4. Identify the error in this Rust code for inserting at the beginning of a linked list:

fn insert_at_beginning(&mut self, data: i32) {
    let new_node = Box::new(Node { data, next: self.head });
    self.head = Some(new_node);
}

medium

A. data type i32 is incorrect for node data

B. self.head should be cloned before assigning to next

C. Box::new cannot be used here

D. self.head is an Option and needs to be taken with .take() to move ownership

Solution

1. Step 1: Understand ownership rules

   self.head is an Option, so assigning it directly to next moves ownership, which is not allowed without .take().

2. Step 2: Correct usage

   Using self.head.take() moves ownership out safely, allowing new_node.next to own old head.

3. Final Answer:

   self.head is an Option and needs to be taken with .take() to move ownership -> Option D

4. Quick Check:

   Use .take() to move Option ownership safely [OK]

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

Common Mistakes:

• Assigning Option without .take()
• Ignoring Rust ownership rules
• Using wrong data types

5. Given a Rust singly linked list, how would you modify the insert_at_beginning method to handle inserting into an empty list and a non-empty list correctly without cloning nodes?

hard

A. Check if self.head is None, then assign new node; else append at tail

B. Use self.head = Some(Box::new(Node { data, next: self.head.take() })) to move ownership safely

C. Clone the entire list before inserting the new node

D. Use unsafe pointers to bypass ownership rules

Solution

1. Step 1: Handle empty and non-empty list uniformly

   Using self.head.take() moves the current head out safely whether it is None or Some(node).

2. Step 2: Create new node with next as old head

   Assign new node as head with next pointing to old head, no cloning needed.

3. Final Answer:

   Use self.head = Some(Box::new(Node { data, next: self.head.take() })) to move ownership safely -> Option B

4. Quick Check:

   Use .take() for safe ownership transfer in insert [OK]

Hint: Use .take() to handle empty and non-empty head safely [OK]

Common Mistakes:

• Appending at tail instead of head
• Cloning nodes unnecessarily
• Using unsafe code without need