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 1

↓

Reduce array size by 1

↓

End with updated array

This flow shows deleting the first element of an array by removing it and shifting all other elements left to fill the gap.

Execution Sample

DSA C

int arr[5] = {10, 20, 30, 40, 50};
int size = 5;
// Delete first element
for (int i = 0; i < size - 1; i++) {
    arr[i] = arr[i + 1];
}
size--;

This code deletes the first element of the array by shifting all elements left and reducing the size.

Execution Table

Step	Operation	Array State	Pointer Changes	Visual State
0	Initial array	[10, 20, 30, 40, 50]	size=5	10 -> 20 -> 30 -> 40 -> 50 -> null
1	Shift arr[0] = arr[1]	[20, 20, 30, 40, 50]	i=0	20 -> 20 -> 30 -> 40 -> 50 -> null
2	Shift arr[1] = arr[2]	[20, 30, 30, 40, 50]	i=1	20 -> 30 -> 30 -> 40 -> 50 -> null
3	Shift arr[2] = arr[3]	[20, 30, 40, 40, 50]	i=2	20 -> 30 -> 40 -> 40 -> 50 -> null
4	Shift arr[3] = arr[4]	[20, 30, 40, 50, 50]	i=3	20 -> 30 -> 40 -> 50 -> 50 -> null
5	Reduce size by 1	[20, 30, 40, 50]	size=4	20 -> 30 -> 40 -> 50 -> null
6	End	[20, 30, 40, 50]	size=4	20 -> 30 -> 40 -> 50 -> null

💡 Loop ends after shifting all elements left; size reduced to 4 to reflect deletion.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	Final
arr	[10,20,30,40,50]	[20,20,30,40,50]	[20,30,30,40,50]	[20,30,40,40,50]	[20,30,40,50,50]	[20,30,40,50]	[20,30,40,50]
size	5	5	5	5	5	4	4
i	N/A	0	1	2	3	N/A	N/A

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 4 in the execution_table.

Why do we reduce the size after shifting elements?

After shifting, the last element is duplicated; reducing size (step 5) logically removes the extra element, so the array reflects the correct number of elements.

What happens if the array is empty before deletion?

If size is 0, the loop does not run and no shifting occurs; deletion is not possible, preventing errors.

Visual Quiz - 3 Questions

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

A [20, 30, 40, 40, 50]

B [20, 30, 30, 40, 50]

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

D [20, 20, 30, 40, 50]

💡 Hint

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

At which step does the size variable change?

A Step 1

B Step 4

C Step 5

D Step 6

💡 Hint

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

If we skip shifting elements, what would the final array look like?

A [10, 20, 30, 40]

B [20, 30, 40, 50, 50]

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

D [20, 30, 40, 50]

💡 Hint

Refer to the array states during shifting steps in the execution_table.

Concept Snapshot

Array Deletion at Beginning:
- Remove first element by shifting all elements left
- Use a loop from i=0 to size-2: arr[i] = arr[i+1]
- Decrease size by 1 after shifting
- Array size reflects current valid elements
- No gaps allowed in array after deletion

Full Transcript

This visual trace shows how to delete the first element of an array. We start with an array of 5 elements. To delete the first element, we shift every element one position to the left. This means arr[0] becomes arr[1], arr[1] becomes arr[2], and so on. After shifting, the last element is duplicated, so we reduce the size by one to remove the extra element logically. The final array has 4 elements, with the original first element removed. This process is necessary because arrays have fixed positions and cannot have gaps. The variable tracker shows how the array and size change after each step. Key moments clarify why shifting is needed and why size reduction is important. The quiz tests understanding of array states and size changes during the deletion process.