Push Using Linked List Node in DSA Rust - Build from Scratch

Push Using Linked List Node

📖 Scenario: You are building a simple linked list to store numbers. Each number is stored in a Node that points to the next number. You want to add new numbers to the front of the list.

🎯 Goal: Create a linked list and add new nodes to the front using the push method. Finally, print the list to see the order of numbers.

📋 What You'll Learn

Create a struct called Node with fields value (i32) and next (Option>)

Create a struct called LinkedList with a field head (Option>)

Create a method push for LinkedList that adds a new node to the front

Print the linked list values in order separated by -> and ending with null

💡 Why This Matters

🌍 Real World

Linked lists are used in many programs to store data where you need fast insertion and deletion at the front.

💼 Career

Understanding linked lists is important for software development jobs that involve data structures and memory management.

1

Create the Node and LinkedList structs

Create a struct called Node with fields value: i32 and next: Option>. Also create a struct called LinkedList with a field head: Option>.

DSA Rust

// Your code here

Hint

Use struct keyword to define Node and LinkedList. Use Option> for the next and head fields.

2

Add the push method to LinkedList

Add an impl block for LinkedList and create a method called push that takes &mut self and value: i32. Inside push, create a new Node with the given value and set its next to the current head. Then update head to point to this new node.

DSA Rust

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

struct LinkedList {
    head: Option>,
}

// Your code here

Hint

Use self.head.take() to move the current head into the new node's next. Then set self.head to Some(new_node).

3

Create a new LinkedList and push values

Create a mutable variable called list of type LinkedList with head set to None. Then use list.push(10), list.push(20), and list.push(30) to add three nodes to the list.

DSA Rust

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

struct LinkedList {
    head: Option>,
}

impl LinkedList {
    fn push(&mut self, value: i32) {
        let new_node = Box::new(Node {
            value,
            next: self.head.take(),
        });
        self.head = Some(new_node);
    }
}

// Your code here

Hint

Create list with head: None. Then call push three times with values 10, 20, and 30.

4

Print the linked list values

Add code in main to print the values in the linked list starting from head. Use a while let loop with a variable current to traverse nodes. Print each value followed by -> . After the loop, print null.

DSA Rust

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

struct LinkedList {
    head: Option>,
}

impl LinkedList {
    fn push(&mut self, value: i32) {
        let new_node = Box::new(Node {
            value,
            next: self.head.take(),
        });
        self.head = Some(new_node);
    }
}

fn main() {
    let mut list = LinkedList { head: None };
    list.push(10);
    list.push(20);
    list.push(30);

    // Traverse and print the list values
    // Your code here
}

Hint

Use a while let Some(node) = current loop to traverse. Print each node.value followed by -> . After the loop, print null.

Practice

1. What does the push operation do in a linked list when using a node?

easy

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

B. Removes the last node from the list

C. Searches for a node with a specific value

D. Deletes the entire list

Solution

1. Step 1: Understand push operation in linked list

   The push operation adds a new node to the linked list.

2. Step 2: Identify where the new node is added

   In a singly linked list, push usually adds the new node at the start (head) of the list.

3. Final Answer:

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

4. Quick Check:

   Push = Add at head [OK]

Hint: Push always adds node at the start of the list [OK]

Common Mistakes:

• Thinking push adds at the end
• Confusing push with pop
• Assuming push deletes nodes

2. Which of the following Rust code snippets correctly creates a new node and pushes it to the front of a linked list?

easy

A. head = Some(Node { data: 5, next: None });

B. let new_node = Node { data: 5, next: None }; head = new_node.next;

C. let new_node = Box::new(Node { data: 5, next: head }); head = Some(new_node);

D. let new_node = Box::new(Node { data: 5 }); head = new_node.next;

Solution

1. Step 1: Check node creation with Box and linking

   let new_node = Box::new(Node { data: 5, next: head }); head = Some(new_node); creates a boxed node with data 5 and next pointing to current head.

2. Step 2: Assign new node as new head

   Then head is updated to Some(new_node), correctly pushing at front.

3. Final Answer:

   let new_node = Box::new(Node { data: 5, next: head }); head = Some(new_node); -> Option C

4. Quick Check:

   Boxed node with next=head, then head=Some(new_node) [OK]

Hint: Use Box::new and set next to current head [OK]

Common Mistakes:

• Not boxing the node
• Not updating head correctly
• Setting next to None instead of head

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

struct Node {
    data: i32,
    next: Option,
}

fn push(head: &mut Option, data: i32) {
    let new_node = Box::new(Node { data, next: head.take() });
    *head = Some(new_node);
}

fn print_list(head: &Option) {
    let mut current = head;
    while let Some(node) = current {
        print!("{} -> ", node.data);
        current = &node.next;
    }
    println!("null");
}

fn main() {
    let mut head = None;
    push(&mut head, 10);
    push(&mut head, 20);
    push(&mut head, 30);
    print_list(&head);
}

medium

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

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

C. null

D. Compilation error

Solution

1. Step 1: Trace push calls and list building

   First push adds 10 as head. Second push adds 20 before 10. Third push adds 30 before 20.

2. Step 2: Print list from head

   Print starts at head (30), then 20, then 10, then null.

3. Final Answer:

   30 -> 20 -> 10 -> null -> Option B

4. Quick Check:

   Last pushed node is head, so list is 30->20->10->null [OK]

Hint: Last pushed node appears first in list [OK]

Common Mistakes:

• Assuming push adds at end
• Confusing order of nodes
• Ignoring Option and Box usage

4. Identify the error in this Rust function that tries to push a new node to the linked list head:

fn push(head: &mut Option, data: i32) {
    let new_node = Box::new(Node { data, next: head });
    *head = Some(new_node);
}

medium

A. Cannot assign &Option to next, must use head.take()

B. Missing return statement

C. Box::new cannot be used here

D. Data type i32 is incorrect

Solution

1. Step 1: Analyze next field assignment

   The next field expects Option, but head is &mut Option, a reference.

2. Step 2: Correct usage with head.take()

   Using head.take() moves the Option out, allowing ownership transfer to next.

3. Final Answer:

   Cannot assign &Option to next, must use head.take() -> Option A

4. Quick Check:

   Use head.take() to move ownership [OK]

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

Common Mistakes:

• Assigning reference instead of owned Option
• Ignoring Rust ownership rules
• Thinking Box::new is invalid here

5. Given a linked list implemented with nodes in Rust, how would you modify the push function to prevent memory leaks when repeatedly pushing nodes?

hard

A. Use clone() on nodes to duplicate data

B. Use raw pointers instead of Box to manage nodes

C. Manually call drop() on old head before pushing

D. Use head.take() to transfer ownership and avoid dangling references

Solution

1. Step 1: Understand ownership in Rust linked list

   Each node owns the next node via Box. To avoid leaks, ownership must be properly transferred.

2. Step 2: Use head.take() to move ownership safely

   head.take() replaces head with None and moves ownership to new node's next, preventing leaks.

3. Final Answer:

   Use head.take() to transfer ownership and avoid dangling references -> Option D

4. Quick Check:

   head.take() safely moves ownership, preventing leaks [OK]

Hint: Use head.take() to transfer ownership safely [OK]

Common Mistakes:

• Using raw pointers causing unsafe code
• Calling drop manually causing double free
• Cloning nodes causing unnecessary copies