Array Insertion at Beginning in DSA Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does inserting an element at the beginning of an array mean?

It means adding a new element at the first position (index 0) of the array, shifting all existing elements one position to the right.

intermediate

In Rust, which data structure is commonly used to allow easy insertion at the beginning?

A VecDeque is often used because it allows efficient insertion at both ends, unlike a Vec which is slower for inserting at the start.

beginner

What happens to the existing elements when you insert at the beginning of a fixed-size array?

All existing elements must be shifted one position to the right to make space for the new element at index 0.

intermediate

Why is inserting at the beginning of a vector (Vec) in Rust less efficient than at the end?

Because inserting at the beginning requires shifting all elements to the right, which takes time proportional to the number of elements (O(n)), while inserting at the end is usually O(1).

beginner

Show a simple Rust code snippet to insert an element at the beginning of a Vec.

```rust
let mut v = vec![2, 3, 4];
v.insert(0, 1); // Insert 1 at index 0
println!("{:?}", v); // Output: [1, 2, 3, 4]
```

What is the index position where a new element is inserted when adding at the beginning of an array?

A Middle index

B 0

C Last index

D 1

Inserting at the beginning means placing the new element at index 0.

Which Rust data structure allows efficient insertion at both the front and back?

A VecDeque

B Vec

C Array

D HashMap

VecDeque supports efficient insertion/removal at both ends.

What must happen to existing elements when inserting at the start of a fixed-size array?

A They shift right by one position

B They stay in place

C They are removed

D They shift left by one position

Elements must move right to make space at index 0.

Why is inserting at the beginning of a Vec slower than at the end?

A Because it requires copying the vector

B Because it requires resizing the vector

C Because it requires sorting the vector

D Because it requires shifting all elements to the right

Shifting elements takes time proportional to the vector size.

What will be the output of this Rust code?

let mut v = vec![2, 3];
v.insert(0, 1);
println!("{:?}", v);

A [3, 2, 1]

B [2, 3, 1]

C [1, 2, 3]

D [2, 1, 3]

Inserting 1 at index 0 shifts existing elements right.

Explain how inserting an element at the beginning of an array affects the existing elements.

Think about what happens to the elements already in the array.

Describe the difference between inserting at the beginning of a Vec and a VecDeque in Rust.

Consider how each data structure handles insertion at the front.

Practice

1. What happens when you insert an element at the beginning of a vector in Rust using insert(0, value)?

easy

A. The element is added at the end of the vector.

B. The element is added at the start, and all other elements shift right by one position.

C. The element replaces the first element without shifting others.

D. The vector size remains the same and no element is added.

Solution

1. Step 1: Understand insert(0, value) behavior

   In Rust, calling insert(0, value) on a vector adds the value at index 0.

2. Step 2: Effect on existing elements

   All existing elements shift one position to the right to make space for the new element.

3. Final Answer:

   The element is added at the start, and all other elements shift right by one position. -> Option B

4. Quick Check:

   Insert at index 0 shifts elements right [OK]

Hint: Insert at index 0 shifts all elements right [OK]

Common Mistakes:

• Thinking insert replaces the first element
• Assuming insert adds at the end
• Believing array size stays the same

2. Which of the following Rust code snippets correctly inserts the value 10 at the beginning of a vector named vec?

easy

A. vec.insert(0, 10);

B. vec.push(10);

C. vec[0] = 10;

D. vec.add(0, 10);

Solution

1. Step 1: Identify correct method for insertion at index

   Rust vectors use insert(index, value) to add elements at a specific position.

2. Step 2: Check each option

   vec.insert(0, 10); uses insert(0, 10), which inserts 10 at the start. vec.push(10); adds at the end. vec[0] = 10; replaces the first element without insertion. vec.add(0, 10); is invalid syntax.

3. Final Answer:

   vec.insert(0, 10); -> Option A

4. Quick Check:

   Use insert(0, value) to add at start [OK]

Hint: Use insert(0, value) to add at beginning [OK]

Common Mistakes:

• Using push() adds at end, not beginning
• Assigning vec[0] replaces element, no insertion
• Using non-existent method add()

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

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

medium

A. [2, 3, 4, 1]

B. [2, 3, 4]

C. [1, 3, 4]

D. [1, 2, 3, 4]

Solution

1. Step 1: Initial vector state

   The vector starts as [2, 3, 4].

2. Step 2: Insert 1 at index 0

   Using vec.insert(0, 1) adds 1 at the start, shifting others right.

3. Final Answer:

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

4. Quick Check:

   Insert at start shifts elements right [OK]

Hint: Insert at 0 adds element at front, shifts others right [OK]

Common Mistakes:

• Expecting element added at end
• Thinking insert replaces element
• Ignoring vector shift after insert

4. Identify the error in this Rust code:

let mut vec = vec![1, 2, 3];
vec.insert(5, 0);

medium

A. The index 5 is out of bounds for the vector of length 3.

B. The vector is immutable; it should be declared mutable.

C. The insert method parameters are reversed; index should be first, value second.

D. The insert method does not exist for vectors.

Solution

1. Step 1: Analyze the insert index

   The vector has length 3, valid insert indices are 0 to 3. Index 5 is out of bounds, causing runtime panic.

2. Step 2: Confirm syntax and mutability

   Parameters follow correct order insert(index, value); vector is declared mutable.

3. Final Answer:

   The index 5 is out of bounds for the vector of length 3. -> Option A

4. Quick Check:

   Insert index must be within vector bounds [OK]

Hint: Check insert(index, value) and index within vector length [OK]

Common Mistakes:

• Reversing insert parameters
• Using out-of-range index
• Forgetting to declare vector mutable

5. You have a vector vec = vec![10, 20, 30]. You want to insert multiple values [1, 2, 3] at the beginning efficiently. Which approach is best in Rust?

hard

A. Use a loop to insert each element at index 0 one by one.

B. Replace the original vector with the new elements only.

C. Create a new vector with the new elements, then extend it with the original vector.

D. Use vec.push() for each new element and then reverse the vector.

Solution

1. Step 1: Analyze inserting multiple elements at start

   Inserting one by one at index 0 shifts elements repeatedly, inefficient for multiple inserts.

2. Step 2: Efficient approach

   Create a new vector with new elements, then extend it with the original vector to combine efficiently.

3. Final Answer:

   Create a new vector with the new elements, then extend it with the original vector. -> Option C

4. Quick Check:

   Prepending by new vector + extend is efficient [OK]

Hint: Prepend multiple by new vector + extend original [OK]

Common Mistakes:

• Inserting elements one by one at index 0 (slow)
• Using push then reversing (extra steps)
• Replacing original vector loses data