Array Deletion at Middle Index in DSA Rust - Execution Trace

Concept Flow - Array Deletion at Middle Index

Start with array

↓

Identify index to delete

↓

Shift elements left from index+1 to end

↓

Reduce array size by 1

↓

Resulting array without deleted element

The flow shows deleting an element by shifting all elements after it one step left, then reducing the array size.

Execution Sample

DSA Rust

let mut arr = vec![10, 20, 30, 40, 50];
let delete_index = 2;
for i in delete_index..arr.len()-1 {
    arr[i] = arr[i+1];
}
arr.pop();

This code deletes the element at index 2 by shifting elements left and popping the last element.

Execution Table

Step	Operation	Index	Array State	Pointer Changes	Visual State
1	Start	-	[10, 20, 30, 40, 50]	delete_index=2	10 -> 20 -> 30 -> 40 -> 50 -> null
2	Shift element	2	[10, 20, 40, 40, 50]	arr[2] = arr[3]	10 -> 20 -> 40 -> 40 -> 50 -> null
3	Shift element	3	[10, 20, 40, 50, 50]	arr[3] = arr[4]	10 -> 20 -> 40 -> 50 -> 50 -> null
4	Pop last element	-	[10, 20, 40, 50]	arr.pop()	10 -> 20 -> 40 -> 50 -> null
5	End	-	[10, 20, 40, 50]	-	10 -> 20 -> 40 -> 50 -> null

💡 Array size reduced by 1 after popping last element; deletion complete.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
arr	[10, 20, 30, 40, 50]	[10, 20, 40, 40, 50]	[10, 20, 40, 50, 50]	[10, 20, 40, 50]	[10, 20, 40, 50]
delete_index	2	2	2	2	2

Key Moments - 3 Insights

Why do we shift elements left instead of just removing the element at the index?

Because arrays have fixed positions, removing an element leaves a gap. Shifting elements left fills that gap, keeping the array continuous as shown in steps 2 and 3.

Why do we pop the last element after shifting?

After shifting, the last element is duplicated. Popping removes this duplicate and reduces the array size, as seen in step 4.

What happens if we delete the last element (index = length-1)?

No shifting is needed; we just pop the last element. This is a special case not shown here but simpler.

Visual Quiz - 3 Questions

Look at the execution table, what is the array state after step 3?

A [10, 20, 30, 40, 50]

B [10, 20, 40, 50, 50]

C [10, 20, 40, 40, 50]

D [10, 20, 40, 50]

💡 Hint

Check the 'Array State' column for step 3 in the execution_table.

At which step does the array size reduce?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look for the 'Pop last element' operation in the execution_table.

If delete_index was 4 (last element), how would the execution change?

A No shifting, just pop the last element

B Shift all elements left

C Pop twice

D No change, same steps

💡 Hint

Recall the key moment about deleting the last element.

Concept Snapshot

Array Deletion at Middle Index:
- Identify index to delete
- Shift elements left from index+1 to end
- Pop last element to reduce size
- Keeps array continuous without gaps
- Works for dynamic arrays like Rust Vec

Full Transcript

This visualization shows how to delete an element from the middle of an array by shifting all elements after it one position to the left, then removing the last element to reduce the array size. The example uses a Rust vector with elements [10, 20, 30, 40, 50] and deletes the element at index 2 (value 30). Each step updates the array state and pointers. Key points include why shifting is necessary to avoid gaps and why popping the last element removes duplicates after shifting. Special case for deleting the last element is also noted. The execution table and variable tracker clearly show the array changes step-by-step.

Practice

1. What happens when you delete the middle element from an array with an odd number of elements?

easy

A. The array size remains the same but the middle element is set to zero.

B. The middle element is removed and the array size decreases by one.

C. The last element is removed instead of the middle element.

D. The array is reversed after deletion.

Solution

1. Step 1: Identify the middle index in an odd-length array

   The middle index is calculated as length divided by 2 (integer division).

2. Step 2: Remove the element at the middle index

   Deleting this element reduces the array size by one and shifts elements after it left.

