Array Insertion at End in DSA C

Mental Model

An array holds items in order, and inserting at the end means placing a new item right after the last one.

Analogy: Think of a row of boxes where you add a new box at the very end without moving any existing boxes.

Index: 0   1   2   3   4
Array: [1] [2] [3] [_] [_]
               ↑end

Dry Run Walkthrough

Input: array: [1, 2, 3, _, _], insert value 4 at end

Goal: Add the value 4 right after the last filled spot in the array

Step 1: Find the current end position (index 3) where insertion can happen

Index: 0   1   2   3   4
Array: [1] [2] [3] [_] [_]
               ↑end

Why: We need to know where the new value should go

Step 2: Place the value 4 at index 3

Index: 0   1   2   3   4
Array: [1] [2] [3] [4] [_]
                   ↑end

Why: Inserting at the end means putting the new value in the first empty spot

Step 3: Update the end position to index 4 for next insertion

Index: 0   1   2   3   4
Array: [1] [2] [3] [4] [_]
                   ↑end

Why: We move the end pointer forward to keep track of the next free spot

Result:

Index: 0   1   2   3   4
Array: [1] [2] [3] [4] [_]
                   ↑end

Annotated Code

DSA C

#include <stdio.h>

#define MAX_SIZE 5

// Function to insert value at the end of the array
void insertAtEnd(int arr[], int *size, int value) {
    if (*size >= MAX_SIZE) {
        printf("Array is full, cannot insert %d\n", value);
        return;
    }
    arr[*size] = value; // place value at current end
    (*size)++;          // move end forward
}

// Function to print the array
void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d", arr[i]);
        if (i < size - 1) printf(" -> ");
    }
    printf(" -> null\n");
}

int main() {
    int arr[MAX_SIZE] = {1, 2, 3};
    int size = 3; // current number of elements

    insertAtEnd(arr, &size, 4);
    printArray(arr, size);

    return 0;
}

