Array Insertion at End in DSA C - Execution Trace

Concept Flow - Array Insertion at End

Check if array is full

No↓

Insert element at last index

↓

Increase size count

↓

Done

Yes↓

Cannot insert, array full

This flow shows checking if there is space, inserting the element at the end, updating size, or stopping if full.

Execution Sample

DSA C

int arr[5] = {1, 2, 3};
int size = 3;
int capacity = 5;
int element = 4;

if (size < capacity) {
  arr[size] = element;
  size++;
}

This code inserts element 4 at the end of array if there is space.

Execution Table

Step	Operation	Array State	Size Before	Size After	Pointer Changes	Visual State
1	Check if size < capacity	[1, 2, 3, _, _]	3	3	size=3, capacity=5	Array has space
2	Insert element 4 at arr[size]	[1, 2, 3, 4, _]	3	4	arr[3] = 4	4 inserted at index 3
3	Increment size	[1, 2, 3, 4, _]	4	4	size++	Size updated to 4
4	End	[1, 2, 3, 4, _]	4	4	-	Insertion complete

💡 Insertion stops after size increments; array not full yet.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
arr	[1, 2, 3, _, _]	[1, 2, 3, _, _]	[1, 2, 3, 4, _]	[1, 2, 3, 4, _]	[1, 2, 3, 4, _]
size	3	3	4	4	4
capacity	5	5	5	5	5
element	4	4	4	4	4

Key Moments - 3 Insights

Why do we check if size < capacity before inserting?

Because arrays have fixed size, we must ensure there is space to insert. See execution_table Step 1 where insertion only proceeds if size (3) is less than capacity (5).

What happens if we forget to increment size after insertion?

The size would not reflect the new element, causing future insertions to overwrite existing data. See execution_table Step 3 where size increments from 3 to 4.

Why is the new element inserted at arr[size] and not arr[size-1]?

Because size points to the next free index. Existing elements occupy indices 0 to size-1. See execution_table Step 2 where element 4 is inserted at index 3 (size before increment).

Visual Quiz - 3 Questions

Look at the execution_table, what is the size after Step 2?

A 2

B 3

C 4

D 5

💡 Hint

Check the 'Size After' column for Step 2 in execution_table.

At which step is the new element actually inserted into the array?

A Step 2

B Step 1

C Step 3

D Step 4

💡 Hint

Look at the 'Operation' and 'Visual State' columns in execution_table.

If the array was full (size == capacity), what would happen according to the concept_flow?

A Element is inserted anyway

B Insertion stops with message 'Cannot insert, array full'

C Size is incremented without insertion

D Array size increases automatically

💡 Hint

Refer to the 'Yes' branch in concept_flow ASCII diagram.

Concept Snapshot

Array Insertion at End:
- Check if size < capacity
- Insert element at arr[size]
- Increment size by 1
- Stop if array is full
- Fixed size arrays need capacity check

Full Transcript

This concept shows how to insert an element at the end of an array. First, we check if the array has space by comparing size and capacity. If there is space, we place the new element at the index equal to the current size. Then, we increase the size count by one to reflect the new element. If the array is full, insertion is not possible. This ensures we do not overwrite existing data or go out of bounds.

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