Array Deletion at Middle Index in DSA Java

Mental Model

To delete an element from the middle of an array, we shift all elements after it one step left to fill the gap.

Analogy: Imagine a row of books on a shelf. If you remove one book in the middle, you slide all the books on the right one spot left to close the empty space.

Index: 0   1   2   3   4
Array: [1]->[2]->[3]->[4]->[5]

Dry Run Walkthrough

Input: array: [1, 2, 3, 4, 5], delete element at index 2

Goal: Remove the element at index 2 and shift remaining elements left

Step 1: Identify element at index 2 (value 3) to delete

Index: 0   1   2   3   4
Array: [1]->[2]->[3]->[4]->[5]

Why: We need to remove the element at index 2

Step 2: Shift element at index 3 (value 4) to index 2

Index: 0   1   2   3   4
Array: [1]->[2]->[4]->[4]->[5]

Why: Shift left to fill the gap created by deletion

Step 3: Shift element at index 4 (value 5) to index 3

Index: 0   1   2   3   4
Array: [1]->[2]->[4]->[5]->[5]

Why: Continue shifting elements left

Step 4: Reduce array size by 1 (ignore last duplicate element)

Index: 0   1   2   3
Array: [1]->[2]->[4]->[5]

Why: Final array size is one less after deletion

Result:

Index: 0   1   2   3
Array: [1]->[2]->[4]->[5]

Annotated Code

DSA Java

public class ArrayDeletion {
    public static int[] deleteAtIndex(int[] arr, int index) {
        if (arr == null || index < 0 || index >= arr.length) {
            return arr; // invalid index or null array
        }
        for (int i = index; i < arr.length - 1; i++) {
            arr[i] = arr[i + 1]; // shift elements left
        }
        int[] newArr = new int[arr.length - 1];
        for (int i = 0; i < newArr.length; i++) {
            newArr[i] = arr[i]; // copy to smaller array
        }
        return newArr;
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int deleteIndex = 2;
        int[] result = deleteAtIndex(arr, deleteIndex);
        for (int val : result) {
            System.out.print(val + " ");
        }
        System.out.println();
    }
}

if (arr == null || index < 0 || index >= arr.length) { return arr; }

handle invalid index or null array to avoid errors

for (int i = index; i < arr.length - 1; i++) { arr[i] = arr[i + 1]; }

shift elements left starting from deletion index to fill the gap

int[] newArr = new int[arr.length - 1];

create new array smaller by one to hold result

for (int i = 0; i < newArr.length; i++) { newArr[i] = arr[i]; }

copy shifted elements to new smaller array

return newArr;

return the new array after deletion

Output

1 2 4 5 

Complexity Analysis

Time: O(n) because we shift elements after the deleted index once

Space: O(n) because we create a new array smaller by one element

vs Alternative: Compared to linked lists which delete in O(1) time, arrays require shifting elements making deletion O(n)

Edge Cases

empty array

returns the same empty array without error

DSA Java

if (arr == null || index < 0 || index >= arr.length) { return arr; }

delete first element (index 0)

shifts all elements left and returns smaller array

DSA Java

for (int i = index; i < arr.length - 1; i++) { arr[i] = arr[i + 1]; }

delete last element (index arr.length - 1)

no shifting needed, just copy all except last element

DSA Java

for (int i = index; i < arr.length - 1; i++) { arr[i] = arr[i + 1]; }

When to Use This Pattern

When you need to remove an element from the middle of a fixed-size list and maintain order, use array deletion with shifting to fill the gap.

Common Mistakes

Mistake: Not shifting elements after deletion index, leaving a duplicate or gap
Fix: Shift all elements after the deleted index one position left to fill the gap

Mistake: Not reducing the array size after deletion
Fix: Create a new array smaller by one and copy shifted elements into it

Summary

Deletes an element at a given index by shifting subsequent elements left and resizing the array.

Use when you have a fixed-size array and need to remove an element while keeping order.

The key insight is shifting elements left to close the gap created by deletion.

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