if (*size >= MAX_SIZE) {

check if array is full to avoid overflow

arr[*size] = value; // place value at current end

insert new value at the current end index

(*size)++; // move end forward

increment size to update end position

Output

1 -> 2 -> 3 -> 4 -> null

Complexity Analysis

Time: O(1) because insertion at the end is a direct assignment without loops

Space: O(1) since no extra space is needed beyond the array

vs Alternative: Compared to inserting at the start or middle which may require shifting elements O(n), inserting at the end is faster and simpler

Edge Cases

array is already full

insertion is rejected with a message to avoid overflow

DSA C

if (*size >= MAX_SIZE) {

array is empty (size = 0)

insertion places the value at index 0 correctly

DSA C

arr[*size] = value;

When to Use This Pattern

When you need to add items to a collection in order without rearranging, reach for array insertion at end because it is simple and fast.

Common Mistakes

Mistake: Trying to insert without checking if the array is full, causing overflow
Fix: Always check if the current size is less than the maximum before inserting

Mistake: Not updating the size after insertion, causing next insertions to overwrite
Fix: Increment the size variable after placing the new value

Summary

It adds a new value at the next free spot at the end of the array.

Use it when you want to grow a list by adding items one after another.

Remember to check space and update the size to keep track of the end.

Practice

1. What happens when you insert an element at the end of an array in C if the array has enough space?

easy

A. The element is added at the last position and the array size increases by one.

B. The element replaces the first element of the array.

C. The array size remains the same and the element is ignored.

D. The array is sorted automatically after insertion.

Solution

1. Step 1: Understand array insertion at end

   When an element is inserted at the end, it is placed at the next free index if space is available.

2. Step 2: Effect on array size

   The logical size of the array increases by one because a new element is added.

3. Final Answer:

   The element is added at the last position and the array size increases by one. -> Option A

4. Quick Check:

   Insert at end adds element and increases size [OK]

Hint: Insert at end adds element at next free index [OK]

Common Mistakes:

• Thinking array size changes physically (fixed size in C)
• Assuming insertion replaces existing elements
• Believing array sorts automatically after insertion

2. Which of the following is the correct syntax to insert an element 'x' at the end of an array 'arr' with current size 'n' in C?

easy

A. arr[n+1] = x; n++;

B. arr[n] = x; n++;

C. arr[n-1] = x; n++;

D. arr[x] = n; n++;

Solution

1. Step 1: Identify correct index for insertion

   The next free position is at index 'n' since array indexing starts at 0 and current size is 'n'.

2. Step 2: Update size after insertion

   After inserting, increment 'n' to reflect the new size.

3. Final Answer:

   arr[n] = x; n++; -> Option B

4. Quick Check:

   Insert at arr[n], then increment n [OK]

Hint: Insert at arr[n], then increase size n [OK]

Common Mistakes:

• Using arr[n+1] causes out-of-bounds error
• Using arr[n-1] overwrites last element
• Confusing element and index positions

3. What will be the output of the following C code?

int arr[5] = {1, 2, 3};
int n = 3;
arr[n] = 4;
n++;
for(int i = 0; i < n; i++) {
    printf("%d ", arr[i]);
}

medium

A. 1 2 3 4

B. 1 2 3

C. 1 2 3 0

D. Compilation error

Solution

1. Step 1: Insert element at arr[3]

   arr[3] is assigned 4, so array becomes {1, 2, 3, 4, ?}.

2. Step 2: Increment size and print elements

   n becomes 4, loop prints arr[0] to arr[3]: 1 2 3 4.

3. Final Answer:

   1 2 3 4 -> Option A

4. Quick Check:

   Inserted 4 at end, printed all elements [OK]

Hint: Insert at arr[n], increment n, print up to n [OK]

Common Mistakes:

• Ignoring increment of n, printing only first 3 elements
• Assuming uninitialized arr[3] is zero
• Confusing array size and capacity

4. Find the error in the following code snippet that inserts an element at the end of an array:

int arr[5] = {10, 20, 30};
int n = 3;
arr[n+1] = 40;
n++;

medium

A. Array initialization is incorrect.

B. The size 'n' is not incremented correctly.

C. No error, code works fine.

D. The element is inserted at wrong index (arr[n+1] instead of arr[n]).

Solution

1. Step 1: Check insertion index

   Inserting at arr[n+1] means arr[4], skipping arr[3], which is incorrect for sequential insertion.

2. Step 2: Consequence of wrong index

   This causes a gap in the array; correct index is arr[n].

3. Final Answer:

   The element is inserted at wrong index (arr[n+1] instead of arr[n]). -> Option D

4. Quick Check:

   Insert at arr[n], not arr[n+1] [OK]

Hint: Insert at arr[n], not arr[n+1] to avoid errors [OK]

Common Mistakes:

• Using arr[n+1] instead of arr[n]
• Not updating size after insertion
• Ignoring array bounds

5. Given an array int arr[6] = {5, 10, 15, 20}; with current size n = 4, which code snippet correctly inserts the element 25 at the end and prints the updated array?

medium

A. arr[n-1] = 25; n++; for(int i=0; i

B. arr[n+1] = 25; n++; for(int i=0; i

C. arr[n] = 25; n++; for(int i=0; i

D. arr[5] = 25; n = 5; for(int i=0; i

Solution

1. Step 1: Identify correct insertion index

   Current size n=4 (indices 0-3 used), so end insertion at arr[4] (arr[n]), then n=5.

2. Step 2: Evaluate options

   A: arr[4]=25, n=5, prints 5 10 15 20 25 [correct].
   B: arr[5]=25, n=5, prints 0-4 (5 10 15 20 <uninit>) [misses 25].
   C: arr[3]=25 overwrites 20 [wrong].
   D: arr[5]=25, n=5, prints 0-4 [misses 25].

3. Final Answer:

   arr[n] = 25; n++; for(int i=0; i -> Option C

4. Quick Check:

   Insert at arr[n], n++, print 0 to n-1 [OK]

Hint: Insert at next free index, update size, print all elements [OK]

Common Mistakes:

• Inserting at wrong index causing overwrite
• Not updating size correctly
• Printing wrong number of elements