Array Deletion at Beginning in DSA Rust

Mental Model

Removing the first item from a list means shifting all other items one step left to fill the gap.

Analogy: Imagine a line of people waiting to buy tickets. When the first person leaves, everyone else moves forward one step to keep the line tight.

Index:  [0] -> [1] -> [2] -> [3] -> null
Value:  10  ->  20  ->  30  ->  40

Dry Run Walkthrough

Input: array: [10, 20, 30, 40], delete element at beginning

Goal: Remove the first element and shift all others left to keep order

Step 1: Remove element at index 0 (value 10)

Index:  [0] -> [1] -> [2] -> [3] -> null
Value:  10  ->  20  ->  30  ->  40

Why: We start by removing the first element to delete it

Step 2: Shift element at index 1 (20) to index 0

Index:  [0] -> [1] -> [2] -> [3] -> null
Value:  20  ->  20  ->  30  ->  40

Why: Shift left to fill the gap at the start

Step 3: Shift element at index 2 (30) to index 1

Index:  [0] -> [1] -> [2] -> [3] -> null
Value:  20  ->  30  ->  30  ->  40

Why: Continue shifting elements left

Step 4: Shift element at index 3 (40) to index 2

Index:  [0] -> [1] -> [2] -> [3] -> null
Value:  20  ->  30  ->  40  ->  40

Why: Shift last element left to fill the gap

Step 5: Remove duplicate last element at index 3

Index:  [0] -> [1] -> [2] -> null
Value:  20  ->  30  ->  40

Why: Remove the extra copy at the end after shifting

Result:

Index:  [0] -> [1] -> [2] -> null
Value:  20  ->  30  ->  40

Annotated Code

DSA Rust

fn delete_at_beginning(arr: &mut Vec<i32>) {
    if arr.is_empty() {
        return; // no elements to delete
    }
    for i in 1..arr.len() {
        arr[i - 1] = arr[i]; // shift element left
    }
    arr.pop(); // remove last duplicate element
}

fn main() {
    let mut arr = vec![10, 20, 30, 40];
    delete_at_beginning(&mut arr);
    for val in &arr {
        print!("{} ", val);
    }
    println!();
}

if arr.is_empty() { return; }

check if array is empty to avoid errors

for i in 1..arr.len() { arr[i - 1] = arr[i]; }

shift each element one position left to overwrite the first element

arr.pop();

remove the last element which is now duplicated after shifting

Output

20 30 40 

Complexity Analysis

Time: O(n) because we shift all elements except the first one once

Space: O(1) because we modify the array in place without extra storage

vs Alternative: Compared to using a linked list where deletion at beginning is O(1), array deletion requires shifting all elements, making it slower for large arrays

Edge Cases

empty array

function returns immediately without error

DSA Rust

if arr.is_empty() { return; }

array with one element

pop removes the only element, resulting in empty array

DSA Rust

arr.pop();

When to Use This Pattern

When you need to remove the first item from a list stored as an array, expect to shift all other items left to fill the gap.

Common Mistakes

Mistake: Not shifting elements left, just removing the first element without adjusting others
Fix: Shift all elements left by copying each element to the previous index before popping the last

Mistake: Popping before shifting, losing data
Fix: Shift first, then pop the last element to remove duplicate

Summary

Deletes the first element of an array by shifting all other elements left and removing the last duplicate.

Use when you need to remove the front item from an array but keep the order of remaining items.

The key insight is that arrays require shifting elements left to fill the gap after deletion at the start.

Practice

1. What happens when you delete the first element from an array in Rust using remove(0)?

easy

A. The array elements remain unchanged.

B. The last element is removed instead of the first.

C. The array becomes empty regardless of its original size.

D. The first element is removed and all other elements shift left by one position.

Solution

1. Step 1: Understand remove(0) method

   The remove(0) method removes the element at index 0, which is the first element in the array.

2. Step 2: Effect on array elements

   After removal, all elements to the right shift left by one to fill the gap, reducing the array length by one.

3. Final Answer:

   The first element is removed and all other elements shift left by one position. -> Option D

4. Quick Check:

   Deleting at start shifts elements left [OK]

Hint: Deleting at index 0 shifts all elements left by one [OK]

Common Mistakes:

• Thinking last element is removed instead of first
• Assuming array size stays the same
• Believing elements do not shift after deletion

2. Which of the following Rust code snippets correctly deletes the first element from a vector v?

easy

A. v.remove(0);

B. v.delete(0);

C. v.pop_front();

D. v.shift();

Solution

1. Step 1: Identify correct Rust method for deletion at index

   Rust vectors use remove(index) to delete element at a specific position.

2. Step 2: Check other options for validity

   delete, pop_front, and shift are not valid Rust vector methods.

3. Final Answer:

   v.remove(0); -> Option A

4. Quick Check:

   Use remove(0) to delete first element [OK]

Hint: Use remove(0) to delete first element in Rust vector [OK]

Common Mistakes:

• Using non-existent methods like pop_front or shift
• Confusing Rust with other languages' syntax
• Trying to use delete which is invalid in Rust

3. What is the output of the following Rust code?

let mut v = vec![10, 20, 30, 40];
v.remove(0);
println!("{:?}", v);

medium

A. [20, 30, 40]

B. [10, 20, 30, 40]

C. [30, 40]

D. [40]

Solution

1. Step 1: Initial vector elements

   The vector v starts as [10, 20, 30, 40].

2. Step 2: Remove first element

   v.remove(0) removes 10, shifting remaining elements left.

3. Step 3: Resulting vector

   After removal, v becomes [20, 30, 40].

4. Final Answer:

   [20, 30, 40] -> Option A

5. Quick Check:

   Remove first element shifts left [OK]

Hint: Removing index 0 drops first element, shifts others left [OK]

Common Mistakes:

• Expecting original vector unchanged
• Thinking multiple elements removed
• Confusing output format

4. Identify the error in this Rust code that tries to delete the first element of a vector:

let mut v = vec![1, 2, 3];
v.remove();

medium

A. Cannot remove elements from a vector.

B. Missing index argument in remove method.

C. remove method does not exist for vectors.

D. Vector cannot be mutable.

Solution

1. Step 1: Check method signature

   The remove method requires an index argument specifying which element to remove.

2. Step 2: Identify missing argument

   The code calls v.remove() without any index, causing a compile error.

3. Final Answer:

   Missing index argument in remove method. -> Option B

4. Quick Check:

   remove needs index argument [OK]

Hint: Always provide index to remove method [OK]

Common Mistakes:

• Calling remove without index
• Thinking remove works like pop() without arguments
• Assuming vector immutability causes error

5. Given a vector v = vec![5, 10, 15, 20, 25], write Rust code to delete the first two elements and print the resulting vector. What will be the output?

hard

A. [5, 10, 15]

B. [10, 15, 20, 25]

C. [15, 20, 25]

D. [20, 25]

Solution

1. Step 1: Remove first element twice

   Calling v.remove(0) twice removes elements at index 0 each time, first 5 then 10.

2. Step 2: Resulting vector after removals

   After removals, vector becomes [15, 20, 25].

3. Final Answer:

   [15, 20, 25] -> Option C

4. Quick Check:

   Two removals at index 0 drop first two elements [OK]

Hint: Remove index 0 repeatedly to delete from start [OK]

Common Mistakes:

• Removing only once instead of twice
• Removing wrong indices after first removal
• Expecting original vector unchanged