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

Concept Flow - Array Insertion at Beginning

Check if array is full

No↓

Shift all elements right by 1

↓

Insert new element at index 0

↓

Update array size

↓

Done

To insert at the beginning, first check space, then move all elements one step right, place new element at start, and update size.

Execution Sample

DSA C++

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

// Insert at beginning
if (size < capacity) {
  for (int i = size; i > 0; i--) arr[i] = arr[i-1];
  arr[0] = new_val;
  size++;
}

This code inserts 5 at the start of array {10,20,30,40} shifting elements right.

Execution Table

Step	Operation	Index i	Element Moved	Array State	Size
1	Check if size < capacity	-	-	[10, 20, 30, 40, _]	4
2	Shift element right	4	40	[10, 20, 30, 40, 40]	4
3	Shift element right	3	30	[10, 20, 30, 30, 40]	4
4	Shift element right	2	20	[10, 20, 20, 30, 40]	4
5	Shift element right	1	10	[10, 10, 20, 30, 40]	4
6	Insert new_val at index 0	0	5 inserted	[5, 10, 20, 30, 40]	4
7	Update size	-	-	[5, 10, 20, 30, 40]	5
8	End	-	-	[5, 10, 20, 30, 40]	5

💡 Insertion done, size updated to 5, array full now.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7	Final
arr	[10,20,30,40,_]	[10,20,30,40,40]	[10,20,30,30,40]	[10,20,20,30,40]	[10,10,20,30,40]	[5,10,20,30,40]	[5,10,20,30,40]	[5,10,20,30,40]
size	4	4	4	4	4	4	5	5

Key Moments - 3 Insights

Why do we shift elements from the end towards the beginning, not the other way?

Shifting from the end (step 2 to 5) prevents overwriting elements before moving them. If we shifted from start to end, original data would be lost.

What happens if the array is already full before insertion?

The insertion check (step 1) fails, so no shifting or insertion happens. This prevents overflow and data loss.

Why do we update the size only after inserting the new element?

Size update (step 7) happens last to reflect the actual number of elements after insertion, ensuring loops and conditions use correct size.

Visual Quiz - 3 Questions

Look at the execution table, what is the array state after shifting element at index 2?

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

B [10, 20, 20, 30, 40]

C [10, 10, 20, 30, 40]

D [5, 10, 20, 30, 40]

💡 Hint

Check row with Step 4 in execution_table for array state after moving element at index 2.

At which step does the new value get inserted at the beginning?

A Step 7

B Step 5

C Step 6

D Step 2

💡 Hint

Look for the step labeled 'Insert new_val at index 0' in execution_table.

If the array size was already 5 before insertion, what would happen at Step 1?

A Insertion is skipped due to full capacity

B Array elements shift right

C Insertion proceeds normally

D Size is updated to 6

💡 Hint

Step 1 checks if size < capacity; if false, insertion stops.

Concept Snapshot

Array Insertion at Beginning:
- Check if array has space
- Shift all elements right from end to start
- Insert new element at index 0
- Increase size by 1
- Shifting prevents overwriting data
- Stops if array is full

Full Transcript

To insert an element at the beginning of an array, first check if there is space. If yes, shift all elements one position to the right starting from the last element to avoid overwriting. Then place the new element at index zero. Finally, update the size to reflect the new element. If the array is full, insertion is skipped. This process ensures data is preserved and the new element is correctly placed at the start.

Practice

1. What happens when you insert an element at the beginning of an array in C++?

easy

A. All existing elements shift one position to the right to make space.

B. The new element replaces the first element without shifting others.

C. The array size decreases by one.

D. The array elements are sorted automatically.

Solution

1. Step 1: Understand array structure

   An array stores elements in continuous memory locations.

2. Step 2: Effect of insertion at beginning

   To insert at the start, all elements must move right to free the first position.

3. Final Answer:

   All existing elements shift one position to the right to make space. -> Option A

4. Quick Check:

   Insertion at start shifts elements right = B [OK]

