Create and Initialize Doubly Linked List in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a struct for a doubly linked list node with a value field.

DSA Rust

struct Node<T> {
    value: T,
    prev: Option<Box<Node<T>>>,
    [1]: Option<Box<Node<T>>>,
}

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

Atail

Bhead

Cnext

Dlink

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'head' or 'tail' as node fields instead of 'next'.

Confusing 'prev' and 'next' pointers.

The next field points to the next node in the doubly linked list.

2fill in blank

medium

Complete the code to initialize an empty doubly linked list struct with head and tail pointers.

DSA Rust

struct DoublyLinkedList<T> {
    head: Option<Box<Node<T>>>,
    [1]: Option<Box<Node<T>>>,
}

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

Anext

Btail

Cprev

Droot

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'next' or 'prev' as fields in the list struct instead of 'tail'.

Confusing node fields with list fields.

The tail field points to the last node in the doubly linked list.

3fill in blank

hard

Fix the error in the method to create a new node with a given value.

DSA Rust

impl<T> Node<T> {
    fn new(value: T) -> Self {
        Node {
            value,
            prev: None,
            [1]: None,
        }
    }
}

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

Ahead

Blink

Ctail

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'head' or 'tail' instead of 'next' in node initialization.

Forgetting to initialize the next pointer.

The next pointer should be initialized to None when creating a new node.

4fill in blank

hard

Fill both blanks to implement the constructor for an empty doubly linked list.

DSA Rust

impl<T> DoublyLinkedList<T> {
    fn new() -> Self {
        DoublyLinkedList {
            [1]: None,
            [2]: None,
        }
    }
}

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

Ahead

Bnext

Ctail

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing node pointers instead of list pointers.

Swapping 'head' and 'tail' fields.

The constructor initializes both head and tail to None for an empty list.

5fill in blank

hard

Fill the blanks to implement a method that checks if the doubly linked list is empty.

DSA Rust

impl<T> DoublyLinkedList<T> {
    fn is_empty(&self) -> bool {
        self.[1].is_none()
            && self.[2].is_none()
    }
}

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

Ahead

Btail

Cas_ref()

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Checking only one of head or tail.

Checking next instead of tail.

The method checks if head and tail are both None.

Practice

1. What is the main purpose of a doubly linked list in data structures?

easy

A. To allow traversal in both forward and backward directions

B. To store data in a fixed-size array

C. To sort elements automatically

D. To prevent duplicate values

Solution

1. Step 1: Understand doubly linked list structure

   A doubly linked list has nodes with pointers to both previous and next nodes.

2. Step 2: Identify traversal capability

   This structure allows moving forward and backward through the list easily.

3. Final Answer:

   To allow traversal in both forward and backward directions -> Option A

4. Quick Check:

   Doubly linked list traversal = forward and backward [OK]

Hint: Remember: double links mean two-way movement [OK]

Common Mistakes:

• Confusing doubly linked list with arrays
• Thinking it sorts data automatically
• Assuming it prevents duplicates

2. Which Rust code snippet correctly defines a node struct for a doubly linked list?

easy

A. struct Node { data: i32, next: Node, prev: Node }

B. struct Node { data: i32, next: Option, prev: Option<*mut Node> }

C. struct Node { data: i32, next: Box<Node>, prev: Box<Node> }

D. struct Node { data: i32, next: Option<Node>, prev: Option<Node> }

Solution

1. Step 1: Understand Rust ownership and pointers

   Rust uses Option for next to allow nullable ownership and *mut Node for raw pointer prev.

2. Step 2: Check each option for correctness

   struct Node { data: i32, next: Option, prev: Option<*mut Node> } uses Option for next and Option<*mut Node> for prev, which is correct for doubly linked list nodes in Rust.

3. Final Answer:

   struct Node { data: i32, next: Option, prev: Option<*mut Node> } -> Option B

4. Quick Check:

   Rust doubly linked list node = Option<Box> + raw pointer [OK]

Hint: Use Option<Box> for next and raw pointer for prev in Rust [OK]

Common Mistakes:

• Using direct Node type causing infinite size error
• Using Box<Node> for prev causing ownership issues
• Not using Option to allow null pointers

3. What will be the output after running this Rust code that creates a doubly linked list with nodes 1 and 2?

