Array Insertion at Middle Index in DSA C

Mental Model

To insert a new value in the middle of an array, we shift all elements from that position to the right by one to make space.

Analogy: Imagine a row of chairs where you want to add a new person in the middle. Everyone from that spot onward must stand up and move one chair to the right to make room.

Index: 0   1   2   3   4
Array: [1]->[2]->[3]->[4]->[5]
Insert at index 2 (middle)

Dry Run Walkthrough

Input: array: [1, 2, 3, 4, 5], insert value 99 at index 2

Goal: Insert 99 at index 2 and shift elements right to keep order

Step 1: Shift element at index 4 (5) to index 5

[1]->[2]->[3]->[4]->[5]->[5]
Indexes: 0 1 2 3 4 5

Why: Make space at index 5 for shifting next element

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

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

Why: Move element right to free index 3

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

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

Why: Move element right to free index 2

Step 4: Insert 99 at index 2

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

Why: Place new value in the freed middle position

Result:

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

Annotated Code

DSA C

#include <stdio.h>

void insertAtMiddle(int arr[], int *size, int capacity, int value, int index) {
    if (*size >= capacity) {
        printf("Array is full, cannot insert.\n");
        return;
    }
    // Shift elements right from the end to index
    for (int i = *size - 1; i >= index; i--) {
        arr[i + 1] = arr[i]; // shift element right
    }
    arr[index] = value; // insert new value
    (*size)++; // increase size
}

void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d", arr[i]);
        if (i != size - 1) printf(" -> ");
    }
    printf("\n");
}

int main() {
    int capacity = 10;
    int arr[10] = {1, 2, 3, 4, 5};
    int size = 5;
    int value = 99;
    int index = 2; // middle index

    insertAtMiddle(arr, &size, capacity, value, index);
    printArray(arr, size);

    return 0;
}

for (int i = *size - 1; i >= index; i--) { arr[i + 1] = arr[i]; }

Shift elements right from the end to index to make space

arr[index] = value;

Insert new value at the middle index

(*size)++;

Increase array size after insertion

Output

1 -> 2 -> 99 -> 3 -> 4 -> 5

Complexity Analysis

Time: O(n) because in the worst case we shift half of the elements to the right

Space: O(1) because insertion is done in place without extra arrays

vs Alternative: Compared to creating a new array and copying elements, this in-place shift saves space but still requires shifting elements which costs O(n)

Edge Cases

Inserting at index 0 (start of array)

All elements shift right, new value placed at start

DSA C

for (int i = *size - 1; i >= index; i--) { arr[i + 1] = arr[i]; }

Inserting at index equal to current size (end of array)

No shifting needed, value appended at end

DSA C

for (int i = *size - 1; i >= index; i--) { arr[i + 1] = arr[i]; }

Array is full (size == capacity)

Insertion is rejected with message

DSA C

if (*size >= capacity) { printf("Array is full, cannot insert.\n"); return; }

When to Use This Pattern

When you need to add an element inside an array and keep order, look for the shifting pattern to make space before insertion.

Common Mistakes

Mistake: Not shifting elements from the end to the index, causing overwriting data
Fix: Always shift elements starting from the last element down to the insertion index to avoid overwriting

Mistake: Forgetting to increase the size after insertion
Fix: Increment the size variable after inserting the new element

Summary

Inserts a new value at a given middle index by shifting elements right to make space.

Use when you want to add an element inside an array without losing existing data order.

The key is to shift elements from the end towards the insertion point before placing the new value.

Practice

1. What is the correct middle index to insert an element in an array of size 6?

easy

A. 5

B. 2

C. 4

D. 3

Solution

1. Step 1: Calculate middle index for even-sized array

   For an array of size 6, middle index is size/2 = 6/2 = 3.

2. Step 2: Confirm insertion position

   Inserting at index 3 places the element exactly in the middle.

3. Final Answer:

   3 -> Option D

4. Quick Check:

   Middle index = size/2 = 3 [OK]

Hint: Middle index = array size divided by 2 [OK]

Common Mistakes:

• Using size-1 as middle index
• Using size/2 - 1 for even size
• Confusing zero-based indexing

2. Which of the following C code snippets correctly inserts an element at the middle index of an array arr of size n?

