Array Insertion at End in DSA C++ - Execution Trace

Concept Flow - Array Insertion at End

Start with array and size

↓

Check if size < capacity?

No→Cannot insert, array full

Yes↓

Insert element at array[size

↓

Increment size by 1

↓

Insertion complete

The flow checks if there is space, inserts the element at the end, then updates the size.

Execution Sample

DSA C++

int arr[5] = {10, 20, 30};
int size = 3;
int capacity = 5;
int element = 40;

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

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

Execution Table

Step	Operation	Array State	Size Before	Size After	Pointer Changes	Visual State
1	Start with array and size	[10, 20, 30, _, _]	3	3	size points to index 3	10 -> 20 -> 30 -> _ -> _
2	Check if size < capacity	[10, 20, 30, _, _]	3	3	size=3, capacity=5	Condition True, space available
3	Insert element 40 at arr[size]	[10, 20, 30, 40, _]	3	3	arr[3] = 40	10 -> 20 -> 30 -> 40 -> _
4	Increment size by 1	[10, 20, 30, 40, _]	3	4	size updated to 4	10 -> 20 -> 30 -> 40 -> _
5	Insertion complete	[10, 20, 30, 40, _]	4	4	size=4	10 -> 20 -> 30 -> 40 -> _

💡 Insertion stops after size increments; array has space and element inserted at end.

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
arr	[10, 20, 30, _, _]	[10, 20, 30, 40, _]	[10, 20, 30, 40, _]	[10, 20, 30, 40, _]
size	3	3	4	4
capacity	5	5	5	5
element	40	40	40	40

Key Moments - 3 Insights

Why do we check if size < capacity before inserting?

Because the array has fixed capacity. If size equals capacity, no space is left to insert. See execution_table step 2 where condition is checked.

Why do we insert at arr[size] and not arr[size-1]?

Because size points to the next free position. Existing elements are at indices 0 to size-1. Step 3 shows insertion at arr[size].

What happens if we forget to increment size after insertion?

The size would not reflect the new element, causing overwriting on next insert. Step 4 shows size increment to avoid this.

Visual Quiz - 3 Questions

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

A [10, 20, 30, 40, _]

B [10, 20, 30, _, _]

C [10, 20, 30, 30, _]

D [_, _, _, _, _]

💡 Hint

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

At which step does the size variable change from 3 to 4?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Size After' column in execution_table rows.

If the capacity was 3 instead of 5, what would happen at step 2?

A Insertion proceeds normally

B Condition size < capacity is false, insertion stops

C Array resizes automatically

D Element is inserted at arr[0]

💡 Hint

Refer to the condition check in step 2 of execution_table.

Concept Snapshot

Array Insertion at End:
- Check if size < capacity
- Insert element at arr[size]
- Increment size by 1
- If full, insertion fails
- Array size tracks used elements

Full Transcript

This visual trace shows how to insert an element at the end of an array. We start with an array of fixed capacity and a current size. First, we check if there is space by comparing size and capacity. If space exists, we place the new element at the index equal to size. Then, we increase the size by one to reflect the new element. If the array is full, insertion does not happen. The trace shows each step with the array state and size changes.

Practice

1. What happens when you insert an element at the end of a fixed-size array in C++ without resizing?

easy

A. The element replaces the last element if the array is full

B. The array automatically resizes to fit the new element

C. The element is added at the next free position if available

D. The program throws a runtime error

Solution

1. Step 1: Understand fixed-size array behavior

   Fixed-size arrays have a set size and cannot grow automatically.

2. Step 2: Inserting at end when full

   If the array is full, you cannot add a new element without overwriting or causing undefined behavior. If there is space available, the element is added at the next free position.

3. Final Answer:

   The element is added at the next free position if available -> Option C

4. Quick Check:

   Fixed-size array adds element only if space available [OK]

Hint: Fixed arrays don't resize; add element only if space available [OK]

Common Mistakes:

• Assuming array resizes automatically
• Thinking insertion always adds new space
• Expecting runtime error on insertion

2. Which of the following is the correct syntax to insert an element `x` at the end of a vector `v` in C++?

easy

A. v.append(x);

B. v.push_back(x);

C. v.add(x);

D. v.insert_end(x);

Solution

1. Step 1: Recall vector insertion method

   The standard method to add an element at the end of a vector is push_back.

2. Step 2: Check syntax correctness

   Only v.push_back(x); is valid C++ syntax for vector insertion at end.

3. Final Answer:

   v.push_back(x); -> Option B

4. Quick Check:

   Use push_back to insert at vector end [OK]

Hint: Use push_back() to add at vector end [OK]

Common Mistakes:

• Using non-existent methods like insert_end or add
• Confusing vector with other container methods
• Using append which is not a C++ vector method

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

int arr[5] = {1, 2, 3, 4, 5};
int n = 5;
int x = 10;
if (n < 5) {
  arr[n] = x;
  n++;
}
for (int i = 0; i < n; i++) {
  std::cout << arr[i] << " ";
}

medium

A. 1 2 3 4 10

B. 1 2 3 4 5 10

C. Compilation error

D. 1 2 3 4 5

Solution

1. Step 1: Check condition for insertion

   The condition if (n < 5) is false because n equals 5, so insertion does not happen.

2. Step 2: Print array elements

   The loop prints all elements from index 0 to 4, which are 1 2 3 4 5.

3. Final Answer:

   1 2 3 4 5 -> Option D

4. Quick Check:

   Insertion skipped, original array printed [OK]

Hint: Check insertion condition before adding element [OK]

Common Mistakes:

• Assuming insertion happens even if condition false
• Printing beyond array size
• Confusing array size with variable n

4. Identify the error in the following code that tries to insert an element at the end of an array:

int arr[3] = {1, 2, 3};
int n = 3;
int x = 4;
arr[n] = x;
n++;
for (int i = 0; i < n; i++) {
  std::cout << arr[i] << " ";
}

medium

A. Array index out of bounds when inserting element

B. Variable n is not incremented correctly

C. Missing semicolon after arr[n] = x

D. Loop condition should be i <= n

Solution

1. Step 1: Check array size and insertion index

   Array size is 3, valid indices are 0,1,2. Inserting at arr[3] is out of bounds.

2. Step 2: Understand consequences of out-of-bounds access

   Accessing arr[3] causes undefined behavior or runtime error.

3. Final Answer:

   Array index out of bounds when inserting element -> Option A

4. Quick Check:

   Insertion index must be within array size [OK]

Hint: Array indices go from 0 to size-1 only [OK]

Common Mistakes:

• Ignoring array bounds when inserting
• Assuming array resizes automatically
• Incorrect loop boundary causing extra prints

5. You have an array `int arr[6] = {1, 2, 3, 4, 5};` and a variable `int n = 5;` representing the current number of elements. Write the correct code snippet to insert `10` at the end safely, considering array size limits.

hard

A. if (n < 6) { arr[n] = 10; n++; }

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

C. if (n <= 6) { arr[n] = 10; n++; }

D. if (n < 5) { arr[n] = 10; n++; }

Solution

1. Step 1: Check array capacity before insertion

   Array size is 6, so insertion is safe only if n < 6.

2. Step 2: Insert element and update count

   If condition is true, assign arr[n] = 10 and increment n to reflect new size.

3. Final Answer:

   if (n < 6) { arr[n] = 10; n++; } -> Option A

4. Quick Check:

   Check capacity before insert, then add element [OK]

Hint: Always check n < array size before inserting [OK]

Common Mistakes:

• Not checking array size before insertion
• Using <= instead of < causing overflow
• Wrong size limit in condition