struct Node {
    data: i32,
    next: Option,
    prev: Option<*mut Node>,
}

fn main() {
    let mut first = Box::new(Node { data: 1, next: None, prev: None });
    let mut second = Box::new(Node { data: 2, next: None, prev: None });

    first.next = Some(second);
    // Set prev pointer
    if let Some(ref mut next_node) = first.next {
        next_node.prev = Some(&mut *first as *mut Node);
    }

    println!("{} -> {} -> null", first.data, first.next.as_ref().unwrap().data);
}

medium

A. 1 -> 2 -> null

B. 2 -> 1 -> null

C. Compilation error due to ownership

D. Runtime panic due to null pointer

Solution

1. Step 1: Analyze node creation and linking

   Two nodes created: first with data 1, second with data 2. first.next points to second, second.prev points back to first.

2. Step 2: Understand ownership rules in Rust

   Assigning first.next = Some(second) moves ownership of second into first.next. However, second is moved and cannot be used after. Also, setting next_node.prev = Some(&mut *first as *mut Node) involves mutable borrow of first while first is already borrowed mutably, causing ownership conflict.

3. Step 3: Compilation error due to ownership and borrowing rules

   The code will not compile due to ownership and borrowing errors.

4. Final Answer:

   Compilation error due to ownership -> Option C

5. Quick Check:

   Rust ownership rules prevent multiple mutable borrows [OK]

Hint: Rust ownership rules prevent multiple mutable borrows [OK]

Common Mistakes:

• Confusing order of nodes in print
• Ignoring unsafe pointer usage
• Assuming compilation error without checking code

4. Identify the error in this Rust code snippet that tries to initialize a doubly linked list node:

struct Node {
    data: i32,
    next: Option,
    prev: Option<*mut Node>,
}

fn main() {
    let mut node = Node { data: 10, next: None, prev: None };
    node.prev = Some(&mut node);
}

medium

A. Cannot assign reference to raw pointer without unsafe block

B. Missing lifetime annotation for prev pointer

C. Cannot borrow `node` as mutable more than once

D. No error, code runs fine

Solution

1. Step 1: Understand raw pointer assignment in Rust

   Assigning a reference (&mut node) to a raw pointer field (prev) requires an unsafe block because raw pointer dereferencing and assignment are unsafe operations.

2. Step 2: Identify missing unsafe block

   The code attempts to assign &mut node to prev without an unsafe block, causing a compilation error.

3. Final Answer:

   Cannot assign reference to raw pointer without unsafe block -> Option A

4. Quick Check:

   Raw pointer assignments require unsafe block in Rust [OK]

Hint: Use unsafe block when assigning raw pointers [OK]

Common Mistakes:

• Ignoring unsafe requirement for raw pointers
• Thinking mutable borrow error occurs here
• Assuming code compiles without error

5. You want to create a doubly linked list in Rust that supports inserting a new node at the front. Which approach correctly initializes the new node and updates pointers?

struct Node {
    data: i32,
    next: Option,
    prev: Option<*mut Node>,
}

fn insert_front(head: &mut Option, value: i32) {
    // Fill in the missing code here
}

hard

A. Create new node with next = None, prev = head; set head to new node without changing old head

B. Create new node with next = None, prev = None; set head to new node without linking

C. Create new node with next = head, prev = head; set head to new node

D. Create new node with next = head.take(), prev = None; if old head exists, set its prev to new node pointer; then set head to new node

Solution

1. Step 1: Create new node with next pointing to old head

   Use head.take() to move old head out safely and assign to new node's next; prev is None because new node is front.

2. Step 2: Update old head's prev pointer if it exists

   If old head exists, set its prev pointer to new node's raw pointer to maintain backward link.

3. Step 3: Update head to point to new node

   Assign new node to head to complete insertion at front.

4. Final Answer:

   Create new node with next = head.take(), prev = None; if old head exists, set its prev to new node pointer; then set head to new node -> Option D

5. Quick Check:

   Insert front updates next, prev, and head correctly [OK]

Hint: Use head.take() and update old head's prev pointer [OK]

Common Mistakes:

• Not updating old head's prev pointer
• Setting prev pointer incorrectly
• Overwriting head without moving old head