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

We start with the array, find the index to delete, shift all elements after it one step left, then reduce the array size by one.

Execution Sample

DSA Java

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 size.

Execution Table

Step	Operation	Index i	Element Shifted	Array State	Array Size
1	Start	-	-	[10, 20, 30, 40, 50]	5
2	Delete element at index 2	2	arr[3] -> arr[2]	[10, 20, 40, 40, 50]	5
3	Shift element	3	arr[4] -> arr[3]	[10, 20, 40, 50, 50]	5
4	Reduce size by 1	-	-	[10, 20, 40, 50]	4
5	End	-	-	[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 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]
deleteIndex	2	2	2	2	2
newSize	5	5	5	4	4
i	-	2	3	-	-

Key Moments - 3 Insights

Why do we shift elements starting from the delete index?

Because we overwrite the element at the delete index with the next element, effectively removing the target and moving all subsequent elements left, as shown in steps 2 and 3 of the execution_table.

Why do we reduce the array size after shifting?

The array size is reduced to reflect that one element is removed. The last element is duplicated during shifting but is ignored after size reduction, as shown in step 4.

What happens if we try to delete an index outside the array bounds?

The code would cause an error or unexpected behavior because shifting elements from an invalid index is not possible. This is why the delete index must be valid, as implied in the initial step.

Visual Quiz - 3 Questions

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

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

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

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

D [10, 20, 40, 50]

💡 Hint

Check the 'Array State' column in row with Step 3 in execution_table.

At which step does the array size reduce?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Array Size' column in execution_table and find when it changes from 5 to 4.

If deleteIndex was 1 instead of 2, what would be the element shifted at step 2?

A arr[1] -> arr[0]

B arr[2] -> arr[1]

C arr[3] -> arr[2]

D arr[4] -> arr[3]

💡 Hint

Refer to the 'Element Shifted' column and understand the pattern of shifting from deleteIndex.

Concept Snapshot

Array Deletion at Middle Index:
- Identify index to delete
- Shift elements left from index+1 to end
- Reduce array size by 1
- Result: array without deleted element
- Shifting overwrites deleted element
- Size reduction ignores last duplicate

Full Transcript

This concept shows how to delete an element from the middle of an array. We start with the original array and the index to delete. Then, we shift all elements after that index one position to the left, overwriting the element to delete. After shifting, we reduce the array size by one to reflect the removal. The execution table tracks each step, showing how the array changes and how the size is updated. Key moments clarify why shifting is necessary and why size reduction happens after shifting. The visual quiz tests understanding of array states and operations at each step.

Practice

1. What happens when you delete the middle element from an array of size 5?
int[] arr = {10, 20, 30, 40, 50};
Delete element at index 2 (middle). What is the resulting 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 size is 5, so middle index is 2 (0-based). Element at index 2 is 30.

2. Step 2: Remove the element and shift remaining

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

3. Final Answer:

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

4. Quick Check:

   Middle element 30 removed, array shrinks by one [OK]

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

Common Mistakes:

• Not shifting elements after deletion
• Deleting wrong index (not middle)
• Leaving array size unchanged

2. Which of the following Java code snippets correctly deletes the middle element from an array arr of odd length n?

easy

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

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

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

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

Solution

1. Step 1: Understand the deletion index

   Middle index for odd length n is n/2 (integer division). We must shift elements after this index left.

2. Step 2: Check loop correctness

   Loop from n/2 to n-2 shifts elements left by copying arr[i+1] to arr[i]. This correctly removes middle element.

3. Final Answer:

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

4. Quick Check:

   Shift elements after middle left [OK]

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

Common Mistakes:

• Looping from 0 instead of middle index
• Shifting elements right instead of left
• Loop running out of array bounds

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

int[] arr = {5, 10, 15, 20, 25, 30, 35};
int n = arr.length;
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++) {
    System.out.print(arr[i] + " ");
}

medium

A. 5 10 15 20 25 35

B. 5 10 15 25 30 35

C. 5 10 15 20 25 30 35

D. 5 10 15 20 25 30

Solution

1. Step 1: Identify middle index and element

   Array length n=7, middle index mid=3, element at index 3 is 20.

2. Step 2: Shift elements left from middle

   Loop shifts elements from index 3 to 5 left by one: arr[3]=arr[4]=25, arr[4]=arr[5]=30, arr[5]=arr[6]=35.

3. Step 3: Decrease size and print

   n is decremented to 6, so print first 6 elements: 5 10 15 25 30 35.

4. Final Answer:

   5 10 15 25 30 35 -> Option B

5. Quick Check:

   Middle element 20 removed, array shifted left [OK]

Hint: Shift elements after middle left, reduce size by one [OK]

Common Mistakes:

• Printing full original array length
• Not decrementing array size after deletion
• Confusing middle index calculation

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

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

medium

A. Loop should start from 0, not mid

B. Middle index calculation is wrong for odd length arrays

C. Array size n should not be decremented

D. Loop runs out of array bounds accessing arr[i+1] when i = n-1

Solution

1. Step 1: Analyze loop range and array access

   Loop runs from i = mid to i = n-1. At i = n-1, arr[i+1] = arr[n] is accessed, which is out of bounds.

2. Step 2: Correct loop boundary

   Loop should run until i < n-1 to avoid out-of-bounds access when shifting elements left.

3. Final Answer:

   Loop runs out of array bounds accessing arr[i+1] when i = n-1 -> Option D

4. Quick Check:

   Array index out of bounds error [OK]

Hint: Loop till n-1, not n, to avoid arr[i+1] error [OK]

Common Mistakes:

• Using wrong loop end condition
• Ignoring array index limits
• Incorrect middle index for even length arrays

5. Given an array arr = {2, 4, 6, 8, 10, 12} of even length 6, how do you delete the middle element(s) to keep the array balanced? Choose the correct resulting array after deleting the middle element(s).

hard

A. [2, 4, 8, 10, 12]

B. [2, 4, 6, 10, 12]

C. [2, 4, 8, 12]

D. [2, 4, 6, 8, 10]

Solution

1. Step 1: Identify middle elements for even length

   For length 6, middle indices are 2 and 3 (elements 6 and 8).

2. Step 2: Delete one or both middle elements to keep balance

   Usually, delete one middle element to keep array balanced. Deleting element at index 2 (6) shifts elements left.

3. Step 3: Resulting array after deleting element at index 2

   Array becomes [2, 4, 8, 10, 12] after shifting elements left and reducing size by one.

4. Final Answer:

   [2, 4, 8, 10, 12] -> Option A

5. Quick Check:

   Delete one middle element, shift left, size reduces [OK]

Hint: For even length, delete lower middle index element [OK]

Common Mistakes:

• Deleting both middle elements instead of one
• Deleting wrong middle index
• Not shifting elements after deletion