Array Insertion at Beginning in DSA C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does 'Array Insertion at Beginning' mean?

It means adding a new element at the first position (index 0) of an array, shifting all other elements one position to the right.

beginner

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

Because arrays have fixed positions, to insert at the start, all existing elements must move one step right to make space for the new element.

intermediate

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

The time complexity is O(n), where n is the number of elements, because all elements need to be shifted one position to the right.

beginner

Show the steps to insert 5 at the beginning of array [10, 20, 30].

Step 1: Shift 30 to index 3
Step 2: Shift 20 to index 2
Step 3: Shift 10 to index 1
Step 4: Insert 5 at index 0
Result: [5, 10, 20, 30]

intermediate

What happens if the array is full when inserting at the beginning?

If the array is full, you cannot insert a new element unless you increase the array size or remove an element first.

What is the first step when inserting an element at the beginning of an array?

A Shift all elements one position to the right

B Insert the element at the last position

C Delete the first element

D Replace the first element

To insert at the beginning, all elements must move right to make space.

What is the time complexity of inserting at the beginning of an array with n elements?

A O(n)

B O(log n)

C O(1)

D O(n^2)

All n elements need to be shifted, so it takes O(n) time.

If an array has elements [1, 2, 3] and we insert 0 at the beginning, what is the new array?

A [1, 2, 3, 0]

B [1, 0, 2, 3]

C [0, 1, 2, 3]

D [0, 1, 3, 2]

The new element 0 is added at the start, shifting others right.

What must be true about the array size to insert a new element at the beginning?

A Array must be full

B Array must have space for one more element

C Array size does not matter

D Array must be empty

There must be space to add a new element; otherwise insertion is not possible.

Which data structure allows easier insertion at the beginning than an array?

A Hash Table

B Stack

C Queue

D Linked List

Linked lists allow insertion at the start without shifting elements.

Explain how to insert an element at the beginning of an array and why shifting elements is necessary.

Think about how arrays store elements in fixed positions.

Describe what happens if you try to insert at the beginning of a full array and how to handle it.

Consider array size and memory limits.

Practice

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

easy

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

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

C. The array size automatically increases without shifting elements.

D. The last element is removed to insert the new element at the start.

Solution

1. Step 1: Understand array memory layout

   Arrays store elements in continuous memory. To insert at the start, existing elements must move to free space.

2. Step 2: Shift elements to the right

   Each element moves one position right to open index 0 for the new element.

3. Final Answer:

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

4. Quick Check:

   Insert at start = shift right [OK]

Hint: Insert at start means shift all elements right [OK]

Common Mistakes:

• Assuming new element overwrites first element
• Thinking array size grows automatically
• Removing last element without reason

2. Which of the following is the correct syntax to insert an element at the beginning of an array in C (assuming space is available)?

easy

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

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

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

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

Solution

1. Step 1: Identify correct loop direction for shifting

   To avoid overwriting, shift elements from end to start (i = n down to 1).

2. Step 2: Assign new element at index 0

   After shifting, place new_element at arr[0].

3. Final Answer:

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

4. Quick Check:

   Shift right from end, then insert [OK]

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

Common Mistakes:

• Shifting from start to end causing overwrite
• Assigning new element before shifting
• Incorrect loop boundaries

3. What will be the content of the array after executing this code?

int arr[5] = {10, 20, 30, 40, 0};
int n = 4;
int new_element = 5;
for(int i = n; i > 0; i--) {
  arr[i] = arr[i-1];
}
arr[0] = new_element;

medium

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

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

C. [5, 10, 20, 30, 0]

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

Solution

1. Step 1: Shift elements right from index 4 to 1

   arr[4]=arr[3]=40, arr[3]=arr[2]=30, arr[2]=arr[1]=20, arr[1]=arr[0]=10

2. Step 2: Insert new_element at arr[0]

   arr[0] = 5

3. Final Answer:

   [5, 10, 20, 30, 40] -> Option D

4. Quick Check:

   Shift right + insert 5 at start = [5,10,20,30,40] [OK]

Hint: Trace shifts from end, then insert new element at start [OK]

Common Mistakes:

• Not shifting last element correctly
• Overwriting elements during shift
• Forgetting to insert new element at index 0

4. Identify the error in this code snippet that tries to insert an element at the beginning of an array:

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

medium

A. Loop direction causes overwriting of elements during shift.

B. Array size is too small to insert new element.

C. New element is assigned after shifting elements.

D. Loop condition should be i <= n instead of i < n.

Solution

1. Step 1: Analyze loop direction and assignments

   Loop shifts elements from start to end, causing arr[i+1] to overwrite arr[i+1] before it is copied.

2. Step 2: Correct approach is to shift from end to start

   Shifting from end to start prevents overwriting original values during shift.

3. Final Answer:

   Loop direction causes overwriting of elements during shift. -> Option A

4. Quick Check:

   Shift must go backward to avoid overwrite [OK]

Hint: Shift elements backward to avoid overwriting [OK]

Common Mistakes:

• Shifting forward overwrites data
• Ignoring array size limits
• Incorrect loop boundaries

5. Given an array int arr[7] = {2, 4, 6, 8, 10, 0, 0}; with n = 5 elements, write the steps to insert 1 at the beginning and then 0 at the beginning again. What will be the final array content?

hard

A. [0, 1, 2, 4, 6, 8, 10]

B. [0, 1, 2, 4, 6, 8]

C. [0, 1, 2, 4, 6, 8, 10, 0]

D. [1, 0, 2, 4, 6, 8]

Solution

1. Step 1: Insert 1 at beginning

   Shift elements 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; then arr[0]=1. Array: [1, 2, 4, 6, 8, 10]

2. Step 2: Insert 0 at beginning

   Shift elements right again: arr[6]=arr[5]=10, arr[5]=arr[4]=8, arr[4]=arr[3]=6, arr[3]=arr[2]=4, arr[2]=arr[1]=2, arr[1]=arr[0]=1; then arr[0]=0. Array: [0, 1, 2, 4, 6, 8, 10]

3. Final Answer:

   [0, 1, 2, 4, 6, 8, 10] -> Option A

4. Quick Check:

   Two shifts + inserts = [0,1,2,4,6,8,10] [OK]

Hint: Shift right twice, insert each new element at index 0 [OK]

Common Mistakes:

• Not updating array size after insertions
• Overwriting elements during second insertion
• Assuming array can hold more than 6 elements