Array Insertion at Middle Index in DSA Rust - Execution Trace

Concept Flow - Array Insertion at Middle Index

Start with array

↓

Calculate middle index

↓

Shift elements right from middle

↓

Insert new element at middle

↓

Array updated with new element

The flow shows starting with an array, finding the middle index, shifting elements right to make space, inserting the new element, and finishing with the updated array.

Execution Sample

DSA Rust

let mut arr = vec![1, 2, 4, 5];
let mid = arr.len() / 2;
arr.insert(mid, 3);
println!("{:?}", arr);

This code inserts the number 3 into the middle of the array [1, 2, 4, 5].

Execution Table

Step	Operation	Middle Index	Array Before	Shifted Elements	Array After	Visual State
1	Start with array	-	[1, 2, 4, 5]	-	[1, 2, 4, 5]	1 -> 2 -> 4 -> 5 -> null
2	Calculate middle index	2	[1, 2, 4, 5]	-	[1, 2, 4, 5]	1 -> 2 -> 4 -> 5 -> null
3	Shift elements right from index 2	2	[1, 2, 4, 5]	4 and 5 shifted right	[1, 2, _, 4, 5]	1 -> 2 -> _ -> 4 -> 5 -> null
4	Insert 3 at index 2	2	[1, 2, _, 4, 5]	-	[1, 2, 3, 4, 5]	1 -> 2 -> 3 -> 4 -> 5 -> null
5	Print final array	-	[1, 2, 3, 4, 5]	-	[1, 2, 3, 4, 5]	1 -> 2 -> 3 -> 4 -> 5 -> null
6	End	-	-	-	-	Insertion complete

💡 Insertion done, array length increased by 1

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
arr	[1, 2, 4, 5]	[1, 2, 4, 5]	[1, 2, _, 4, 5]	[1, 2, 3, 4, 5]	[1, 2, 3, 4, 5]
mid	-	2	2	2	2

Key Moments - 3 Insights

Why do we shift elements to the right before inserting?

Because the array needs space at the middle index to insert the new element without overwriting existing data. See Step 3 in execution_table where elements 4 and 5 are shifted right.

How is the middle index calculated for even-length arrays?

The middle index is the length divided by 2 using integer division, which gives the left-middle position. In this example, length 4 / 2 = 2, as shown in Step 2.

What happens to the array length after insertion?

The array length increases by 1 because a new element is added. The final array has 5 elements instead of 4, as seen in Step 5.

Visual Quiz - 3 Questions

Look at the execution_table, what is the middle index calculated at Step 2?

A 1

B 3

C 2

D 4

💡 Hint

Check the 'Middle Index' column in Step 2 of execution_table.

At which step are elements shifted to the right to make space?

A Step 3

B Step 4

C Step 2

D Step 5

💡 Hint

Look for the 'Shift elements right' operation in the execution_table.

If the array was [1, 2, 3], what would be the middle index for insertion?

A 0

B 1

C 2

D 3

💡 Hint

Middle index is length divided by 2 using integer division; length 3 / 2 = 1.

Concept Snapshot

Array Insertion at Middle Index:
- Calculate middle index as length / 2
- Shift elements right from middle to end
- Insert new element at middle index
- Array size increases by 1
- Preserves order of existing elements

Full Transcript

This visualization shows how to insert an element into the middle of an array. First, we start with the original array. Then, we calculate the middle index by dividing the array length by two. Next, we shift all elements from the middle index to the right by one position to make space. After that, we insert the new element at the middle index. Finally, the array is updated with the new element, and its length increases by one. This process preserves the order of the original elements while adding the new one in the middle.

Practice

1. What does inserting an element at the middle index of an array mean?

easy

A. Adding a new element at the end of the array

B. Replacing the middle element with a new one

C. Adding a new element exactly in the center, shifting others right

D. Removing the middle element from the array

Solution

1. Step 1: Understand middle index insertion

   Inserting at the middle means placing a new element at the center position, pushing existing elements to the right.

