Array Deletion at Middle Index in DSA Python

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 chairs where one person leaves from the middle; everyone behind moves one seat forward to close the empty spot.

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: Start deletion at index 2 (value 3)

1 -> 2 -> [3↑] -> 4 -> 5

Why: We identify the element to remove

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

1 -> 2 -> 4 -> [4] -> 5

Why: Fill the gap by moving next element left

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

1 -> 2 -> 4 -> 5 -> [5]

Why: Continue shifting elements left to close gap

Step 4: Remove last duplicate element at index 4

1 -> 2 -> 4 -> 5 -> null

Why: Last element is now duplicate, so reduce array size

Result:

1 -> 2 -> 4 -> 5 -> null

Annotated Code

DSA Python

class Array:
    def __init__(self, elements):
        self.arr = elements
        self.size = len(elements)

    def delete_at_index(self, index):
        if index < 0 or index >= self.size:
            print("Index out of bounds")
            return
        for i in range(index, self.size - 1):
            self.arr[i] = self.arr[i + 1]  # shift element left
        self.size -= 1  # reduce size to remove last duplicate

    def print_array(self):
        for i in range(self.size):
            print(self.arr[i], end=" -> " if i < self.size - 1 else " -> null\n")

# Driver code
array = Array([1, 2, 3, 4, 5])
array.delete_at_index(2)
array.print_array()

if index < 0 or index >= self.size:

check if index is valid to avoid errors

for i in range(index, self.size - 1):

loop to shift elements left starting from deletion index

self.arr[i] = self.arr[i + 1] # shift element left

move element from right to current position to fill gap

self.size -= 1 # reduce size to remove last duplicate

decrease size to logically remove last duplicate element

Output

1 -> 2 -> 4 -> 5 -> null

Complexity Analysis

Time: O(n) because in worst case we shift all elements after the deleted index once

Space: O(1) because deletion is done in place without extra storage

vs Alternative: Compared to creating a new array without the element (O(n) time and space), this method saves space by shifting in place

Edge Cases

delete at index 0 (first element)

All elements shift left, first element removed

DSA Python

if index < 0 or index >= self.size:

delete at last index

No shifting needed, just reduce size by one

DSA Python

for i in range(index, self.size - 1):

delete with invalid index (negative or too large)

Prints 'Index out of bounds' and no change

DSA Python

if index < 0 or index >= self.size:

When to Use This Pattern

When you need to remove an element from the middle of a fixed-size list or array, think of shifting elements left to fill the gap.

Common Mistakes

Mistake: Not reducing the size after shifting, leaving a duplicate at the end
Fix: Decrease the size variable by one after shifting elements

Mistake: Trying to shift elements beyond array bounds
Fix: Ensure loop runs only until size - 1 to avoid index errors

Summary

Deletes an element at a given index by shifting subsequent elements left.

Use when you want to remove an element from the middle of an array without creating a new array.

The key is to move all elements after the deleted one one step left and reduce the array size.

Practice

1. What happens when you delete the middle element from an array with an odd number of elements?

easy

A. The element at the exact middle index is removed, and the array size decreases by one.

B. The first element is removed instead of the middle one.

C. The array size remains the same but the middle element is set to zero.

D. The last element is removed instead of the middle one.

Solution

1. Step 1: Identify the middle index in an odd-length array

   For an array with odd length n, the middle index is n//2 (integer division).

2. Step 2: Remove the element at the middle index

   Deleting the element at this index reduces the array size by one and shifts elements after it left.

3. Final Answer:

   The element at the exact middle index is removed, and the array size decreases by one. -> Option A

4. Quick Check:

   Middle element removed = The element at the exact middle index is removed, and the array size decreases by one. [OK]

Hint: Middle index = length // 2 for odd arrays [OK]

Common Mistakes:

• Removing first or last element instead of middle
• Not reducing array size after deletion
• Confusing middle index calculation

2. Which of the following Python statements correctly deletes the middle element from a list named arr with odd length?

easy

A. arr.pop(len(arr))

