Create and Initialize Doubly Linked List in DSA Rust

Mental Model

A doubly linked list is a chain of nodes where each node knows the one before and the one after it.

Analogy: Imagine a train where each car is connected to the car in front and the car behind, so you can move forward or backward easily.

null ← [head] 1 ↔ 2 ↔ 3 [tail] → null

Dry Run Walkthrough

Input: Create a doubly linked list with values 1, 2, 3 in order

Goal: Build a doubly linked list where each node points to the previous and next nodes correctly

Step 1: Create first node with value 1; head and tail point to it

null ← [head/tail] 1 → null

Why: Start the list with the first node; it is both head and tail

Step 2: Create second node with value 2; link it after first node

null ← 1 ↔ 2 [tail] → null

Why: Add second node and update tail; link previous and next pointers

Step 3: Create third node with value 3; link it after second node

null ← 1 ↔ 2 ↔ 3 [tail] → null

Why: Add third node and update tail; maintain links in both directions

Result:

null ← 1 ↔ 2 ↔ 3 [tail] → null

Annotated Code

DSA Rust

use std::rc::{Rc, Weak};
use std::cell::RefCell;

#[derive(Debug)]
struct Node {
    value: i32,
    prev: Option<Weak<RefCell<Node>>>,
    next: Option<Rc<RefCell<Node>>>,
}

impl Node {
    fn new(value: i32) -> Rc<RefCell<Node>> {
        Rc::new(RefCell::new(Node {
            value,
            prev: None,
            next: None,
        }))
    }
}

struct DoublyLinkedList {
    head: Option<Rc<RefCell<Node>>>,
    tail: Option<Rc<RefCell<Node>>>,
}

impl DoublyLinkedList {
    fn new() -> Self {
        DoublyLinkedList { head: None, tail: None }
    }

    fn append(&mut self, value: i32) {
        let new_node = Node::new(value);
        match self.tail.take() {
            Some(old_tail) => {
                old_tail.borrow_mut().next = Some(new_node.clone()); // link old tail to new node
                new_node.borrow_mut().prev = Some(Rc::downgrade(&old_tail)); // link new node back to old tail
                self.tail = Some(new_node); // update tail to new node
            }
            None => {
                self.head = Some(new_node.clone()); // first node is head
                self.tail = Some(new_node); // first node is tail
            }
        }
    }

    fn print_forward(&self) {
        let mut current = self.head.as_ref();
        while let Some(node) = current {
            print!("{}", node.borrow().value);
            current = node.borrow().next.as_ref();
            if current.is_some() {
                print!(" ↔ ");
            }
        }
        println!();
    }
}

fn main() {
    let mut list = DoublyLinkedList::new();
    list.append(1);
    list.append(2);
    list.append(3);
    list.print_forward();
}

old_tail.borrow_mut().next = Some(new_node.clone()); // link old tail to new node

connect previous tail's next pointer to new node

new_node.borrow_mut().prev = Some(Rc::downgrade(&old_tail)); // link new node back to old tail

connect new node's prev pointer back to old tail

self.tail = Some(new_node); // update tail to new node

update tail pointer to new node

self.head = Some(new_node.clone()); // first node is head

set head pointer when list is empty

self.tail = Some(new_node); // first node is tail

set tail pointer when list is empty

Output

1 ↔ 2 ↔ 3

Complexity Analysis

Time: O(n) to create n nodes because each append adds one node with constant time

Space: O(n) because we store n nodes each with pointers

vs Alternative: Compared to singly linked list, doubly linked list uses more space for prev pointers but allows backward traversal

Edge Cases

Empty list when appending first node

Head and tail both point to the new node

DSA Rust

self.head = Some(new_node.clone()); // first node is head

Appending multiple nodes

Each new node links back to previous tail and updates tail pointer

DSA Rust

old_tail.borrow_mut().next = Some(new_node.clone()); // link old tail to new node

When to Use This Pattern

When you need a list where you can move forward and backward easily, use a doubly linked list to keep track of both previous and next nodes.

Common Mistakes

Mistake: Not updating the prev pointer of the new node to point back to the old tail
Fix: Set new_node.prev to old_tail using a weak reference to maintain backward link

Mistake: Not updating the tail pointer after adding a new node
Fix: Assign self.tail to the new node after linking

Summary

Creates a doubly linked list where each node links to the previous and next nodes.

Use it when you want to traverse a list forwards and backwards efficiently.

Remember to update both next and prev pointers and adjust head and tail correctly.

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