2. Step 2: Differentiate from other operations

   Replacing or removing elements changes existing data, but insertion adds a new element without deletion.

3. Final Answer:

   Adding a new element exactly in the center, shifting others right -> Option C

4. Quick Check:

   Middle insertion means add and shift [OK]

Hint: Middle insertion adds element, shifts others right [OK]

Common Mistakes:

• Thinking insertion replaces an element
• Confusing insertion with removal
• Assuming insertion always happens at end

2. Which Rust code correctly inserts the value 99 at the middle index of a vector named vec?

easy

A. vec.insert(vec.len() / 2, 99);

B. vec.push(99);

C. vec[vec.len() / 2] = 99;

D. vec.remove(vec.len() / 2); vec.push(99);

Solution

1. Step 1: Identify correct insertion method

   Rust's insert method adds an element at a given index, shifting others right.

2. Step 2: Calculate middle index and apply insert

   Using vec.len() / 2 gives the middle index; vec.insert places 99 there correctly.

3. Final Answer:

   vec.insert(vec.len() / 2, 99); -> Option A

4. Quick Check:

   Use insert with middle index [OK]

Hint: Use vec.insert(middle_index, value) to insert [OK]

Common Mistakes:

• Using push adds at end, not middle
• Assigning with vec[index] replaces, not inserts
• Removing then pushing changes order

3. What is the output of this Rust code?

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

medium

A. [10, 20, 30, 25, 40]

B. [10, 20, 25, 30, 40]

C. [10, 25, 20, 30, 40]

D. [25, 10, 20, 30, 40]

Solution

1. Step 1: Calculate middle index

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

2. Step 2: Insert 25 at index 2

   Inserting 25 at index 2 shifts elements at and after index 2 right: 30 and 40 move right.

3. Final Answer:

   [10, 20, 25, 30, 40] -> Option B

4. Quick Check:

   Insert at middle shifts elements right [OK]

Hint: Middle index = length/2; insert shifts right [OK]

Common Mistakes:

• Inserting at wrong index
• Confusing insert with replace
• Miscounting vector length

4. Identify the error in this Rust code that tries to insert 50 at the middle of vec:

let mut vec = vec![1, 2, 3, 4, 5];
let mid = vec.len() / 2;
vec[mid] = 50;
println!("{:?}", vec);

medium

A. Using assignment replaces element instead of inserting

B. vec.len() / 2 is incorrect middle index

C. vec is immutable, cannot modify

D. println! syntax is wrong

Solution

1. Step 1: Understand vec[mid] = 50;

   This replaces the element at index mid instead of inserting a new one.

2. Step 2: Correct method is insert

   To insert, use vec.insert(mid, 50); which shifts elements right.

3. Final Answer:

   Using assignment replaces element instead of inserting -> Option A

4. Quick Check:

   Assignment replaces, insert adds [OK]

Hint: Use insert() to add, not assignment [OK]

Common Mistakes:

• Replacing element instead of inserting
• Misunderstanding vector mutability
• Incorrect println! usage

5. Given a vector vec = vec![5, 10, 15, 20, 25, 30], write Rust code to insert 17 exactly in the middle so that the vector remains sorted. What will be the vector after insertion?

hard

A. [5, 10, 15, 20, 25, 30, 12]

B. [5, 10, 15, 12, 20, 25, 30]

C. [12, 5, 10, 15, 20, 25, 30]

D. [5, 10, 15, 17, 20, 25, 30]

Solution

1. Step 1: Find middle index for insertion

   Vector length is 6, middle index is 6 / 2 = 3.

2. Step 2: Insert 17 at index 3 to keep sorted order

   Inserting 17 at index 3 shifts elements 20, 25, 30 right, keeping order.

3. Final Answer:

   [5, 10, 15, 17, 20, 25, 30] -> Option D

4. Quick Check:

   Insert 17 at middle index 3 to keep sorted [OK]

Hint: Insert at length/2 to keep sorted vector [OK]

Common Mistakes:

• Inserting at wrong index breaking order
• Appending instead of inserting
• Replacing element instead of inserting