Insert at End of Doubly Linked List 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 { value: [1], prev: None, next: None });

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

Aitem

Bvalue

Cdata

Dval

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name not defined in the function like 'value' or 'data'.

The parameter name for the value to insert is 'val', so we use it to set the node's value.

2fill in blank

medium

Complete the code to check if the list is empty by testing if head is None.

DSA Rust

if self.head.[1]() {

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

Ais_none

Bis_empty

Cis_some

Dis_null

Attempts:

3 left

💡 Hint

Common Mistakes

Using is_some() which returns true if there is a value.

Using non-existent methods like is_empty() or is_null().

To check if the list is empty, we check if head is None using is_none().

3fill in blank

hard

Fix the error in updating the previous pointer of the new node to point to the current tail.

DSA Rust

new_node.prev = Some(Box::into_raw(self.tail.[1]()));

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

Aclone

Bas_mut

Cas_ref

Dunwrap

Attempts:

3 left

💡 Hint

Common Mistakes

Using as_ref() which gives an immutable reference.

Using clone() which copies the data instead of referencing.

Using unwrap() which extracts the value but does not give a reference.

We need a mutable reference to the tail node to set the new node's prev pointer, so use as_mut().

4fill in blank

hard

Fill both blanks to update the tail's next pointer and then update the list's tail to the new node.

DSA Rust

self.tail.[1] = Some(new_node);
self.[2] = self.tail.as_mut().unwrap().next.as_mut();

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

Anext

Bhead

Ctail

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing head and tail pointers.

Setting prev instead of next pointer.

We set the current tail's next pointer to the new node, then update the list's tail to that new node.

5fill in blank

hard

Fill all three blanks to correctly insert a new node at the end of the doubly linked list.

DSA Rust

fn insert_at_end(&mut self, val: i32) {
    let mut new_node = Box::new(Node { value: [1], prev: None, next: None });
    if self.head.is_none() {
        self.head = Some(new_node);
        self.[2] = self.head.as_mut();
    } else {
        new_node.prev = Some(Box::into_raw(self.tail.as_mut().unwrap()));
        self.tail.as_mut().unwrap().next = Some(new_node);
        self.[3] = self.tail.as_mut().unwrap().next.as_mut();
    }
}

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

Aval

Bhead

Ctail

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'head' instead of 'tail' to update the pointer.

Using 'value' instead of 'val' for the new node's value.

We use 'val' to set the new node's value, and update the list's tail pointer correctly to the new node.

Practice

1. What is the main purpose of inserting a node at the end of a doubly linked list?

easy

A. To reverse the list

B. To remove the first node

C. To add a new element after the last node

D. To find the middle node

Solution

1. Step 1: Understand the structure of a doubly linked list

   A doubly linked list has nodes connected forward and backward, allowing traversal in both directions.

2. Step 2: Purpose of insertion at the end

   Inserting at the end means adding a new node after the current last node, updating pointers accordingly.

3. Final Answer:

   To add a new element after the last node -> Option C

4. Quick Check:

   Insert at end = add after last node [OK]

Hint: Insert at end means add after last node [OK]

Common Mistakes:

• Confusing insertion at end with deletion
• Thinking insertion reverses the list
• Assuming insertion happens at the start

2. Which Rust code snippet correctly creates a new node and inserts it at the end of a doubly linked list?

easy

A. let new_node = Node::new(value); new_node.prev = Some(head); head.next = Some(new_node);

B. let new_node = Node::new(value); head.prev = Some(new_node); new_node.next = Some(head);

C. let new_node = Node::new(value); new_node.next = Some(tail); tail.prev = Some(new_node);

D. let new_node = Node::new(value); tail.next = Some(new_node); new_node.prev = Some(tail);

Solution

1. Step 1: Create new node with given value

   Use Node::new(value) to create a new node.

2. Step 2: Link new node after tail

   Set tail.next to new_node and new_node.prev to tail to insert at end.

3. Final Answer:

   let new_node = Node::new(value); tail.next = Some(new_node); new_node.prev = Some(tail); -> Option D

4. Quick Check:

   New node after tail = let new_node = Node::new(value); tail.next = Some(new_node); new_node.prev = Some(tail); [OK]

Hint: New node's prev points to tail; tail's next points to new node [OK]

Common Mistakes:

• Linking new node before head instead of after tail
• Swapping next and prev pointers incorrectly
• Not updating tail's next pointer

3. Given the Rust code below, what will be the printed list after inserting 4 at the end?

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

// Assume list initially: 1 <-> 2 <-> 3
// Insert 4 at end
// Print list from head to tail

medium

A. 1 <-> 2 <-> 3 <-> 4 <-> null

B. 4 <-> 1 <-> 2 <-> 3 <-> null

C. 1 <-> 2 <-> 4 <-> 3 <-> null

D. 1 <-> 2 <-> 3 <-> null

Solution

1. Step 1: Understand initial list structure

   The list is 1 linked to 2, linked to 3, with 3 as tail.

2. Step 2: Insert 4 at the end

   Adding 4 after 3 updates 3.next to 4 and 4.prev to 3.

3. Final Answer:

   1 <-> 2 <-> 3 <-> 4 <-> null -> Option A

4. Quick Check:

   Insert at end adds 4 after 3 [OK]

Hint: New node appears after last node in printed list [OK]

Common Mistakes:

• Inserting new node at start instead of end
• Not updating next pointer of last node
• Printing list without new node

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

fn insert_end(tail: &mut Option, value: i32) {
    let mut new_node = Box::new(Node::new(value));
    new_node.prev = tail.clone();
    tail = Some(new_node);
}

medium

A. tail is not updated correctly; should update tail's next pointer

B. new_node.prev should be None for end insertion

C. new_node should not be boxed

D. value should be mutable

Solution

1. Step 1: Check pointer updates

   tail is reassigned locally, but tail's next pointer is not updated to link new_node.

2. Step 2: Correct linking needed

   Must set tail's next to new_node and new_node.prev to tail, then update tail reference.

3. Final Answer:

   tail is not updated correctly; should update tail's next pointer -> Option A

4. Quick Check:

   Update tail.next to new_node [OK]

Hint: Always update tail's next pointer when inserting at end [OK]

Common Mistakes:

• Only reassigning tail without linking nodes
• Setting prev pointer incorrectly
• Ignoring ownership rules in Rust

5. You have a doubly linked list with nodes: 10 <-> 20 <-> 30. You want to insert 25 at the end but also keep a pointer to the middle node for quick access. After insertion, which node should the middle pointer reference to keep it as the middle of the list?

hard

A. 25

B. 20

C. 30

D. 10

Solution

1. Step 1: Understand list before insertion

   List is 10 <-> 20 <-> 30; middle is 20 (second of three nodes).

2. Step 2: Insert 25 at end and find new middle

   List becomes 10 <-> 20 <-> 30 <-> 25. With 4 nodes, middle is between 20 and 30, usually the second node (20) to keep balance.

3. Final Answer:

   20 -> Option B

4. Quick Check:

   Middle of 4 nodes = 2nd node [OK]

Hint: Middle of even nodes is lower middle [OK]

Common Mistakes:

• Moving middle pointer to last inserted node
• Choosing last node as middle
• Not updating middle pointer after insertion