3. Final Answer:

   The middle element is removed and the array size decreases by one. -> Option B

4. Quick Check:

   Deleting middle element shrinks array [OK]

Hint: Middle index = length / 2 for odd arrays [OK]

Common Mistakes:

• Thinking array size stays the same after deletion
• Removing last element instead of middle
• Not shifting elements after deletion

2. Which Rust code snippet correctly deletes the middle element from a vector v with odd length?

easy

A. v.pop(v.len() / 2);

B. v.delete(v.len() / 2);

C. v.remove(v.len() / 2);

D. v.erase(v.len() / 2);

Solution

1. Step 1: Identify Rust method to remove element by index

   Rust's Vec type uses remove(index) to delete element at given index.

2. Step 2: Calculate middle index and call remove

   Middle index is v.len() / 2. Calling v.remove(v.len() / 2) deletes middle element.

3. Final Answer:

   v.remove(v.len() / 2); -> Option C

4. Quick Check:

   Use remove(index) to delete element [OK]

Hint: Use Vec::remove(index) to delete element [OK]

Common Mistakes:

• Using non-existent methods like delete or erase
• Using pop which removes last element only
• Passing index to pop which takes no arguments

3. What is the output of this Rust code?

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

medium

A. [10, 30, 40, 50]

B. [10, 20, 30, 40]

C. [20, 30, 40, 50]

D. [10, 20, 40, 50]

Solution

1. Step 1: Calculate middle index of vector

   Vector length is 5, so middle index = 5 / 2 = 2.

2. Step 2: Remove element at index 2 and print vector

   Element at index 2 is 30, removed. Remaining vector is [10, 20, 40, 50].

3. Final Answer:

   [10, 20, 40, 50] -> Option D

4. Quick Check:

   Removed middle element 30, vector shrinks [OK]

Hint: Remove element at len()/2 index for middle deletion [OK]

Common Mistakes:

• Removing wrong index element
• Confusing index with value
• Expecting vector size unchanged

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

let mut v = vec![1, 2];
v.remove(v.len() / 2 + 1);
println!("{:?}", v);

medium

A. Index used for removal is off by one, causing panic.

B. Vector cannot be mutable for removal.

C. remove() method does not exist for vectors.

D. The println! macro is used incorrectly.

Solution

1. Step 1: Calculate middle index for even-length vector

   Vector length is 2, middle index should be 2 / 2 = 1.

2. Step 2: Check removal index used in code

   Code uses index 1 + 1 = 2, which is out of bounds.

3. Step 3: Understand consequences

   Index 2 >= length 2 causes runtime panic (out of bounds).

4. Final Answer:

   Index used for removal is off by one, causing panic. -> Option A

5. Quick Check:

   Use correct middle index = len()/2 [OK]

Hint: Middle index is len()/2, no +1 for removal [OK]

Common Mistakes:

• Adding +1 to middle index incorrectly
• Trying to remove from immutable vector
• Misusing remove method name

5. Given a vector v of even length, how can you delete the lower middle element (the one at index len()/2 - 1) and then print the updated vector in Rust?

hard

A. v.remove(v.len() / 2 - 1); println!("{:?}", v);

B. v.remove(v.len() / 2); println!("{:?}", v);

C. v.pop(); println!("{:?}", v);

D. v.remove(v.len() / 2 + 1); println!("{:?}", v);

Solution

1. Step 1: Identify lower middle index for even-length vector

   For even length, lower middle index is len()/2 - 1.

2. Step 2: Remove element at lower middle index and print vector

   Use v.remove(v.len() / 2 - 1) to delete lower middle element, then print with println!("{:?}", v);.

3. Final Answer:

   v.remove(v.len() / 2 - 1); println!("{:?}", v); -> Option A

4. Quick Check:

   Remove lower middle with len()/2 - 1 [OK]

Hint: For even length, lower middle = len()/2 - 1 [OK]

Common Mistakes:

• Removing upper middle instead of lower middle
• Using pop which removes last element
• Adding +1 to index incorrectly