Array Insertion at Beginning in DSA C# - Execution Trace

Concept Flow - Array Insertion at Beginning

Check if array has space

↓

Shift all elements right by 1

↓

Insert new element at index 0

↓

Update array size

↓

Done

To insert at the beginning, first shift all elements one step right, then place the new element at index 0, and update the size.

Execution Sample

DSA C#

int[] arr = new int[5] {10, 20, 30, 40, 0};
int size = 4;
int newElement = 5;
// Insert at beginning
for (int i = size; i > 0; i--) arr[i] = arr[i - 1];
arr[0] = newElement;
size++;

This code inserts 5 at the start of the array by shifting elements right and placing 5 at index 0.

Execution Table

Step	Operation	Array State	Pointer Changes	Visual State
1	Check space for insertion	[10, 20, 30, 40, 0]	size=4	[10, 20, 30, 40, 0]
2	Shift element at index 4 = index 3	[10, 20, 30, 40, 40]	i=4	[10, 20, 30, 40, 40]
3	Shift element at index 3 = index 2	[10, 20, 30, 30, 40]	i=3	[10, 20, 30, 30, 40]
4	Shift element at index 2 = index 1	[10, 20, 20, 30, 40]	i=2	[10, 20, 20, 30, 40]
5	Shift element at index 1 = index 0	[10, 10, 20, 30, 40]	i=1	[10, 10, 20, 30, 40]
6	Insert new element 5 at index 0	[5, 10, 20, 30, 40]	arr[0]=5	[5, 10, 20, 30, 40]
7	Increase size by 1	[5, 10, 20, 30, 40]	size=5	[5, 10, 20, 30, 40]
8	End of insertion	[5, 10, 20, 30, 40]	size=5	[5, 10, 20, 30, 40]

💡 Insertion complete, array size updated to 5

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	Final
arr	[10, 20, 30, 40, 0]	[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]
size	4	4	4	4	4	4	5
i	N/A	4	3	2	1	N/A	N/A

Key Moments - 3 Insights

Why do we shift elements from the end towards the beginning?

Shifting from the end prevents overwriting data. If we shifted from the start, we would overwrite elements before moving them, losing data. See steps 2 to 5 in execution_table.

What happens if the array is already full?

If the array is full (size equals array length), we cannot insert without resizing. This example assumes space at the end (index 4 is 0). Step 1 checks space before shifting.

Why do we update the size after insertion?

Size tracks how many elements are valid. After inserting, size increases by 1 to reflect the new element. See step 7 in execution_table.

Visual Quiz - 3 Questions

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

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

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

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

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

💡 Hint

Check the 'Array State' column at step 4 in execution_table.

At which step is the new element inserted at index 0?

A Step 5

B Step 6

C Step 7

D Step 2

💡 Hint

Look for the operation mentioning 'Insert new element' in execution_table.

If the array was full with no space, what would change in the execution flow?

A We would skip shifting and insert directly

B We would decrease the size variable

C We would resize the array before shifting

D We would insert at the end instead

💡 Hint

Refer to key_moments about array full condition and step 1 check.

Concept Snapshot

Array Insertion at Beginning:
- Check if space is available
- Shift all elements right by one (from end to start)
- Insert new element at index 0
- Increase size by 1
- Requires shifting to avoid overwriting data

Full Transcript

To insert an element at the beginning of an array, first check if there is space. Then shift all existing elements one position to the right starting from the last element to avoid overwriting. Insert the new element at index 0. Finally, increase the size variable to reflect the new element count. This process ensures the array maintains order and data integrity.

Practice

1. What happens when you insert an element at the beginning of a fixed-size array in C#?

easy

A. The last element is removed and the new element is added at the start.

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

C. The array size automatically increases to fit the new element.

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

Solution

1. Step 1: Understand fixed-size array behavior

   In C#, arrays have fixed size, so to insert at the beginning, elements must shift right.

2. Step 2: Effect of insertion at index 0

   The element at index 0 is replaced by the new element, and all others move one index higher.

3. Final Answer:

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

4. Quick Check:

   Insert at start = shift right [OK]

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

Common Mistakes:

• Thinking array size grows automatically
• Replacing first element without shifting
• Removing last element silently

