Array Insertion at Middle Index in DSA Go - Execution Trace

Concept Flow - Array Insertion at Middle Index

Start with original array

↓

Calculate middle index = length/2

↓

Shift elements right from end to middle

↓

Insert new element at middle index

↓

Array updated with new element in middle

This flow shows how to insert a new element in the middle of an array by shifting elements right and placing the new element at the middle index.

Execution Sample

DSA Go

arr := []int{1, 2, 4, 5}
mid := len(arr) / 2
arr = append(arr, 0)
for i := len(arr)-2; i >= mid; i-- {
    arr[i+1] = arr[i]
}
arr[mid] = 3

Inserts 3 into the middle of array [1, 2, 4, 5] resulting in [1, 2, 3, 4, 5]

Execution Table

Step	Operation	Array State	Pointer Changes	Visual State
1	Start with original array	[1, 2, 4, 5]	mid = 2	1 -> 2 -> 4 -> 5 -> null
2	Append dummy element to increase size	[1, 2, 4, 5, 0]	len(arr) = 5	1 -> 2 -> 4 -> 5 -> 0 -> null
3	Shift element at index 3 to index 4	[1, 2, 4, 5, 5]	i=3 -> i+1=4	1 -> 2 -> 4 -> 5 -> 5 -> null
4	Shift element at index 2 to index 3	[1, 2, 4, 4, 5]	i=2 -> i+1=3	1 -> 2 -> 4 -> 4 -> 5 -> null
5	Insert new element 3 at middle index 2	[1, 2, 3, 4, 5]	arr[2] = 3	1 -> 2 -> 3 -> 4 -> 5 -> null
6	End of insertion	[1, 2, 3, 4, 5]	No pointer changes	1 -> 2 -> 3 -> 4 -> 5 -> null

💡 All elements shifted right from middle; new element inserted at middle index

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
arr	[1, 2, 4, 5]	[1, 2, 4, 5, 0]	[1, 2, 4, 4, 5]	[1, 2, 3, 4, 5]
mid	2	2	2	2
len(arr)	4	5	5	5
i	N/A	3	2	N/A

Key Moments - 3 Insights

Why do we append a dummy element before shifting?

Appending creates space at the end of the array to shift elements right without losing data, as shown in step 2 and 3 of the execution_table.

Why do we shift elements starting from the end towards the middle?

Shifting from the end prevents overwriting elements before they are moved, as seen in steps 3 and 4 where elements at higher indexes move first.

Why is the middle index calculated as length/2?

Because integer division gives the middle position where the new element should be inserted, as shown in step 1 where mid = 2 for length 4.

Visual Quiz - 3 Questions

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

A [1, 2, 0, 5, 5]

B [1, 2, 4, 4, 5]

C [1, 2, 4, 5, 5]

D [1, 2, 4, 5, 0]

💡 Hint

Check the 'Array State' column at step 3 in execution_table.

At which step does the new element get inserted at the middle index?

A Step 2

B Step 5

C Step 4

D Step 6

💡 Hint

Look for the operation mentioning 'Insert new element' in execution_table.

If the original array length was 5 instead of 4, what would be the middle index?

A 2

B 3

C 4

D 5

💡 Hint

Middle index is calculated as length/2 using integer division, see variable_tracker for mid value.

Concept Snapshot

Array Insertion at Middle Index:
- Calculate middle index as length/2
- Append dummy element to increase size
- Shift elements right from end to middle
- Insert new element at middle index
- Result: array with new element in middle

Full Transcript

This visual execution shows how to insert an element in the middle of an array. First, we calculate the middle index by dividing the array length by two. Then, we append a dummy element to the array to create space. Next, we shift elements from the end of the array towards the middle index one position to the right to avoid overwriting. Finally, we insert the new element at the middle index. The array updates step-by-step, ensuring no data is lost during shifting.

Practice

1. What is the middle index of an array with 7 elements when inserting a new element?

easy

A. 3

B. 4

C. 2

D. 5

Solution

1. Step 1: Calculate middle index for odd length array

   For an array of length 7, middle index = length / 2 = 7 / 2 = 3 (integer division).

2. Step 2: Confirm insertion position

   The new element should be inserted at index 3 to be in the middle.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Middle index = 7/2 = 3 [OK]

Hint: Middle index = length divided by 2 (integer division) [OK]

Common Mistakes:

