Array Deletion at End in DSA Rust

Mental Model

Removing the last item from a list means just ignoring it from now on.

Analogy: Imagine a stack of plates where you always take the top plate off first. Deleting at the end is like removing the top plate from the stack.

Index: 0   1   2   3   4
Array: 10 -> 20 -> 30 -> 40 -> 50
Length: 5
End points here ->

Dry Run Walkthrough

Input: array: [10, 20, 30, 40, 50], delete last element

Goal: Remove the last element and reduce the array size by one

Step 1: Check if array is empty

10 -> 20 -> 30 -> 40 -> 50, length=5

Why: We must ensure there is something to delete

Step 2: Reduce length by one to remove last element

10 -> 20 -> 30 -> 40, length=4

Why: Shortening length effectively deletes last element

Step 3: Return updated array state

10 -> 20 -> 30 -> 40, length=4

Why: Now array ends before the old last element

Result:

10 -> 20 -> 30 -> 40 -> null
Length: 4

Annotated Code

DSA Rust

fn delete_at_end(arr: &mut Vec<i32>) {
    if arr.is_empty() {
        return; // nothing to delete
    }
    arr.pop(); // remove last element
}

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

if arr.is_empty() { return; }

check if array is empty to avoid error

arr.pop();

remove last element by popping from vector

Output

10 -> 20 -> 30 -> 40 -> null

Complexity Analysis

Time: O(1) because removing the last element does not require shifting any elements

Space: O(1) because no extra space is needed for deletion

vs Alternative: Compared to deleting from the front which requires shifting all elements O(n), deleting at end is faster and simpler

Edge Cases

empty array

function returns immediately without error

DSA Rust

if arr.is_empty() { return; }

array with one element

last element is removed, array becomes empty

DSA Rust

arr.pop();

When to Use This Pattern

When you need to remove the last item from a list quickly, use array deletion at end because it is simple and fast.

Common Mistakes

Mistake: Trying to delete last element by shifting all elements
Fix: Use pop() or reduce length instead of shifting

Summary

Deletes the last element from an array by reducing its size.

Use when you want to remove the most recently added item efficiently.

The key insight is that removing from the end does not require moving other elements.

Practice

1. What happens when you remove the last element from a Rust Vec using pop()?

easy

A. The last element is removed and returned as Some(value).

B. The first element is removed and returned.

C. The entire vector is cleared.

D. The vector becomes immutable.

Solution

1. Step 1: Understand pop() behavior

   The pop() method removes the last element from the vector and returns it wrapped in Some(value) if the vector is not empty.

2. Step 2: Confirm it does not affect other elements

   Only the last element is removed; the rest of the vector remains unchanged.

3. Final Answer:

   The last element is removed and returned as Some(value). -> Option A

4. Quick Check:

   pop() removes last element [OK]

Hint: pop() removes and returns last element wrapped in Some [OK]

Common Mistakes:

• Thinking pop() removes the first element
• Assuming pop() clears the entire vector
• Believing pop() makes vector immutable

2. Which of the following is the correct syntax to remove the last element from a mutable vector v in Rust?

easy

A. v.erase_last();

B. v.remove_last();

C. v.delete_end();

D. v.pop();

Solution

1. Step 1: Recall Rust vector methods

   The standard method to remove the last element from a vector is pop().

2. Step 2: Check method names

   Methods like remove_last(), delete_end(), and erase_last() do not exist in Rust's Vec API.

3. Final Answer:

   v.pop(); -> Option D

4. Quick Check:

   Correct method to remove last element is pop() [OK]

Hint: Use pop() to remove last element from vector [OK]

Common Mistakes:

• Using non-existent methods like remove_last()
• Confusing pop() with remove() which removes by index
• Trying to use erase_last() or delete_end() which are invalid

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

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

medium

A. [10, 20]
None

B. [10, 20, 30]
None

C. [10, 20]
Some(30)

D. [20, 30]
Some(10)

Solution

1. Step 1: Understand pop() effect on vector

   The pop() removes the last element, which is 30, and returns Some(30).

2. Step 2: Check vector after pop

   After removal, the vector contains [10, 20].

3. Final Answer:

   [10, 20] Some(30) -> Option C

4. Quick Check:

   pop() removes last element 30, vector left with [10, 20] [OK]

Hint: pop() returns last element and shortens vector [OK]

Common Mistakes:

• Expecting pop() to remove first element
• Assuming pop() returns None when vector is not empty
• Confusing vector contents after pop

4. Identify the error in the following Rust code that tries to remove the last element from a vector:

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

medium

A. pop() method does not exist for vectors.

B. Cannot call pop() on an immutable vector.

C. pop() removes the first element, not the last.

D. The vector must be empty before calling pop().

Solution

1. Step 1: Check vector mutability

   The vector v is declared immutable with let. To modify it, it must be mutable.

2. Step 2: Understand pop() requirements

   The pop() method requires a mutable vector to remove the last element.

3. Final Answer:

   Cannot call pop() on an immutable vector. -> Option B

4. Quick Check:

   pop() needs mutable vector [OK]

Hint: Make vector mutable with 'mut' before pop() [OK]

Common Mistakes:

• Trying to pop from immutable vector
• Thinking pop() removes first element
• Assuming pop() works on empty vector without error

5. Given a vector v with elements [5, 10, 15, 20], write Rust code to remove the last two elements and print the resulting vector. What will be printed?

hard

A. [5, 10]

B. [5, 10, 15]

C. [15, 20]

D. [5, 10, 15, 20]

Solution

1. Step 1: Remove last element twice using pop()

   Calling pop() twice removes 20 then 15, leaving [5, 10].

2. Step 2: Print the vector after removals

   Printing v now shows [5, 10].

3. Final Answer:

   [5, 10] -> Option A

4. Quick Check:

   Two pops remove last two elements [OK]

Hint: Call pop() twice to remove last two elements [OK]

Common Mistakes:

• Removing only one element instead of two
• Confusing pop() with remove(index)
• Expecting vector to be empty after two pops