Push Using Linked List Node in DSA Rust - Time & Space Complexity

Time Complexity: Push Using Linked List Node

O(1)

Understanding Time Complexity

We want to understand how long it takes to add a new item to the front of a linked list.

How does the time needed change as the list grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

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

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

This code adds a new node with a value to the front of a linked list.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Creating a new node and updating the head pointer.
• How many times: This happens once per push call, no loops or recursion involved.

How Execution Grows With Input

Adding a node always takes the same steps, no matter how big the list is.

Input Size (n)	Approx. Operations
10	3 (create node, update pointer)
100	3 (same steps, no extra work)
1000	3 (still the same fixed steps)

Pattern observation: The time to push does not grow with the list size; it stays constant.

Final Time Complexity

Time Complexity: O(1)

This means adding a new node to the front takes the same short time no matter how many nodes are already in the list.

Common Mistake

[X] Wrong: "Adding a node takes longer as the list grows because we have to move through the list."

[OK] Correct: We only change the head pointer and the new node's next pointer; we never walk through the list when pushing.

Interview Connect

Knowing that push on a linked list is quick and constant time shows you understand how pointers work and why linked lists are useful for fast insertions.

Self-Check

"What if we had to add a node at the end of the linked list instead? How would the time complexity change?"

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