Array Deletion at Beginning in DSA Java - 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

The process removes the first element, shifts all others left, and reduces the array size by one.

Execution Sample

DSA Java

int[] arr = {10, 20, 30, 40};
int size = 4;
// Delete at beginning
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 decreasing the size.

Execution Table

Step	Operation	Array State	Pointer Changes	Visual State
1	Initial array	[10, 20, 30, 40]	size=4	10 -> 20 -> 30 -> 40 -> null
2	Shift arr[0] = arr[1]	[20, 20, 30, 40]	i=0	20 -> 20 -> 30 -> 40 -> null
3	Shift arr[1] = arr[2]	[20, 30, 30, 40]	i=1	20 -> 30 -> 30 -> 40 -> null
4	Shift arr[2] = arr[3]	[20, 30, 40, 40]	i=2	20 -> 30 -> 40 -> 40 -> null
5	Decrease size by 1	[20, 30, 40, 40]	size=3	20 -> 30 -> 40 -> null
6	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 2	After Step 3	After Step 4	After Step 5	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
i	N/A	0	1	2	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 remove the first element, we must move all others left to fill the gap, as shown in steps 2 to 4 in the execution_table.

Why does the size decrease after shifting elements?

Because the array logically holds one less element after deletion, size is reduced at step 5 to ignore the last duplicate element.

What happens to the last element after shifting?

It remains in the array but is ignored because size is decreased; see step 5 and 6 where size changes but array content still shows the old last value.

Visual Quiz - 3 Questions

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

A [20, 30, 30, 40]

B [20, 20, 30, 40]

C [10, 20, 30, 40]

D [20, 30, 40, 40]

💡 Hint

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

At which step does the size variable decrease?

A Step 2

B Step 5

C Step 4

D Step 6

💡 Hint

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

If we skip shifting elements, what would happen to the array after deletion?

A The first element would be removed and array size reduced correctly.

B The last element would be duplicated.

C The array would still contain the first element, causing incorrect data.

D The array size would increase.

💡 Hint

Refer to key_moments about why shifting is necessary.

Concept Snapshot

Array Deletion at Beginning:
- Remove first element by shifting all elements left
- Use a loop from 0 to size-2 to shift
- Decrease size by 1 after shifting
- Last element remains but is ignored
- Array size controls valid elements

Full Transcript

This concept shows how to delete the first element of an array by shifting all elements one position to the left and then reducing the size by one. The code loops through the array, replacing each element with the next one. After shifting, the size variable is decreased to ignore the last duplicate element. This process ensures the array reflects the deletion logically, even though the physical array size remains fixed. Key points include why shifting is necessary and how size controls the valid elements in the array.

Practice

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

easy

A. All elements shift one position to the left, and the first element is removed.

B. All elements shift one position to the right, and the last element is removed.

C. The array size increases by one.

D. The array remains unchanged.

Solution

1. Step 1: Understand array deletion at beginning

   Deleting the first element means removing the element at index 0.

2. Step 2: Effect on remaining elements

   All other elements move one position left to fill the gap, reducing the array size by one.

3. Final Answer:

   All elements shift one position to the left, and the first element is removed. -> Option A

4. Quick Check:

   Delete first element = shift left [OK]

Hint: Deleting first element shifts all others left by one [OK]

Common Mistakes:

• Thinking elements shift right instead of left
• Assuming array size stays the same
• Believing the array remains unchanged

2. Which of the following Java code snippets correctly deletes the first element from an integer array arr and shifts the remaining elements left?

easy

A. for (int i = 1; i < arr.length; i++) { arr[i] = arr[i - 1]; }

B. for (int i = arr.length - 1; i > 0; i--) { arr[i] = arr[i - 1]; }

C. for (int i = 0; i < arr.length - 1; i++) { arr[i] = arr[i + 1]; }

D. for (int i = 0; i < arr.length; i++) { arr[i + 1] = arr[i]; }

Solution

1. Step 1: Identify correct loop direction and indices

   To shift elements left, start from index 0 to length-2, assigning arr[i] = arr[i+1].

2. Step 2: Check each option

   for (int i = 0; i < arr.length - 1; i++) { arr[i] = arr[i + 1]; } matches this logic; others shift right or use wrong indices causing errors.

3. Final Answer:

   for (int i = 0; i < arr.length - 1; i++) { arr[i] = arr[i + 1]; } -> Option C

4. Quick Check:

   Shift left loop: i from 0 to length-2 [OK]

Hint: Shift left by copying arr[i+1] to arr[i] in forward loop [OK]

Common Mistakes:

• Looping backwards when shifting left
• Using wrong indices causing ArrayIndexOutOfBounds
• Assigning arr[i-1] instead of arr[i+1]

3. What is the output of the following Java code?

int[] arr = {10, 20, 30, 40, 50};
for (int i = 0; i < arr.length - 1; i++) {
    arr[i] = arr[i + 1];
}
arr[arr.length - 1] = 0;
for (int num : arr) {
    System.out.print(num + " ");
}

medium

A. 20 30 40 50 0

B. 10 20 30 40 50

C. 0 10 20 30 40

D. 50 40 30 20 10

Solution

1. Step 1: Trace the shifting loop

   Each element moves left: arr[0]=20, arr[1]=30, arr[2]=40, arr[3]=50.

2. Step 2: Set last element to 0

   arr[4] is set to 0 explicitly.

3. Final Answer:

   20 30 40 50 0 -> Option A

4. Quick Check:

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

Hint: After shift, last element set to zero to fill gap [OK]

Common Mistakes:

• Forgetting to set last element to zero
• Printing original array without shift
• Confusing shift direction

4. The following code attempts to delete the first element of an array but causes an error. What is the error?

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

medium

A. Logical error: elements shift right instead of left

B. ArrayIndexOutOfBoundsException at i = 3

C. Syntax error due to missing semicolon

D. No error, code runs fine

Solution

1. Step 1: Analyze loop range

   The loop runs i from 0 to arr.length - 1 (i.e., 0 to 3).

2. Step 2: Identify out-of-bounds access

   At i=3, arr[i+1] = arr[4] is accessed, which is outside array bounds causing exception.

3. Final Answer:

   ArrayIndexOutOfBoundsException at i = 3 -> Option B

4. Quick Check:

   Accessing arr[4] in length 4 array causes exception [OK]

Hint: Loop till length-2 to avoid out-of-bounds [OK]

Common Mistakes:

• Using <= instead of < in loop condition
• Ignoring array length limits
• Assuming code runs without error

5. Given an array arr = {5, 10, 15, 20, 25}, write the output after deleting the first element twice using the standard shift-left method and setting the last element to zero each time.
What is the final state of the array?

hard

A. [5, 10, 15, 20, 25]

B. [10, 15, 20, 25, 0]

C. [0, 0, 15, 20, 25]

D. [15, 20, 25, 0, 0]

Solution

1. Step 1: First deletion

   Shift left: arr becomes [10, 15, 20, 25, 0]

2. Step 2: Second deletion

   Shift left again: arr becomes [15, 20, 25, 0, 0]

3. Final Answer:

   [15, 20, 25, 0, 0] -> Option D

4. Quick Check:

   Two shifts left + zeros at end = [15, 20, 25, 0, 0] [OK]

Hint: Each deletion shifts left and adds zero at end [OK]

Common Mistakes:

• Deleting only once instead of twice
• Not setting last element to zero after shift
• Confusing order of elements after shifts