Array Insertion at Beginning in DSA C++ - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after inserting an element at the beginning of the array?

Consider the following C++ code that inserts an element at the beginning of an array by shifting elements to the right. What will be the printed array after insertion?

DSA C++

#include <iostream>
using namespace std;

int main() {
    int arr[5] = {2, 4, 6, 8};
    int n = 4; // current number of elements
    int x = 10; // element to insert at beginning

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

    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

A 10 2 4 6 8

B 2 4 6 8 10

C 10 2 4 6 8 0

D 2 4 6 8 0

💡 Hint

Think about how elements are shifted to the right before inserting the new element at index 0.

The code shifts all elements one position to the right starting from the end, then inserts the new element at the beginning (index 0). The array after insertion is: 10 2 4 6 8.

🧠 Conceptual

intermediate

Why do we shift elements when inserting at the beginning of an array?

Inserting an element at the beginning of a fixed-size array requires shifting existing elements. Why is this step necessary?

A To reverse the array before inserting.

B To delete the last element automatically.

C To make space at the first index by moving all elements one position to the right.

D To sort the array before insertion.

💡 Hint

Think about what happens to the element currently at index 0 when a new element is inserted there.

Since arrays have fixed positions, to insert at the beginning, all elements must move one step right to free index 0 for the new element.

🔧 Debug

advanced

Identify the error in this array insertion code

What error will this code produce when trying to insert an element at the beginning of the array?

DSA C++

#include <iostream>
using namespace std;

int main() {
    int arr[4] = {1, 2, 3, 4};
    int n = 4;
    int x = 0;

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

    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

A Runtime error: Array index out of bounds

B Output: 0 1 2 3 4

C Compilation error: Missing semicolon

D Output: 1 2 3 4 0

💡 Hint

Check the loop indices and array size carefully.

The loop runs from i = n down to 1, so when i = n (which is 4), arr[i] = arr[i - 1] tries to access arr[4] which is out of bounds for an array of size 4.

❓ Predict Output

advanced

What is the output after multiple insertions at the beginning?

Given the following code, what will be the printed array after inserting two elements at the beginning sequentially?

DSA C++

#include <iostream>
using namespace std;

int main() {
    int arr[6] = {5, 6, 7, 8};
    int n = 4;

    // Insert 3 at beginning
    for (int i = n; i > 0; i--) {
        arr[i] = arr[i - 1];
    }
    arr[0] = 3;
    n++;

    // Insert 1 at beginning
    for (int i = n; i > 0; i--) {
        arr[i] = arr[i - 1];
    }
    arr[0] = 1;
    n++;

    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

A 3 1 5 6 7 8

B 1 3 5 6 7 8

C 1 5 6 7 8 3

D 5 6 7 8 3 1

💡 Hint

Each insertion shifts all elements to the right before placing the new element at index 0.

First insertion adds 3 at the start: 3 5 6 7 8. Second insertion adds 1 at the start, shifting all right: 1 3 5 6 7 8.

🧠 Conceptual

expert

What is the time complexity of inserting an element at the beginning of an array?

When inserting an element at the beginning of a fixed-size array by shifting elements, what is the time complexity in terms of n (number of elements)?

A O(log n), because shifting uses binary search.

B O(1), because insertion at the beginning is direct.

C O(n^2), because each element is shifted multiple times.

D O(n), because all elements must be shifted one position to the right.

💡 Hint

Consider how many elements need to move when inserting at the start.

Inserting at the beginning requires shifting all existing elements one position right, which takes time proportional to n.

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