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

The flow shows starting with an array, choosing the index to delete, shifting elements left to overwrite it, reducing size, and ending with the updated array.

Execution Sample

DSA C#

int[] arr = {10, 20, 30, 40, 50};
int deleteIndex = 2;
for (int i = deleteIndex; i < arr.Length - 1; i++)
    arr[i] = arr[i + 1];
int newSize = arr.Length - 1;

This code deletes the element at index 2 by shifting elements left and reducing the array size by one.

Execution Table

Step	Operation	Index	Array State	Pointer Changes	Visual State
1	Start	-	[10, 20, 30, 40, 50]	deleteIndex=2	10 -> 20 -> 30 -> 40 -> 50 -> null
2	Shift element left	i=2	[10, 20, 40, 40, 50]	arr[2] = arr[3]	10 -> 20 -> 40 -> 40 -> 50 -> null
3	Shift element left	i=3	[10, 20, 40, 50, 50]	arr[3] = arr[4]	10 -> 20 -> 40 -> 50 -> 50 -> null
4	Reduce size	-	Logical size = 4	-	10 -> 20 -> 40 -> 50 -> null
5	End	-	[10, 20, 40, 50]	Size reduced	10 -> 20 -> 40 -> 50 -> null

💡 Array size reduced by 1 after shifting elements left to overwrite deleted index.

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, 50]	[10, 20, 40, 50] (logical)
deleteIndex	2	2	2	2	2
newSize	5	5	5	4	4

Key Moments - 3 Insights

Why do we shift elements left after deleting?

Because arrays have fixed size, we overwrite the deleted element by moving all elements after it one step left to fill the gap, as shown in steps 2 and 3.

Why do we reduce the logical size instead of physically resizing the array?

In many languages like C#, arrays have fixed size. We keep the physical array but track a smaller logical size to ignore the last element, as shown in step 4.

What happens to the last element after shifting?

It remains in the array but is ignored because the logical size is reduced, so it is considered outside the valid elements, as shown in step 4 and 5.

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 is the logical size of the array reduced?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

Look for 'Reduce size' operation in the execution table.

If we delete the element at index 1 instead, what would be the array state after the first shift?

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

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

C [10, 30, 30, 40, 50]

D [10, 20, 40, 50, 50]

💡 Hint

Deleting index 1 means shifting elements starting from index 1 left by one.

Concept Snapshot

Array Deletion at Middle Index:
- Identify index to delete.
- Shift all elements after index left by one.
- Reduce logical size by one.
- Physical array size stays same.
- Last element ignored after size reduction.

Full Transcript

This visualization shows how to delete an element from the middle of an array. We start with the full array and the index to delete. Then, we shift each element after that index one position to the left to overwrite the deleted element. After shifting, we reduce the logical size of the array by one to ignore the last element, which remains but is no longer considered part of the array. This process keeps the array contiguous without gaps. The execution table tracks each step, showing how the array changes and how pointers move. The variable tracker shows the array and size changes after each step. Key moments clarify why shifting is needed and why size reduction is logical, not physical. 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 in C#?

easy

A. The element is removed and all elements after it shift left by one position.

B. The array size automatically decreases by one without shifting elements.

C. The middle element is replaced by zero but array size stays the same.

D. The array throws an error because arrays have fixed size.

Solution

1. Step 1: Understand array behavior on deletion

   In C#, arrays have fixed size, so to delete an element, we shift elements after it left to overwrite it.

2. Step 2: Effect on array elements

   After shifting, the last element is duplicated or ignored logically, but the middle element is effectively removed from the sequence.

3. Final Answer:

   The element is removed and all elements after it shift left by one position. -> Option A

4. Quick Check:

   Deletion shifts elements left [OK]

Hint: Deleting means shifting elements left to fill the gap [OK]

Common Mistakes:

• Thinking array size changes automatically
• Assuming deletion replaces element with zero
• Believing arrays throw error on deletion

2. Which of the following C# code snippets correctly deletes the middle element from an integer array arr of odd length?

easy

A. int mid = arr.Length / 2; arr[mid] = 0;

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

