Insert at Middle Specific Position in DSA Rust - Time & Space Complexity

Time Complexity: Insert at Middle Specific Position

O(n)

Understanding Time Complexity

When we insert an element at a specific middle position in a list, the time it takes depends on how far we need to go to reach that position.

We want to understand how the time grows as the list gets bigger.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fn insert_at_middle(vec: &mut Vec<i32>, pos: usize, val: i32) {
    vec.insert(pos, val);
}
    

This code inserts a value at a given position in a vector, shifting elements after that position.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Shifting elements after the insertion position to the right.
• How many times: Number of elements after the position, which depends on input size and position.

How Execution Grows With Input

As the list grows, the number of elements to shift grows roughly with the distance from the insertion point to the end.

Input Size (n)	Approx. Operations
10	About 5 shifts if inserted in middle
100	About 50 shifts
1000	About 500 shifts

Pattern observation: The number of shifts grows roughly proportional to the size of the list.

Final Time Complexity

Time Complexity: O(n)

This means the time to insert grows linearly with the size of the list because elements after the insertion point must move.

Common Mistake

[X] Wrong: "Inserting in the middle is always fast because we just add one element."

[OK] Correct: Actually, elements after the insertion point must shift, so the work depends on how many elements move, not just adding one.

Interview Connect

Understanding how insertion time grows helps you explain trade-offs in data structures and shows you can analyze real code performance clearly.

Self-Check

"What if we changed the data structure to a linked list? How would the time complexity for insertion at a middle position change?"

Practice

1. What does inserting a node at a specific middle position in a linked list mean?

easy

A. Removing a node from the middle of the list

B. Adding a new node only at the start of the list

C. Adding a new node only at the end of the list

D. Adding a new node exactly between two existing nodes at a given position

Solution

1. Step 1: Understand linked list positions

   Positions in a linked list start from 1 at the head. Inserting at a middle position means placing a new node between existing nodes.

2. Step 2: Define insertion at middle

   Inserting at a specific middle position means the new node will be placed after the node at position (pos-1) and before the node at position pos.

3. Final Answer:

   Adding a new node exactly between two existing nodes at a given position -> Option D

4. Quick Check:

   Insert at middle = Add node between nodes [OK]

Hint: Middle insertion means placing node between two nodes [OK]

Common Mistakes:

• Confusing insertion with deletion
• Thinking insertion only happens at start or end
• Ignoring position indexing starting at 1

2. Which Rust code snippet correctly inserts a new node with value 10 at position 3 in a singly linked list?

easy

A. let mut current = &mut head;
for _ in 1..2 {
current = &mut current.as_mut().unwrap().next;
}
let new_node = Some(Box::new(Node { val: 10, next: current.take() }));
*current = new_node;

B. let mut current = &head;
for _ in 1..3 {
current = ¤t.unwrap().next;
}
current = Some(Box::new(Node { val: 10, next: None }));

C. head = Some(Box::new(Node { val: 10, next: head }));

D. let new_node = Node { val: 10, next: None };
head.next = Some(Box::new(new_node));

Solution

1. Step 1: Traverse to position before insertion

   The loop runs from 1 to 2 (pos-1) to reach node at position 2, using mutable references to modify links.

2. Step 2: Insert new node at position 3

   Create new node with value 10, set its next to current node's next, then update current's next to new node.

3. Final Answer:

   Code snippet in option A correctly inserts at position 3 -> Option A

4. Quick Check:

   Traverse to pos-1, link new node next to current next, update current next [OK]

Hint: Traverse to pos-1, then link new node [OK]

Common Mistakes:

• Using immutable references when mutable needed
• Incorrect loop range causing wrong position
• Not updating links properly causing list break

3. What is the output linked list after inserting value 99 at position 2 in the list 1 -> 2 -> 3 -> null using the following Rust code?

let mut head = Some(Box::new(Node { val: 1, next: Some(Box::new(Node { val: 2, next: Some(Box::new(Node { val: 3, next: None })) })) }));

let mut current = &mut head;
for _ in 1..1 {
    current = &mut current.as_mut().unwrap().next;
}
let new_node = Some(Box::new(Node { val: 99, next: current.as_mut().unwrap().next.take() }));
current.as_mut().unwrap().next = new_node;

// Print list code omitted for brevity

medium

A. 1 -> 99 -> 2 -> 3 -> null

B. 1 -> 2 -> 99 -> 3 -> null

C. 99 -> 1 -> 2 -> 3 -> null

D. 1 -> 2 -> 3 -> 99 -> null

Solution

1. Step 1: Traverse to node at position 1

   The loop runs from 1 to 1, which is empty, so no iteration; current points to head node with value 1.

2. Step 2: Insert new node after current

   New node with value 99 is created with next pointing to current's next (node with value 2). Then current's next is updated to new node.

3. Final Answer:

   1 -> 99 -> 2 -> 3 -> null -> Option A

4. Quick Check:

   Insert after position 1 adds 99 between 1 and 2 [OK]

Hint: Insert after pos-1 node, new node points to old next [OK]

Common Mistakes:

• Miscounting loop iterations causing wrong position
• Not updating next pointers correctly
• Confusing node values and positions

4. Identify the error in this Rust code snippet that tries to insert a node at position 2 in a singly linked list:

let mut current = &mut head;
for _ in 0..2 {
    current = &mut current.as_mut().unwrap().next;
}
let new_node = Some(Box::new(Node { val: 5, next: current.take() }));
*current = new_node;

medium

A. The code uses immutable references instead of mutable

B. The loop runs too many times, moving current past the insertion point

C. The new node's next pointer is not set correctly

D. The head pointer is not updated after insertion

Solution

1. Step 1: Analyze loop iteration count

   The loop runs from 0 to 1 (0..2), so two iterations, moving current two nodes ahead, which is past position 2.

2. Step 2: Understand insertion position

   To insert at position 2, current should point to node at position 1 (pos-1). Loop should run once, not twice.

3. Final Answer:

   The loop runs too many times, moving current past the insertion point -> Option B

4. Quick Check:

   Loop count must be pos-1 to insert correctly [OK]

Hint: Loop must run pos-1 times to reach insertion point [OK]

Common Mistakes:

• Off-by-one error in loop range
• Not using mutable references for insertion
• Incorrectly setting new node's next pointer

5. Given a singly linked list and a position that may be beyond the current list length, how should you modify the insertion logic in Rust to insert a node with value 50 at position 5 in the list 10 -> 20 -> 30 -> null?

hard

A. Return an error and do not insert if position is beyond length

B. Insert at the head regardless of position

C. Traverse until the end if position exceeds length, then insert at the end

D. Insert at position 3 instead of 5 automatically

Solution

1. Step 1: Check position against list length

   Since position 5 is beyond current length 3, traverse until the last node to insert at the end.

2. Step 2: Insert new node at end

   Once at last node, set its next pointer to new node with value 50 and next as None.

3. Final Answer:

   Traverse until the end if position exceeds length, then insert at the end -> Option C

4. Quick Check:

   Insert at end if position too large [OK]

Hint: If position too big, insert at list end [OK]

Common Mistakes:

• Crashing or panicking when position is too large
• Ignoring position and inserting at wrong place
• Not handling None next pointers properly