2. Which of the following C# code snippets correctly inserts an integer 5 at the beginning of an array arr of size 5, shifting elements right?

easy

A. for (int i = arr.Length - 1; i > 0; i--) { arr[i] = arr[i - 1]; } arr[0] = 5;

B. for (int i = 0; i < arr.Length - 1; i++) { arr[i] = arr[i + 1]; } arr[arr.Length - 1] = 5;

C. arr[0] = 5; // No shifting needed

D. arr[arr.Length] = 5; // Add at end

Solution

1. Step 1: Identify correct loop for shifting right

   Loop must start from the end and move elements one step right to avoid overwriting.

2. Step 2: Assign new value at index 0

   After shifting, assign 5 to arr[0].

3. Final Answer:

   for (int i = arr.Length - 1; i > 0; i--) { arr[i] = arr[i - 1]; } arr[0] = 5; -> Option A

4. Quick Check:

   Shift right from end, then insert [OK]

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

Common Mistakes:

• Shifting left instead of right
• Assigning without shifting
• Using invalid index arr.Length

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

int[] arr = {10, 20, 30, 40, 50};
for (int i = arr.Length - 1; i > 0; i--) {
    arr[i] = arr[i - 1];
}
arr[0] = 5;
foreach (int num in arr) {
    Console.Write(num + " ");
}

medium

A. 5 10 20 30 50

B. 5 10 20 30 40

C. 5 20 30 40 50

D. 10 5 20 30 40

Solution

1. Step 1: Shift elements right

   Elements move right: arr[4]=arr[3]=40, arr[3]=arr[2]=30, arr[2]=arr[1]=20, arr[1]=arr[0]=10

2. Step 2: Insert 5 at index 0

   arr[0] = 5

3. Final Answer:

   5 10 20 30 40 -> Option B

4. Quick Check:

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

Hint: Trace shifts from end, then insert new value [OK]

Common Mistakes:

• Not shifting elements correctly
• Overwriting elements before shifting
• Incorrect final array print

4. The following code attempts to insert 99 at the beginning of an array arr but produces incorrect output. What is the error?

int[] arr = {1, 2, 3, 4, 5};
for (int i = 0; i < arr.Length - 1; i++) {
    arr[i + 1] = arr[i];
}
arr[0] = 99;

medium

A. The loop shifts elements left instead of right, overwriting data.

B. The assignment to arr[0] should be inside the loop.

C. The loop index range is incorrect; it should start from the end.

D. The array size is too small to insert a new element.

Solution

1. Step 1: Analyze loop direction and range

   The loop starts from 0 and moves forward, causing overwriting of elements.

2. Step 2: Correct loop should start from end

   To shift right safely, loop must start from last index and move backward.

3. Final Answer:

   The loop index range is incorrect; it should start from the end. -> Option C

4. Quick Check:

   Shift right requires backward loop [OK]

Hint: Shift right needs backward loop from end [OK]

Common Mistakes:

• Looping forward overwrites elements
• Assigning new value inside loop
• Ignoring fixed array size

5. You have an array arr = new int[6] {0, 1, 2, 3, 4, 5} and want to insert a new element 99 at the beginning without losing any data. Which approach correctly handles this?

hard

A. Create a new array of size 7, set arr2[0] = 99, then copy all elements of arr to arr2 starting at index 1.

B. Shift all elements right by one and assign 99 to arr[0], but last element is lost.

C. Replace arr[0] with 99 directly without shifting elements.

D. Use a List<int> instead of array to insert at beginning easily.

Solution

1. Step 1: Understand fixed array size limitation

   Original array size is 6, so inserting without losing data requires a bigger array.

2. Step 2: Create new larger array and copy elements

   Create new array size 7, assign 99 at index 0, then copy original elements starting at index 1.

3. Final Answer:

   Create a new array of size 7, set arr2[0] = 99, then copy all elements of arr to arr2 starting at index 1. -> Option A

4. Quick Check:

   New bigger array + copy elements = safe insertion [OK]

Hint: Use bigger array and copy to insert without loss [OK]

Common Mistakes:

• Trying to insert in fixed-size array losing last element
• Replacing without shifting
• Ignoring better data structures like List