Array Deletion at Beginning in DSA C# - Execution Trace

Concept Flow - Array Deletion at Beginning

Start with array

↓

Delete first element

↓

Shift all elements left by one

↓

Reduce array size by one

↓

End with updated array

This flow shows deleting the first element of an array by shifting all other elements left and reducing the size.

Execution Sample

DSA C#

int[] arr = {10, 20, 30, 40};
int size = 4;
// Delete first element
for (int i = 1; i < size; i++) {
    arr[i - 1] = arr[i];
}
size--;
// Print updated array

Deletes the first element by shifting elements left and decreasing size.

Execution Table

Step	Operation	Array State	Pointer Changes	Visual State
0	Start with array	[10, 20, 30, 40]	size=4	10 -> 20 -> 30 -> 40 -> null
1	Shift arr[1] to arr[0]	[20, 20, 30, 40]	arr[0] = arr[1]	20 -> 20 -> 30 -> 40 -> null
2	Shift arr[2] to arr[1]	[20, 30, 30, 40]	arr[1] = arr[2]	20 -> 30 -> 30 -> 40 -> null
3	Shift arr[3] to arr[2]	[20, 30, 40, 40]	arr[2] = arr[3]	20 -> 30 -> 40 -> 40 -> null
4	Decrease size by 1	[20, 30, 40, 40]	size = 3	20 -> 30 -> 40 -> null
5	End	[20, 30, 40]	size = 3	20 -> 30 -> 40 -> null

💡 size reduced to 3, so last element ignored; deletion complete

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
arr	[10,20,30,40]	[20,20,30,40]	[20,30,30,40]	[20,30,40,40]	[20,30,40,40]	[20,30,40]
size	4	4	4	4	3	3

Key Moments - 3 Insights

Why do we shift elements left instead of just removing the first element?

Arrays have fixed positions; to delete the first element, we must move all others left to fill the gap, as shown in steps 1 to 3 in the execution_table.

Why do we reduce the size after shifting?

The size variable tracks how many elements are valid. After shifting, the last element is duplicated but ignored by reducing size, as in step 4.

What happens to the last element after deletion?

It remains in memory but is ignored because size is decreased. The visual state in step 5 shows the effective array ignoring the last duplicate.

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what is the array state?

A [20, 20, 30, 40]

B [10, 20, 30, 40]

C [20, 30, 30, 40]

D [20, 30, 40, 40]

💡 Hint

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

At which step does the size variable decrease?

A Step 3

B Step 4

C Step 5

D Step 1

💡 Hint

Look at the 'Pointer Changes' column for size changes in execution_table.

If we did not reduce size after shifting, what would be the visual state at the end?

A 20 -> 30 -> 40 -> 40 -> null

B 10 -> 20 -> 30 -> 40 -> null

C 20 -> 20 -> 30 -> 40 -> null

D 20 -> 30 -> 40 -> null

💡 Hint

Refer to step 3 and 4 visual states in execution_table to see effect of size.

Concept Snapshot

Array Deletion at Beginning:
- Remove first element by shifting all elements left.
- Use a loop from index 1 to size-1 to shift.
- Decrease size by 1 to ignore last duplicate.
- Array size is fixed; shifting keeps order.
- Last element remains but is ignored after size change.

Full Transcript

This visual trace shows how to delete the first element of an array by shifting all elements left one position and then reducing the size variable by one. Initially, the array contains four elements. Each step shifts the element at the next index to the current index, effectively overwriting the first element. After shifting all elements, the size is decreased to ignore the last duplicate element. The final array state shows the updated elements with the first element removed. This method is necessary because arrays have fixed positions and cannot remove elements without shifting.

Practice

1. What happens to the elements of an array when you delete the first element (at the beginning) in C#?

easy

A. All elements shift one position to the left, and the last element becomes unused.

B. The array size decreases automatically by one.

C. The first element is replaced by null but others stay the same.

D. The array elements remain unchanged.

Solution

1. Step 1: Understand array fixed size in C#

   Arrays have fixed size; deleting an element does not reduce size automatically.

2. Step 2: Effect of deleting first element

   To delete the first element, all other elements shift left by one to fill the gap.