• Using length/2 + 1 for middle index
• Confusing zero-based index with count
• Using length/2 as float instead of integer

2. Which Go code snippet correctly inserts an element `x` at the middle index of slice `arr`?

easy

A. arr = append(arr, x)

B. arr = append(arr[:len(arr)/2], append([]int{x}, arr[len(arr)/2:]...)...)

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

D. arr = append(arr[:len(arr)/2+1], append([]int{x}, arr[len(arr)/2:]...)...)

Solution

1. Step 1: Understand slice insertion in Go

   To insert at middle, split slice at middle index, append new element slice, then append remaining slice.

2. Step 2: Check syntax correctness

   arr = append(arr[:len(arr)/2], append([]int{x}, arr[len(arr)/2:]...)...) correctly uses append with slices and variadic syntax to insert element at middle.

3. Final Answer:

   arr = append(arr[:len(arr)/2], append([]int{x}, arr[len(arr)/2:]...)...) -> Option B

4. Quick Check:

   Correct slice append syntax = arr = append(arr[:len(arr)/2], append([]int{x}, arr[len(arr)/2:]...)...) [OK]

Hint: Use append with slices and variadic ... to insert at middle [OK]

Common Mistakes:

• Trying to append element directly without wrapping in slice
• Incorrect index calculation with +1
• Appending element at end instead of middle

3. What is the output of this Go code?

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

medium

A. [1 2 99 3 4]

B. [1 2 3 99 4]

C. [99 1 2 3 4]

D. [1 2 3 4 99]

Solution

1. Step 1: Calculate middle index

   len(arr) = 4, so mid = 4 / 2 = 2.

2. Step 2: Insert 99 at index 2

   arr[:2] = [1, 2], arr[2:] = [3, 4]. Insert 99 between them.

3. Step 3: Resulting array

   New arr = [1, 2, 99, 3, 4]

4. Final Answer:

   [1 2 99 3 4] -> Option A

5. Quick Check:

   Insert 99 at index 2 = [1 2 99 3 4] [OK]

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

Common Mistakes:

• Inserting element at wrong index
• Appending element at end instead of middle
• Misunderstanding slice append syntax

4. Identify the error in this Go code that tries to insert 50 at the middle of slice `nums`:

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

medium

A. Middle index calculation is wrong

B. Slice nums is not initialized

C. Cannot append element and slice together without wrapping element in slice

D. fmt.Println syntax error

Solution

1. Step 1: Check append syntax

   append(nums[:mid], 50, nums[mid:]...) tries to append int and slice variadically, which is invalid.

2. Step 2: Correct approach

   Wrap 50 in a slice: append(nums[:mid], append([]int{50}, nums[mid:]...)...).

3. Final Answer:

   Cannot append element and slice together without wrapping element in slice -> Option C

4. Quick Check:

   Append element + slice needs nested append [OK]

Hint: Wrap single element in slice when appending with another slice [OK]

Common Mistakes:

• Appending element and slice directly together
• Incorrect middle index calculation
• Forgetting variadic ... operator

5. Given a slice `data := []int{5, 10, 15, 20, 25}`, write the correct Go code to insert `100` exactly in the middle, then print the updated slice.

hard

A. mid := len(data)/2
data = append(data[:mid], 100, data[mid:])
fmt.Println(data)

B. mid := len(data)/2
data = append(data[:mid+1], append([]int{100}, data[mid:]...)...)
fmt.Println(data)

C. mid := len(data)/2
data = append(data, 100)
fmt.Println(data)

D. mid := len(data)/2
data = append(data[:mid], append([]int{100}, data[mid:]...)...)
fmt.Println(data)

Solution

1. Step 1: Calculate middle index

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

2. Step 2: Insert 100 at index 2 correctly

   Use nested append: append(data[:mid], append([]int{100}, data[mid:]...)...).

3. Step 3: Print updated slice

   Prints [5 10 100 15 20 25].

4. Final Answer:

   mid := len(data)/2 data = append(data[:mid], append([]int{100}, data[mid:]...)...) fmt.Println(data) -> Option D

5. Quick Check:

   Insert at middle with nested append = mid := len(data)/2 data = append(data[:mid], append([]int{100}, data[mid:]...)...) fmt.Println(data) [OK]

Hint: Use nested append with slices to insert element at middle [OK]

Common Mistakes:

• Using mid+1 instead of mid for insertion
• Appending element at end instead of middle
• Appending element and slice without wrapping element