Hint: Insertion at start shifts elements right to free first slot [OK]

Common Mistakes:

• Thinking new element replaces first without shifting
• Assuming array size decreases
• Believing array sorts automatically

2. Which of the following is the correct syntax to insert an element `x` at the beginning of an array `arr` of size `n` in C++ (assuming enough space)?

easy

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

B. arr[0] = x; for(int i = 1; i <= n; i++) arr[i] = arr[i-1]; n++;

C. for(int i = n; i > 0; i--) arr[i] = arr[i-1]; arr[0] = x; n++;

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

Solution

1. Step 1: Shift elements right from end

   Loop from last index `n` down to 1, moving each element to the right by one.

2. Step 2: Insert new element at index 0 and increase size

   Place `x` at `arr[0]` and increment `n`.

3. Final Answer:

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

4. Quick Check:

   Shift right from end, insert at 0 = C [OK]

Hint: Shift from end to start, then insert at zero index [OK]

Common Mistakes:

• Shifting from start to end overwrites data
• Not incrementing array size
• Inserting without shifting elements

3. What is the output of the following C++ code?

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

medium

A. 2 4 6 8 10 1

B. 1 2 4 6 8 10

C. 1 2 4 6 8

D. 2 4 6 8 10

Solution

1. Step 1: Shift elements right to make space

   Elements move right: arr[5]=arr[4]=10, arr[4]=arr[3]=8, arr[3]=arr[2]=6, arr[2]=arr[1]=4, arr[1]=arr[0]=2.

2. Step 2: Insert 1 at arr[0] and print

   arr[0]=1, array becomes [1,2,4,6,8,10], printed with space.

3. Final Answer:

   1 2 4 6 8 10 -> Option B

4. Quick Check:

   Shift right + insert 1 at start = A [OK]

Hint: Shift right, insert new at zero, print all elements [OK]

Common Mistakes:

• Not shifting elements correctly
• Printing old array size
• Inserting at wrong index

4. Identify the error in this code snippet that inserts `x` at the beginning of array `arr` of size `n`:

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

medium

A. Loop shifts elements left instead of right, overwriting data.

B. Array size `n` is not incremented after insertion.

C. New element is inserted at wrong index.

D. Loop should start from `n` and go down to 1 to avoid overwrite.

Solution

1. Step 1: Analyze loop direction

   Loop moves from 0 to n-1, shifting elements forward, overwriting original data.

2. Step 2: Correct loop direction

   Loop must run backward from n to 1 to shift elements safely without overwrite.

3. Final Answer:

   Loop should start from `n` and go down to 1 to avoid overwrite. -> Option D

4. Quick Check:

   Backward loop prevents overwrite = D [OK]

Hint: Shift elements backward from end to start to avoid overwrite [OK]

Common Mistakes:

• Shifting elements forward overwrites data
• Forgetting to increment array size
• Inserting element at wrong position

5. Given an array `arr` of size `n` with elements sorted in ascending order, how can you insert a new element `x` at the beginning and keep the array sorted?

hard

A. If `x` is smaller than `arr[0]`, shift elements right and insert `x` at start; else find correct position.

B. Insert `x` at the beginning and then sort the entire array again.

C. Always insert `x` at the beginning without shifting elements.

D. Replace the last element with `x` if `x` is smaller than last element.

Solution

1. Step 1: Check if `x` is smaller than first element

   If yes, shift all elements right and insert `x` at index 0 to keep order.

2. Step 2: If `x` is not smallest, find correct position

   Find proper index to insert `x` to maintain sorted order, not necessarily at start.

3. Final Answer:

   If `x` is smaller than `arr[0]`, shift elements right and insert `x` at start; else find correct position. -> Option A

4. Quick Check:

   Insert at start only if smaller, else find position = A [OK]

Hint: Insert at start only if smaller; else find correct sorted position [OK]

Common Mistakes:

• Always inserting at start breaks sorting
• Sorting entire array after insertion wastes time
• Replacing last element loses data