Array Deletion at Middle Index in DSA C - 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

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

Execution Sample

DSA C

int arr[] = {10, 20, 30, 40, 50};
int n = 5;
int del_index = 2;
for (int i = del_index; i < n - 1; i++) {
    arr[i] = arr[i + 1];
}
n--;

Deletes element at index 2 by shifting elements left and reducing size.

Execution Table

Step	Operation	Index i	Array State	Array Size
0	Start	-	[10, 20, 30, 40, 50]	5
1	Delete at index 2	2	[10, 20, 40, 40, 50]	5
2	Shift element from index 3 to 2	3	[10, 20, 40, 50, 50]	5
3	Loop exits: i=4 >= n-1	4	[10, 20, 40, 50, 50]	5
4	Reduce size by 1	-	[10, 20, 40, 50]	4

💡 Array size reduced to 4, element at index 2 deleted by shifting elements left.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
arr	[10, 20, 30, 40, 50]	[10, 20, 40, 40, 50]	[10, 20, 40, 50, 50]	[10, 20, 40, 50, 50]	[10, 20, 40, 50]
n	5	5	5	5	4
i	-	2	3	4	-

Key Moments - 3 Insights

Why do we shift elements left after the deleted index?

Because arrays have fixed positions, to remove an element we move all elements after it one step left to fill the gap, as shown in steps 1 to 3 in the execution_table.

Why do we reduce the array size after shifting?

The last element becomes duplicated after shifting, so we reduce the size by 1 to ignore the extra element, as shown in step 4.

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

No shifting is needed; we just reduce the size by 1. This is a special case not shown here but follows the same logic.

Visual Quiz - 3 Questions

Look at the execution_table, what is the array state after step 2?

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

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

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

D [10, 20, 30, 50, 50]

💡 Hint

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

At which step does the array size reduce?

A Step 1

B Step 4

C Step 3

D Step 2

💡 Hint

Look at the 'Array Size' column in the execution_table.

If we delete index 4 instead of 2, how many shifts happen?

A 0 shifts

B 2 shifts

C 1 shift

D 3 shifts

💡 Hint

Deleting the last element requires no shifting, only size reduction.

Concept Snapshot

Array Deletion at Middle Index:
- Identify index to delete.
- Shift all elements after index one step left.
- Reduce array size by 1.
- No gaps remain; array stays contiguous.
- Deleting last element skips shifting.

Full Transcript

This concept shows how to delete an element from the middle of an array. We start with the array and the index to delete. Then we shift every element after that index one position to the left to fill the gap. Finally, we reduce the array size by one to remove the duplicate last element. This keeps the array contiguous without empty spaces. The execution table shows each step of shifting and the array state. Key moments explain why shifting is needed and what happens when deleting the last element. The quiz tests understanding of array states and size changes during deletion.

Practice

1. What happens when you delete the middle element from an array of size 5?
int arr[5] = {10, 20, 30, 40, 50};
Delete the element at index 2 (middle). What is the new array?

easy

A. [10, 20, 40, 50]

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

C. [10, 20, 30, 50]

D. [20, 30, 40, 50]

Solution

1. Step 1: Identify the middle index and element

   The array has 5 elements, so the middle index is 2 (0-based). The element at index 2 is 30.

2. Step 2: Delete the middle element and shift remaining elements

   Remove 30, then shift elements after index 2 left by one: 40 moves to index 2, 50 moves to index 3.

3. Final Answer:

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

4. Quick Check:

   Middle element removed, array size reduced by 1 [OK]

Hint: Remove middle, shift right elements left by one [OK]

Common Mistakes:

• Not shifting elements after deletion
• Deleting wrong index
• Leaving array size unchanged

2. Which of the following C code snippets correctly deletes the middle element from an array arr of size n?

easy

A. for (int i = n/2; i > 0; i--) arr[i] = arr[i - 1]; n--;

B. for (int i = 0; i < n/2; i++) arr[i] = arr[i + 1]; n--;

