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

This flow shows deleting an element at a middle index by shifting elements left and reducing array size.

Execution Sample

DSA Go

arr := []int{10, 20, 30, 40, 50}
index := 2
for i := index; i < len(arr)-1; i++ {
    arr[i] = arr[i+1]
}
arr = arr[:len(arr)-1]

Deletes element at index 2 by shifting elements left and slicing array to reduce size.

Execution Table

Step	Operation	Index	Array State	Pointer Changes	Visual State
1	Start	-	[10, 20, 30, 40, 50]	arr points to full array	10 -> 20 -> 30 -> 40 -> 50 -> null
2	Delete at index	2	[10, 20, 30, 40, 50]	index=2	10 -> 20 -> 30 -> 40 -> 50 -> null
3	Shift element at i=2	2	[10, 20, 40, 40, 50]	arr[2] = arr[3]	10 -> 20 -> 40 -> 40 -> 50 -> null
4	Shift element at i=3	3	[10, 20, 40, 50, 50]	arr[3] = arr[4]	10 -> 20 -> 40 -> 50 -> 50 -> null
5	Reduce array size	-	[10, 20, 40, 50]	arr = arr[:4]	10 -> 20 -> 40 -> 50 -> null
6	End	-	[10, 20, 40, 50]	final array size 4	10 -> 20 -> 40 -> 50 -> null

💡 Array size reduced by 1 after shifting elements left from index 2

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
len(arr)	5	5	5	4	4

Key Moments - 3 Insights

Why do we shift elements left after deleting at a middle index?

Because arrays have fixed positions, we must move elements after the deleted index left to fill the gap, as shown in steps 3 and 4 in the execution_table.

Why do we reduce the array size after shifting elements?

After shifting, the last element is duplicated, so we slice the array to remove the extra element, shown in step 5 in the execution_table.

What happens if we delete the last element (index = len(arr)-1)?

No shifting is needed; we just reduce the array size by one, skipping steps 3 and 4.

Visual Quiz - 3 Questions

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

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

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

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

D [10, 20, 40, 50]

💡 Hint

Check the 'Array State' column for step 4 in the execution_table.

At which step does the array size reduce?

A Step 3

B Step 4

C Step 5

D Step 6

💡 Hint

Look for 'Reduce array size' operation in the execution_table.

If we delete element at index 4 (last element), which steps would be skipped?

A Step 5 only

B Steps 3 and 4

C Step 2 only

D No steps skipped

💡 Hint

Recall shifting happens only if deleted index is not last; see key_moments explanation.

Concept Snapshot

Array Deletion at Middle Index:
- Identify index to delete
- Shift elements left from index+1 to end
- Reduce array size by slicing
- Result: array without deleted element
- Shifting fills the gap left by deletion

Full Transcript

This concept 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 all elements after that index one position to the left to fill the gap. After shifting, the array has a duplicate last element, so we reduce the array size by slicing off the last element. The final array no longer contains the deleted element. This process is necessary because arrays have fixed positions and cannot have gaps. If the deleted element is the last one, no shifting is needed, only size reduction.

Practice

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

easy

A. The array size stays the same but the middle element becomes zero.

B. The middle element is removed and the array size decreases by one.

C. The array is reversed after deletion.

D. The first element is removed instead of the middle.

Solution

1. Step 1: Understand array deletion

   Deleting an element removes it and shifts later elements left.

2. Step 2: Effect on array size

   Removing one element reduces the array length by one.

3. Final Answer:

   The middle element is removed and the array size decreases by one. -> Option B

4. Quick Check:

   Delete middle element = size - 1 [OK]

Hint: Deleting removes element and shrinks array size [OK]

Common Mistakes:

• Thinking array size stays the same after deletion
• Assuming deletion replaces element with zero
• Confusing middle deletion with first element deletion

2. Which Go code snippet correctly deletes the middle element from an array named arr with odd length?

easy

A. arr = arr[len(arr)/2+1:]