B. del arr[len(arr)//2]

C. arr.remove(len(arr)//2)

D. arr.delete(len(arr)//2)

Solution

1. Step 1: Understand Python deletion syntax

   The del statement removes an element at a specific index from a list.

2. Step 2: Calculate middle index and delete

   Using len(arr)//2 gives the middle index for odd length. So del arr[len(arr)//2] deletes the middle element correctly.

3. Final Answer:

   del arr[len(arr)//2] -> Option B

4. Quick Check:

   Correct syntax for deletion = del arr[len(arr)//2] [OK]

Hint: Use del with index: del arr[len(arr)//2] [OK]

Common Mistakes:

• Using remove() which deletes by value, not index
• Using pop() with wrong index
• Using non-existent delete() method

3. What is the output of the following code?

arr = [10, 20, 30, 40, 50]
del arr[len(arr)//2]
print(arr)

medium

A. [10, 30, 40, 50]

B. [10, 20, 30, 40]

C. [20, 30, 40, 50]

D. [10, 20, 40, 50]

Solution

1. Step 1: Calculate middle index

   Length of arr is 5, so middle index = 5 // 2 = 2.

2. Step 2: Delete element at index 2 and print

   Element at index 2 is 30. After deletion, arr becomes [10, 20, 40, 50].

3. Final Answer:

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

4. Quick Check:

   Deleted arr[2] = 30, remaining = [10, 20, 40, 50] [OK]

Hint: Middle index 2 in 5 elements; delete arr[2] [OK]

Common Mistakes:

• Deleting wrong index (like 3 or 1)
• Confusing element value with index
• Printing before deletion

4. The following code is intended to delete the middle element from an array arr. What is the error?

arr = [1, 2, 3, 4, 5]
arr.remove(len(arr)//2)
print(arr)

medium

A. It deletes the last element instead of the middle one.

B. It causes an IndexError because remove expects an index.

C. It deletes the element with value 2 instead of the middle index element.

D. There is no error; it deletes the middle element correctly.

Solution

1. Step 1: Understand remove() method behavior

   remove(x) deletes the first element with value x, not at index x.

2. Step 2: Analyze the argument passed to remove()

   len(arr)//2 = 5//2 = 2, so arr.remove(2) deletes element with value 2, not element at index 2.

3. Final Answer:

   It deletes the element with value 2 instead of the middle index element. -> Option C

4. Quick Check:

   remove deletes by value, not index = It deletes the element with value 2 instead of the middle index element. [OK]

Hint: remove() deletes by value, del deletes by index [OK]

Common Mistakes:

• Confusing remove() with del or pop()
• Expecting remove() to delete by index
• Not calculating middle index correctly

5. Given an array arr = [5, 10, 15, 20, 25, 30] with even length, which code correctly deletes the middle element(s) so that after deletion the array is [5, 10, 25, 30]?

hard

A. del arr[len(arr)//2 - 1]; del arr[len(arr)//2]

B. del arr[len(arr)//2]; del arr[len(arr)//2 - 1]

C. arr.pop(len(arr)//2); arr.pop(len(arr)//2 - 1)

D. arr.remove(len(arr)//2); arr.remove(len(arr)//2 - 1)

Solution

1. Step 1: Identify middle indices for even length array

   Length is 6, middle indices are 2 and 3 (0-based), values 15 and 20.

2. Step 2: Delete elements at indices 2 and 3 accounting for length change

   del arr[len(arr)//2 - 1] deletes index 2 (15), array becomes [5, 10, 20, 25, 30]. Then del arr[len(arr)//2] deletes new index 2 (20), resulting in [5, 10, 25, 30].

3. Final Answer:

   del arr[len(arr)//2 - 1]; del arr[len(arr)//2] -> Option A

4. Quick Check:

   del arr[2] then del arr[2] (after shift) = [5, 10, 25, 30] [OK]

Hint: For even length, delete lower middle index first then the new middle index [OK]

Common Mistakes:

• Deleting higher index first without adjusting for length change
• Using pop() in wrong order causing incorrect shifts
• Using remove() which deletes by value