C. for (int i = n - 1; i > n/2; i--) arr[i] = arr[i - 1]; n--;

D. for (int i = n/2; i < n - 1; i++) arr[i] = arr[i + 1]; n--;

Solution

1. Step 1: Identify the middle index and loop direction

   The middle index is n/2 (integer division). To delete, shift elements after middle left.

2. Step 2: Check loop correctness

   for (int i = n/2; i < n - 1; i++) arr[i] = arr[i + 1]; n--; shifts elements from middle to end left by one, then reduces size. This is correct.

3. Final Answer:

   for (int i = n/2; i < n - 1; i++) arr[i] = arr[i + 1]; n--; -> Option D

4. Quick Check:

   Shift elements after middle left [OK]

Hint: Shift elements from middle to end left by one [OK]

Common Mistakes:

• Shifting elements before middle
• Looping in wrong direction
• Not reducing array size

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

int arr[6] = {5, 10, 15, 20, 25, 30};
int n = 6;
int mid = n / 2;
for (int i = mid; i < n - 1; i++) {
    arr[i] = arr[i + 1];
}
n--;
for (int i = 0; i < n; i++) {
    printf("%d ", arr[i]);
}

medium

A. 5 10 15 20 25 30

B. 5 10 15 20 30

C. 5 10 15 25 30

D. 5 10 20 25 30

Solution

1. Step 1: Calculate middle index and deletion

   n=6, mid=3. Element at index 3 is 20. It will be deleted.

2. Step 2: Shift elements after index 3 left by one

   arr[3] = arr[4] (25), arr[4] = arr[5] (30), n becomes 5.

3. Step 3: Print updated array

   Elements: 5, 10, 15, 25, 30

4. Final Answer:

   5 10 15 25 30 -> Option C

5. Quick Check:

   Deleted middle element, shifted right elements left [OK]

Hint: Delete middle, shift right elements left, print first n-1 elements [OK]

Common Mistakes:

• Printing original array size
• Not shifting elements correctly
• Deleting wrong index

4. Find the error in this code snippet that deletes the middle element from an array arr of size n:

int mid = n / 2;
for (int i = 0; i < mid; i++) {
    arr[i] = arr[i + 1];
}
n--;

medium

A. Middle index calculation is wrong, should be (n-1)/2

B. Loop shifts elements before middle, should shift after middle

C. Array size decrement should be before loop

D. No error, code is correct

Solution

1. Step 1: Analyze loop range and shifting direction

   The loop runs from 0 to mid-1, shifting elements before middle left, which is incorrect.

2. Step 2: Correct shifting after middle index

   To delete middle element, shift elements from middle index to end left by one, not before middle.

3. Final Answer:

   Loop shifts elements before middle, should shift after middle -> Option B

4. Quick Check:

   Shift elements after middle, not before [OK]

Hint: Shift elements after middle, not before [OK]

Common Mistakes:

• Shifting elements before middle
• Wrong loop boundaries
• Not reducing array size

5. Given an array arr of size n where n is even, write the steps to delete the middle two elements and shift the rest. What will be the new array after deleting middle elements from {1, 2, 3, 4, 5, 6}?

hard

A. [1, 2, 5, 6]

B. [1, 2, 3, 6]

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

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

Solution

1. Step 1: Identify middle two indices for even-sized array

   For n=6, middle two indices are 2 and 3 (0-based), elements 3 and 4.

2. Step 2: Delete these two elements and shift remaining elements left

   Shift elements from index 4 and 5 left by two positions: 5 moves to index 2, 6 moves to index 3. Reduce size by 2.

3. Step 3: New array after deletion

   Array becomes [1, 2, 5, 6]

4. Final Answer:

   [1, 2, 5, 6] -> Option A

5. Quick Check:

   Delete two middle elements, shift right elements left by two [OK]

Hint: Delete two middles, shift right elements left by two [OK]

Common Mistakes:

• Deleting only one middle element
• Shifting elements incorrectly
• Not reducing array size by two