Array Deletion at Middle Index in DSA Python - 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 an array, find the index to delete, shift all elements after it one step left, then reduce the array size by one.

Execution Sample

DSA Python

arr = [10, 20, 30, 40, 50]
index = 2
for i in range(index, len(arr)-1):
    arr[i] = arr[i+1]
arr.pop()

Deletes element at index 2 by shifting elements left and removing last duplicate.

Execution Table

Step	Operation	Index i	Array State	Pointer Changes	Visual State
1	Start	-	[10, 20, 30, 40, 50]	head at 0	10 -> 20 -> 30 -> 40 -> 50 -> null
2	Delete at index	2	[10, 20, 30, 40, 50]	target index = 2	10 -> 20 -> 30 -> 40 -> 50 -> null
3	Shift element	2	[10, 20, 40, 40, 50]	arr[2] = arr[3]	10 -> 20 -> 40 -> 40 -> 50 -> null
4	Shift element	3	[10, 20, 40, 50, 50]	arr[3] = arr[4]	10 -> 20 -> 40 -> 50 -> 50 -> null
5	Pop last element	-	[10, 20, 40, 50]	size reduced by 1	10 -> 20 -> 40 -> 50 -> null
6	End	-	[10, 20, 40, 50]	-	10 -> 20 -> 40 -> 50 -> null

💡 All elements shifted left from index 2, last element removed to reduce size.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	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]
index	2	2	2	2	2
i	-	2	3	-	-

Key Moments - 3 Insights

Why do we shift elements left instead of just removing the element at the index?

Because arrays have fixed positions, removing an element leaves a gap. Shifting left fills that gap, keeping elements contiguous as shown in steps 3 and 4 of the execution_table.

Why do we pop the last element after shifting?

After shifting, the last element is duplicated. Popping removes this duplicate and reduces the array size, as shown in step 5.

What happens if we delete the last element (index = last)?

No shifting is needed; we just pop the last element. This is a special case not shown here but follows the same pop step.

Visual Quiz - 3 Questions

Look at the execution_table, what is the array state after shifting element at index 2?

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

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

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

D [10, 20, 40, 50]

💡 Hint

Check row with Step 3 in execution_table under 'Array State'

At which step does the array size reduce?

A Step 5

B Step 4

C Step 3

D Step 6

💡 Hint

Look for 'Pop last element' operation in execution_table

If we delete element at index 4 (last element), how would the execution_table change?

A Shift elements twice then pop

B Shift elements once then pop

C No shifting steps, only pop last element

D No pop needed

💡 Hint

Deleting last element means no elements after it to shift, so only pop is needed

Concept Snapshot

Array Deletion at Middle Index:
- Identify index to delete
- Shift all elements after index one step left
- Remove last element to reduce size
- Keeps array contiguous without gaps
- Works in O(n) time for shifting

Full Transcript

This visualization 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 each element after that index one position to the left to fill the gap. Finally, we remove the last element since it is now duplicated. This keeps the array contiguous and reduces its size by one. The execution table tracks each step, showing how the array changes and how pointers move. Key moments clarify why shifting and popping are necessary. The quiz tests understanding of these steps.

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