Array Insertion at Middle Index in DSA C - Execution Trace

Concept Flow - Array Insertion at Middle Index

Start with array and size

↓

Calculate middle index = size/2

↓

Shift elements right from end to middle

↓

Insert new element at middle index

↓

Increase size by 1

↓

Array updated with new element in middle

The flow shows how to find the middle, shift elements right to make space, insert the new element, and update the size.

Execution Sample

DSA C

int arr[6] = {1, 2, 4, 5, 6};
int size = 5;
int val = 3;
int mid = size / 2;
// Shift and insert
for (int i = size; i > mid; i--) arr[i] = arr[i-1];
arr[mid] = val;
size++;

This code inserts value 3 into the middle of the array by shifting elements right and placing 3 at index 2.

Execution Table

Step	Operation	Array State	Pointer Changes	Visual State
1	Start with array and size	[1, 2, 4, 5, 6, _]	size=5, mid=2	1 -> 2 -> 4 -> 5 -> 6 -> _
2	Calculate middle index	Same	mid=2	1 -> 2 -> 4 -> 5 -> 6 -> _
3	Shift element at index 4 to 5	[1, 2, 4, 5, 6, 6]	i=5	1 -> 2 -> 4 -> 5 -> 6 -> 6
4	Shift element at index 3 to 4	[1, 2, 4, 5, 5, 6]	i=4	1 -> 2 -> 4 -> 5 -> 5 -> 6
5	Shift element at index 2 to 3	[1, 2, 4, 4, 5, 6]	i=3	1 -> 2 -> 4 -> 4 -> 5 -> 6
6	Insert 3 at index 2	[1, 2, 3, 4, 5, 6]	arr[2]=3	1 -> 2 -> 3 -> 4 -> 5 -> 6
7	Increase size by 1	size=6	size=6	1 -> 2 -> 3 -> 4 -> 5 -> 6
8	End	Final array	size=6	1 -> 2 -> 3 -> 4 -> 5 -> 6

💡 All elements shifted right from index 2, new element inserted, size updated to 6

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	After Step 6	Final
arr	[1, 2, 4, 5, 6, _]	[1, 2, 4, 5, 6, 6]	[1, 2, 4, 5, 5, 6]	[1, 2, 4, 4, 5, 6]	[1, 2, 3, 4, 5, 6]	[1, 2, 3, 4, 5, 6]
size	5	5	5	5	5	6
mid	2	2	2	2	2	2
i	N/A	5	4	3	N/A	N/A

Key Moments - 3 Insights

Why do we shift elements starting from the end towards the middle?

Shifting from the end prevents overwriting elements before they are moved, as shown in steps 3 to 5 in the execution_table.

Why is the middle index calculated as size/2?

Because integer division truncates, it gives the correct middle position to insert the new element, as seen in step 2.

What happens if we insert without shifting elements?

Without shifting, the element at the middle index would be overwritten and lost, breaking the array order, which is avoided by steps 3-5.

Visual Quiz - 3 Questions

Look at the execution_table at step 5, what is the array state?

A [1, 2, 4, 5, 5, 6]

B [1, 2, 4, 5, 6, 6]

C [1, 2, 4, 4, 5, 6]

D [1, 2, 3, 4, 5, 6]

💡 Hint

Check the 'Array State' column at step 5 in the execution_table.

At which step is the new value 3 inserted into the array?

A Step 6

B Step 5

C Step 4

D Step 7

💡 Hint

Look for the operation mentioning 'Insert 3' in the execution_table.

If the initial size was 6 instead of 5, how would the middle index change?

A It would be 2

B It would be 3

C It would be 4

D It would be 5

💡 Hint

Middle index is calculated as size/2; check variable_tracker for mid value.

Concept Snapshot

Array Insertion at Middle Index:
- Calculate middle index as size/2
- Shift elements right from end to middle
- Insert new element at middle index
- Increase size by 1
- Maintains order and space in array

Full Transcript

This visual trace shows how to insert a new element into the middle of an array. First, we calculate the middle index by dividing the size by two. Then, starting from the end of the array, we shift each element one position to the right until we reach the middle index. This creates space to insert the new element without overwriting existing data. After inserting the new value at the middle index, we increase the size of the array by one. The execution table tracks each step, showing the array state and pointer changes. Key moments clarify why shifting starts from the end and why the middle index is calculated as size divided by two. The quiz tests understanding of array states and index calculations. This method keeps the array ordered and correctly sized after insertion.