B. arr = append(arr[1:], arr[:len(arr)-1]...)

C. arr = append(arr[:len(arr)/2], arr[len(arr)/2+1:]...)

D. arr = arr[:len(arr)/2] + arr[len(arr)/2+1:]

Solution

1. Step 1: Identify correct slicing syntax

   In Go, to delete an element at index i, use append(arr[:i], arr[i+1:]...).

2. Step 2: Apply to middle index

   Middle index is len(arr)/2 for odd length, so arr = append(arr[:len(arr)/2], arr[len(arr)/2+1:]...).

3. Final Answer:

   arr = append(arr[:len(arr)/2], arr[len(arr)/2+1:]...) -> Option C

4. Quick Check:

   Use append with slices excluding middle [OK]

Hint: Use append(arr[:i], arr[i+1:]...) to delete index i [OK]

Common Mistakes:

• Using + operator to join slices (invalid in Go)
• Not using ... to expand second slice in append
• Deleting wrong index or slice ranges

3. What is the output of this Go code?

arr := []int{10, 20, 30, 40, 50}
mid := len(arr) / 2
arr = append(arr[:mid], arr[mid+1:]...)
fmt.Println(arr)

medium

A. [10 20 40 50]

B. [10 20 30 40]

C. [20 30 40 50]

D. [10 30 40 50]

Solution

1. Step 1: Calculate middle index

   len(arr) = 5, so mid = 5 / 2 = 2 (integer division).

2. Step 2: Delete element at index 2

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

3. Final Answer:

   [10 20 40 50] -> Option A

4. Quick Check:

   Removed 30 at index 2 [OK]

Hint: Middle index = length/2; remove that element [OK]

Common Mistakes:

• Using float division instead of integer
• Deleting wrong index element
• Not expanding slice with ... in append

4. Find the error in this Go code that tries to delete the middle element from arr:

arr := []int{1, 2, 3, 4, 5}
mid := len(arr) / 2
arr = append(arr[:mid], arr[mid:]...)
fmt.Println(arr)

medium

A. The second slice should start from mid+1, not mid.

B. The middle index calculation is wrong.

C. append cannot be used with slices.

D. The array length is even, so no middle element.

Solution

1. Step 1: Check slice ranges in append

   The code uses arr[mid:] which includes the middle element again, not deleting it.

2. Step 2: Correct slice to exclude middle element

   To delete middle element at mid, use arr[mid+1:] to skip it.

3. Final Answer:

   The second slice should start from mid+1, not mid. -> Option A

4. Quick Check:

   Exclude middle element by slicing from mid+1 [OK]

Hint: Second slice must start at mid+1 to delete middle [OK]

Common Mistakes:

• Using arr[mid:] includes middle element again
• Miscalculating middle index for odd length
• Thinking append can't join slices

5. Given an array arr := []int{5, 10, 15, 20, 25, 30, 35}, write the Go code to delete the middle element and then insert 100 at the same middle index. What will be the final array?

hard

A. [5 10 15 20 100 25 30 35]

B. [5 10 15 20 25 30 35 100]

C. [5 10 15 20 25 30 35]

D. [5 10 15 100 25 30 35]

Solution

1. Step 1: Delete middle element

   Length is 7, middle index = 7/2 = 3. Delete element at index 3 (value 20): arr = append(arr[:3], arr[4:]...) = [5 10 15 25 30 35].

2. Step 2: Insert 100 at middle index

   Insert 100 at index 3: arr = append(arr[:3], append([]int{100}, arr[3:]...)...) = [5 10 15 100 25 30 35].

3. Step 3: Verify final array

   Final array is [5 10 15 100 25 30 35].

4. Final Answer:

   [5 10 15 100 25 30 35] -> Option D

5. Quick Check:

   Delete middle, insert 100 at same index [OK]

Hint: Delete middle then insert at same index using append [OK]

Common Mistakes:

• Not updating array after deletion before insertion
• Inserting 100 at wrong index
• Appending 100 at end instead of middle