Array Insertion at End in DSA Rust

Mental Model

Adding a new item to the end of a list means placing it right after the last item without changing the order of existing items.

Analogy: Imagine a row of boxes on a shelf. To add a new box, you simply put it at the very end of the row, next to the last box.

[1] -> [2] -> [3] -> null
Add new value 4 at the end:
[1] -> [2] -> [3] -> [4] -> null

Dry Run Walkthrough

Input: array: [1, 2, 3], insert value 4 at end

Goal: Add the value 4 to the end of the array without disturbing existing elements

Step 1: Check if there is space at the end of the array

[1] -> [2] -> [3] -> null

Why: We need to ensure the array can hold one more item

Step 2: Place the new value 4 at the next free position after 3

[1] -> [2] -> [3] -> [4] -> null

Why: Inserting at the end keeps the order and adds the new item

Step 3: Update the array size to include the new element

[1] -> [2] -> [3] -> [4] -> null

Why: Size must reflect the new total number of elements

Result:

[1] -> [2] -> [3] -> [4] -> null

Annotated Code

DSA Rust

fn insert_at_end(arr: &mut Vec<i32>, value: i32) {
    // Add value to the end of the vector
    arr.push(value);
}

fn main() {
    let mut arr = vec![1, 2, 3];
    insert_at_end(&mut arr, 4);
    // Print array elements separated by arrows
    for (i, val) in arr.iter().enumerate() {
        if i < arr.len() - 1 {
            print!("{} -> ", val);
        } else {
            print!("{} -> null", val);
        }
    }
    println!();
}

arr.push(value);

Add the new value at the end of the array

for (i, val) in arr.iter().enumerate() {

Traverse the array to print each element

print!("{} -> ", val);

Print element followed by arrow if not last

print!("{} -> null", val);

Print last element followed by null

Output

1 -> 2 -> 3 -> 4 -> null

Complexity Analysis

Time: O(1) because adding at the end of a vector is a constant time operation on average

Space: O(1) because insertion does not require extra space besides the new element

vs Alternative: Compared to inserting at the beginning or middle which requires shifting elements (O(n)), insertion at end is faster and simpler

Edge Cases

empty array

The value is simply added as the first element

DSA Rust

arr.push(value);

array at capacity (vector auto-resizes)

Vector automatically allocates more space before adding the new element

DSA Rust

arr.push(value);

When to Use This Pattern

When you need to add data to the end of a list quickly without disturbing order, use array insertion at end for efficient appending.

Common Mistakes

Mistake: Trying to insert by shifting all elements manually
Fix: Use built-in push method to add at the end without shifting

Summary

Adds a new element to the end of an array or list.

Use when you want to append data quickly without changing existing order.

The key is to place the new item right after the last existing element.

Practice

1. What does inserting an element at the end of an array mean in simple terms?

easy

A. Sorting the array in ascending order

B. Removing the first item from the array

C. Replacing the first item in the array

D. Adding a new item after the last existing item in the array

Solution

1. Step 1: Understand array structure

   An array is a list of items stored in order, starting from the first to the last.

2. Step 2: Define insertion at the end

   Inserting at the end means placing a new item right after the last item, extending the array by one.

3. Final Answer:

   Adding a new item after the last existing item in the array -> Option D

4. Quick Check:

   Insert at end = Add after last [OK]

Hint: Think: new item goes after the last one [OK]

Common Mistakes:

• Confusing insertion at end with removal
• Thinking insertion replaces an item
• Mixing insertion with sorting

2. Which Rust code snippet correctly inserts the value 10 at the end of a mutable vector named vec?

easy

A. vec.push(10);

B. vec.insert(0, 10);

C. vec[vec.len()] = 10;

D. vec.append(10);

Solution

1. Step 1: Identify correct method to add at end

   In Rust, push adds an element to the end of a vector.

2. Step 2: Check other options

   insert(0, 10) adds at start, vec[vec.len()] = 10 causes error (index out of bounds), append(10) is invalid syntax.

3. Final Answer:

   vec.push(10); -> Option A

4. Quick Check:

   Use push() to add at end [OK]

Hint: Use push() to add at the end of a vector [OK]

Common Mistakes:

• Using insert with wrong index
• Trying to assign to vec[vec.len()] directly
• Using append with a single value

3. What will be the output of this Rust code?

let mut numbers = vec![1, 2, 3];
numbers.push(4);
println!("{:?}", numbers);

medium

A. [1, 2, 3]

B. [4, 1, 2, 3]

C. [1, 2, 3, 4]

D. Compilation error

Solution

1. Step 1: Understand initial vector

   The vector numbers starts as [1, 2, 3].

2. Step 2: Apply push operation

   numbers.push(4) adds 4 at the end, making it [1, 2, 3, 4].

3. Final Answer:

   [1, 2, 3, 4] -> Option C

4. Quick Check:

   push(4) adds 4 at end [OK]

Hint: push() adds element at the end [OK]

Common Mistakes:

• Thinking push adds at start
• Expecting original vector unchanged
• Confusing output format

4. Identify the error in this Rust code that tries to insert 5 at the end of a vector:

let numbers = vec![1, 2, 3];
numbers.push(5);

medium

A. Cannot push because vector is immutable

B. push method does not exist for vectors

C. Syntax error in push call

D. No error, code runs fine

Solution

1. Step 1: Check vector mutability

   The vector numbers is declared without mut, so it is immutable.

2. Step 2: Understand push requirements

   push requires the vector to be mutable to add elements.

3. Final Answer:

   Cannot push because vector is immutable -> Option A

4. Quick Check:

   push needs mutable vector [OK]

Hint: Declare vector as mutable to push [OK]

Common Mistakes:

• Forgetting to add mut keyword
• Assuming push works on immutable vectors
• Misreading error as syntax problem

5. Given a vector vec with elements [2, 4, 6], write Rust code to insert the number 8 at the end and then remove the first element. What will be the final vector?

hard

A. [2, 4, 6, 8]

B. [4, 6, 8]

C. [8, 2, 4, 6]

D. [2, 4, 8]

Solution

1. Step 1: Insert 8 at the end

   Using vec.push(8), vector becomes [2, 4, 6, 8].

2. Step 2: Remove the first element

   Using vec.remove(0), removes 2, vector becomes [4, 6, 8].

3. Final Answer:

   [4, 6, 8] -> Option B

4. Quick Check:

   push then remove first = [4,6,8] [OK]

Hint: Push adds end, remove(0) deletes first [OK]

Common Mistakes:

• Removing last instead of first element
• Not updating vector after push
• Confusing remove index