C. int mid = arr.Length / 2; arr.RemoveAt(mid);

D. int mid = arr.Length / 2; Array.Delete(arr, mid);

Solution

1. Step 1: Identify valid deletion method in arrays

   Arrays in C# do not have RemoveAt or Delete methods; we must shift elements manually.

2. Step 2: Check code correctness

   int mid = arr.Length / 2; for(int i = mid; i < arr.Length - 1; i++) arr[i] = arr[i + 1]; calculates middle index and shifts elements left from middle to end-1, correctly deleting the middle element.

3. Final Answer:

   int mid = arr.Length / 2; for(int i = mid; i < arr.Length - 1; i++) arr[i] = arr[i + 1]; -> Option B

4. Quick Check:

   Manual shift after mid index [OK]

Hint: Use loop to shift elements left from middle index [OK]

Common Mistakes:

• Using non-existent array methods like RemoveAt
• Just setting middle element to zero without shifting
• Trying to delete without shifting elements

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

int[] arr = {10, 20, 30, 40, 50};
int mid = arr.Length / 2;
for(int i = mid; i < arr.Length - 1; i++)
    arr[i] = arr[i + 1];
for(int i = 0; i < arr.Length - 1; i++)
    Console.Write(arr[i] + " ");

medium

A. 10 20 30 50

B. 10 20 30 40 50

C. 10 20 40 50

D. 10 20 40 50 50

Solution

1. Step 1: Calculate middle index and shift elements

   Array length is 5, mid = 2. Loop shifts arr[2] = arr[3] (40), arr[3] = arr[4] (50).

2. Step 2: Print elements except last

   Loop prints arr[0]=10, arr[1]=20, arr[2]=40, arr[3]=50. Last element ignored.

3. Final Answer:

   10 20 40 50 -> Option C

4. Quick Check:

   Shifted middle element out = 10 20 40 50 [OK]

Hint: Shift elements left, print all but last [OK]

Common Mistakes:

• Printing full array including last duplicate
• Not shifting elements correctly
• Confusing middle index calculation

4. Find the error in this code that tries to delete the middle element from an array arr of length 6:

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

medium

A. Array elements are not shifted correctly.

B. Middle index calculation is wrong for even length arrays.

C. No error; code works fine.

D. Loop condition causes index out of range error.

Solution

1. Step 1: Analyze loop range and array indexing

   Loop runs from mid to arr.Length - 1 inclusive, accessing arr[i + 1]. For i = arr.Length - 1, arr[i + 1] is out of bounds.

2. Step 2: Identify cause of error

   Accessing arr[arr.Length] causes IndexOutOfRangeException.

3. Final Answer:

   Loop condition causes index out of range error. -> Option D

4. Quick Check:

   Loop index out of bounds [OK]

Hint: Loop must stop before last index to avoid out of range [OK]

Common Mistakes:

• Using <= instead of < in loop condition
• Ignoring array bounds when accessing i+1
• Misunderstanding middle index for even length

5. You have an array arr = {5, 10, 15, 20, 25, 30, 35}. Write the steps to delete the middle element and print the resulting array with correct size handling.

hard

A. Create a list from arr; remove element at mid; convert back to array; print.

B. Calculate mid = arr.Length / 2; shift elements left from mid; print first arr.Length - 1 elements.

C. Use Array.RemoveAt(mid); print arr.

D. Set arr[mid] = 0; print arr as is.

Solution

1. Step 1: Convert array to list for flexible size

   Arrays have fixed size, so convert to List<int> to remove element easily.

2. Step 2: Remove middle element and convert back

   Remove element at mid index, then convert list back to array for printing.

3. Step 3: Print resulting array

   Print elements of new array which has one less element.

4. Final Answer:

   Create a list from arr; remove element at mid; convert back to array; print. -> Option A

5. Quick Check:

   Use List for deletion, then convert back [OK]

Hint: Use List to delete middle element easily, then convert back [OK]

Common Mistakes:

• Trying to resize arrays directly
• Only shifting elements without resizing
• Using non-existent Array.RemoveAt method