easy

A. int mid = n / 2; for(int i = 0; i < mid; i++) arr[i] = arr[i+1]; arr[mid] = x;

B. int mid = n / 2; for(int i = n; i > mid; i--) arr[i] = arr[i-1]; arr[mid] = x;

C. int mid = n / 2; arr[mid] = x;

D. int mid = n / 2; for(int i = mid; i < n; i++) arr[i] = arr[i+1]; arr[mid] = x;

Solution

1. Step 1: Identify correct shifting direction

   To insert at middle, elements from middle to end must shift right to make space.

2. Step 2: Check code correctness

   int mid = n / 2; for(int i = n; i > mid; i--) arr[i] = arr[i-1]; arr[mid] = x; shifts elements right from end to middle, then inserts x at mid. Others shift incorrectly or overwrite.

3. Final Answer:

   int mid = n / 2; for(int i = n; i > mid; i--) arr[i] = arr[i-1]; arr[mid] = x; -> Option B

4. Quick Check:

   Shift right from end to mid, then insert [OK]

Hint: Shift elements right from end to middle before insertion [OK]

Common Mistakes:

• Shifting elements left instead of right
• Not shifting elements before insertion
• Overwriting elements without shifting

3. What will be the content of the array after inserting 99 at the middle index of arr = {10, 20, 30, 40, 50} using the correct insertion method?

medium

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

B. [10, 20, 99, 30, 40, 50]

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

D. [10, 20, 30, 40, 50, 99]

Solution

1. Step 1: Calculate middle index

   Array size is 5, middle index = 5/2 = 2 (integer division).

2. Step 2: Shift elements right and insert 99

   Shift elements from index 4 to 2 right by one position. Insert 99 at index 2.

3. Final Answer:

   [10, 20, 99, 30, 40, 50] -> Option C

4. Quick Check:

   Insert at index 2 shifts elements right [OK]

Hint: Middle index = size/2; shift right, then insert [OK]

Common Mistakes:

• Inserting at wrong index
• Not shifting elements before insertion
• Overwriting elements

4. Identify the error in the following code snippet that inserts an element x at the middle of array arr of size n:

int mid = n / 2;
for(int i = mid; i < n; i++) {
    arr[i+1] = arr[i];
}
arr[mid] = x;

medium

A. Loop should run backwards from n to mid

B. Index mid is incorrect for insertion

C. No need to shift elements before insertion

D. Array size n should be incremented before insertion

Solution

1. Step 1: Analyze loop direction

   The loop shifts elements from mid to n forward, but does so from low to high index, causing overwrite.

2. Step 2: Correct loop direction

   Loop must run backwards from n to mid to shift elements right safely without overwriting.

3. Final Answer:

   Loop should run backwards from n to mid -> Option A

4. Quick Check:

   Shift right must be done backwards [OK]

Hint: Shift elements right by looping backwards from end [OK]

Common Mistakes:

• Looping forward causing data overwrite
• Not updating array size after insertion
• Incorrect middle index calculation

5. Given an array arr = {5, 10, 15, 20, 25, 30} of size 6, write the final array after inserting 99 at the middle index and then inserting 77 at the new middle index of the updated array.

hard

A. [5, 10, 15, 77, 99, 20, 25, 30]

B. [5, 10, 77, 99, 15, 20, 25, 30]

C. [5, 10, 99, 15, 77, 20, 25, 30]

D. [5, 10, 15, 99, 77, 20, 25, 30]

Solution

1. Step 1: Insert 99 at middle of original array

   Original size = 6, middle index = 3. Insert 99 at index 3 shifting elements right: [5, 10, 15, 99, 20, 25, 30]

2. Step 2: Insert 77 at middle of updated array

   New size = 7, middle index = 7/2 = 3. Insert 77 at index 3 shifting elements right: [5, 10, 15, 77, 99, 20, 25, 30]

3. Final Answer:

   [5, 10, 15, 77, 99, 20, 25, 30] -> Option A

4. Quick Check:

   Insert twice at middle recalculating index each time [OK]

Hint: Recalculate middle after each insertion before next insert [OK]

Common Mistakes:

• Not recalculating middle index after first insertion
• Overwriting elements without shifting
• Inserting at wrong index second time