Why Create and Initialize Doubly Linked List in DSA Rust?

The Big Idea

What if you could flip through your list forwards and backwards without losing your place or wasting time?

The Scenario

Imagine you want to keep track of your daily tasks on paper, but you only write them down in a list without any order or way to go back and forth easily.

When you want to add a new task or check previous ones, you have to flip through pages manually, which is slow and confusing.

The Problem

Writing tasks manually means you can only move forward through the list, and going back means starting over or flipping pages back and forth.

This wastes time and causes mistakes, like missing or repeating tasks.

The Solution

A doubly linked list lets you move forward and backward through your tasks easily.

It connects each task to the one before and after it, so you can add, remove, or find tasks quickly without flipping through everything.

Before vs After

✗ Before

let mut tasks = Vec::new();
tasks.push("Task 1");
tasks.push("Task 2");
// No easy way to go back or insert in middle

✓ After

struct Node {
    data: String,
    prev: Option<Box<Node>>,
    next: Option<Box<Node>>,
}
// Create and link nodes for easy forward and backward moves

What It Enables

It enables smooth navigation and updates in lists, making your programs faster and easier to manage.

Real Life Example

Think of a music playlist where you can go to the next or previous song easily without restarting the list.

Key Takeaways

Doubly linked lists let you move both forward and backward.

They make adding and removing items easier anywhere in the list.

They solve the problem of slow, one-way manual lists.

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