3. Final Answer:

   All elements shift one position to the left, and the last element becomes unused. -> Option A

4. Quick Check:

   Deleting first element shifts left [OK]

Hint: Deleting at start shifts all elements left by one [OK]

Common Mistakes:

• Thinking array size changes automatically
• Assuming elements stay in place
• Believing first element becomes null only

2. Which of the following is the correct syntax to delete the first element from an array named arr in C# by shifting elements?

easy

A. arr.RemoveAt(0);

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

C. for(int i = 1; i < arr.Length; i++) arr[i] = arr[i - 1];

D. arr.Delete(0);

Solution

1. Step 1: Understand array element shifting

   To delete first element, shift elements left starting from index 0 to length-2.

2. Step 2: Check syntax correctness

   for(int i = 0; i < arr.Length - 1; i++) arr[i] = arr[i + 1]; correctly loops from 0 to length-2 and assigns arr[i] = arr[i+1].

3. Final Answer:

   for(int i = 0; i < arr.Length - 1; i++) arr[i] = arr[i + 1]; -> Option B

4. Quick Check:

   Loop from 0 to length-2 shifting elements left [OK]

Hint: Shift elements from index 0 to length-2 left [OK]

Common Mistakes:

• Starting loop from 1 instead of 0
• Using non-existent array methods like RemoveAt
• Assigning elements in wrong direction

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

int[] arr = {10, 20, 30, 40};
for(int i = 0; i < arr.Length - 1; i++) {
  arr[i] = arr[i + 1];
}
arr[arr.Length - 1] = 0;
for(int i = 0; i < arr.Length; i++) {
  Console.Write(arr[i] + " ");
}

medium

A. 20 30 40 0

B. 10 20 30 40

C. 0 20 30 40

D. 20 30 40 40

Solution

1. Step 1: Trace the shifting loop

   Loop shifts elements left: arr[0]=20, arr[1]=30, arr[2]=40.

2. Step 2: Set last element to 0

   arr[3] = 0 replaces old last element 40.

3. Final Answer:

   20 30 40 0 -> Option A

4. Quick Check:

   Shift left + last zero = 20 30 40 0 [OK]

Hint: Shift left then zero last element for deletion [OK]

Common Mistakes:

• Not setting last element to zero
• Confusing loop range causing wrong shifts
• Printing old array without changes

4. Identify the error in the following code that tries to delete the first element of an array arr and fix it:

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

medium

A. Last element should not be set to zero.

B. Array size must be reduced before shifting.

C. Loop direction is wrong; should shift elements left, not right.

D. The loop should start from 0 and go to arr.Length - 2.

Solution

1. Step 1: Analyze loop direction

   The loop copies arr[i-1] to arr[i], shifting elements right, which is incorrect for deletion.

2. Step 2: Correct loop to shift elements left

   Loop should assign arr[i] = arr[i+1] starting from i=0 to length-2.

3. Final Answer:

   Loop direction is wrong; should shift elements left, not right. -> Option C

4. Quick Check:

   Shift left to delete first element [OK]

Hint: Shift elements left, not right, when deleting at start [OK]

Common Mistakes:

• Shifting elements in wrong direction
• Trying to reduce array size directly
• Ignoring last element cleanup

5. You have an array int[] arr = {3, 6, 9, 12, 15}. Write a method to delete the first element and return a new array with the remaining elements only (size reduced by one). Which approach is correct?

hard

A. Use arr.RemoveAt(0) to delete the first element.

B. Shift elements left in original array and keep the same size.

C. Set arr[0] = 0 and return the original array.

D. Create a new array of size arr.Length - 1 and copy elements from index 1 onward.

Solution

1. Step 1: Understand fixed size arrays

   Arrays in C# have fixed size; to reduce size, create a new array.

2. Step 2: Copy elements except first

   Create new array of size one less and copy elements from index 1 onward.

3. Final Answer:

   Create a new array of size arr.Length - 1 and copy elements from index 1 onward. -> Option D

4. Quick Check:

   New smaller array with elements from index 1 [OK]

Hint: Create new smaller array and copy from index 1 [OK]

Common Mistakes:

• Trying to resize original array directly
• Only shifting elements without resizing
• Using non-existent RemoveAt method on array