Array Deletion at End in DSA Java - Execution Trace

Concept Flow - Array Deletion at End

Start with array and size

↓

Check if array is empty?

↓

Stop: nothing to delete

↓

Last element considered deleted

↓

Done

The process checks if the array is empty. If not, it reduces the size by one, effectively deleting the last element.

Execution Sample

DSA Java

int[] arr = {10, 20, 30, 40};
int size = 4;
// Delete last element
if (size > 0) size--;
// Now size is 3

This code deletes the last element by reducing the size variable, so the array is considered smaller by one.

Execution Table

Step	Operation	Array State	Size Before	Size After	Visual State
1	Start with array	[10, 20, 30, 40]	4	4	10 -> 20 -> 30 -> 40 -> null
2	Check if size > 0	[10, 20, 30, 40]	4	4	10 -> 20 -> 30 -> 40 -> null
3	Reduce size by 1	[10, 20, 30, 40]	4	3	10 -> 20 -> 30 -> null
4	End	[10, 20, 30, 40]	3	3	10 -> 20 -> 30 -> null

💡 Size reduced from 4 to 3, last element considered deleted

Variable Tracker

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

Key Moments - 2 Insights

Why do we reduce the size variable instead of removing the element physically?

Because arrays have fixed size in Java, we can't shrink them. Reducing size means we ignore the last element logically, as shown in step 3 of the execution table.

What happens if we try to delete when size is 0?

The check in step 2 prevents reducing size below 0. If size is 0, deletion stops immediately, no change occurs.

Visual Quiz - 3 Questions

Look at the execution table, what is the size after step 3?

A 4

B 3

C 2

D 0

💡 Hint

Check the 'Size After' column in row for step 3 in the execution table.

At which step does the last element get logically deleted?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Operation' and 'Visual State' columns in the execution table.

If the initial size was 1, what would be the size after deletion?

A 1

B 0

C 2

D -1

💡 Hint

Refer to the variable_tracker and how size changes after deletion.

Concept Snapshot

Array Deletion at End:
- Check if array size > 0
- Reduce size by 1 to delete last element
- Array physical size fixed, logical size changes
- Last element ignored after size reduction

Full Transcript

This concept shows how to delete the last element of an array by reducing the size variable. Since arrays in Java have fixed size, we cannot physically remove elements. Instead, we keep track of the current size and reduce it by one when deleting. The execution table shows starting with size 4, checking if size is greater than zero, then reducing size to 3, which means the last element is logically deleted. The variable tracker confirms the size changes while the array content remains the same. Key moments clarify why size reduction is used and what happens if deletion is attempted on an empty array.

Practice

1. What happens when you delete an element from the end of a fixed-size array in Java?

easy

A. The last element is removed and the array size decreases by one

B. The last element is set to zero or null but the array size stays the same

C. All elements shift left by one position

D. The array is completely cleared

Solution

1. Step 1: Understand fixed-size array behavior

   Java arrays have a fixed size once created, so their length cannot change.

2. Step 2: Effect of deleting at end

   Deleting means logically ignoring the last element or setting it to default (0 or null), but the array length remains unchanged.

3. Final Answer:

   The last element is set to zero or null but the array size stays the same -> Option B

4. Quick Check:

   Fixed-size array length unchanged on deletion [OK]

Hint: Fixed arrays keep size; deletion just clears last element [OK]

Common Mistakes:

• Thinking array size shrinks automatically
• Assuming elements shift after deletion
• Believing array clears fully on one deletion

2. Which of the following is the correct syntax to delete the last element from an array named arr in Java by reducing its logical size stored in size?

easy

A. arr[size--] = 0;

B. arr[size] = 0; size--;

C. size--; arr[size] = 0;

D. arr[size] = null; size++;

Solution

1. Step 1: Understand logical deletion

   To delete last element, first reduce size by one, then clear that element.

2. Step 2: Check syntax correctness

   size--; arr[size] = 0; reduces size first (size--) then sets arr[size] to 0, correctly deleting last element.

3. Final Answer:

   size--; arr[size] = 0; -> Option C

4. Quick Check:

   Decrease size before clearing element [OK]

Hint: Decrease size first, then clear element [OK]

Common Mistakes:

• Clearing element before decreasing size
• Using post-decrement incorrectly
• Increasing size instead of decreasing

3. What will be the output of the following Java code?

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

medium

A. 10 20 30 0 0

B. 10 20 30 40 0

C. 10 20 30 40 50

D. 10 20 30 40

Solution

1. Step 1: Understand size decrement and element clearing

   Size is reduced from 5 to 4, then arr[4] is set to 0, removing last element logically.

2. Step 2: Loop prints elements from index 0 to 3

   Loop runs i=0 to 3, printing arr[0]=10, arr[1]=20, arr[2]=30, arr[3]=40.

3. Final Answer:

   10 20 30 40 -> Option D

4. Quick Check:

   Last element removed, loop prints first 4 elements [OK]

Hint: Loop runs till size, last element skipped after decrement [OK]

Common Mistakes:

• Printing all 5 elements ignoring size
• Not updating last element to zero
• Confusing array index with size

4. Identify the error in this Java code snippet that tries to delete the last element from an array:

int[] arr = {1, 2, 3, 4};
int size = 4;
arr[size] = 0;
size--;

medium

A. Array index out of bounds error at arr[size] = 0;

B. Size variable is not decremented

C. Array elements are not shifted left

D. No error, code works fine

Solution

1. Step 1: Check array indexing

   Array indices go from 0 to size-1, so arr[size] is out of bounds.

2. Step 2: Identify correct order

   Must decrement size first, then access arr[size] to avoid error.

3. Final Answer:

   Array index out of bounds error at arr[size] = 0; -> Option A

4. Quick Check:

   Accessing arr[size] causes error [OK]

Hint: Decrement size before accessing arr[size] [OK]

Common Mistakes:

• Accessing arr[size] directly
• Not decrementing size before deletion
• Ignoring array index limits

5. You have an array int[] arr = {5, 10, 15, 20, 25} and a variable size = 5. You want to logically delete the last two elements without modifying the values in the array and print the remaining elements. Which code snippet correctly does this?

hard

A. size -= 2;
for(int i = 0; i < size; i++) System.out.print(arr[i] + " ");

B. arr[size-1] = 0; arr[size-2] = 0; size -= 2;
for(int i = 0; i < size; i++) System.out.print(arr[i] + " ");

C. size -= 2;
arr[size] = 0; arr[size+1] = 0;
for(int i = 0; i < size; i++) System.out.print(arr[i] + " ");

D. for(int i = 0; i < size-2; i++) System.out.print(arr[i] + " ");

Solution

1. Step 1: Reduce logical size by 2

   Decreasing size by 2 means last two elements are ignored logically.

2. Step 2: Print elements up to new size

   Loop from 0 to size-1 prints remaining elements correctly.

3. Final Answer:

   size -= 2; for(int i = 0; i < size; i++) System.out.print(arr[i] + " "); -> Option A

4. Quick Check:

   Logical size controls printed elements [OK]

Hint: Reduce size, then print up to size [OK]

Common Mistakes:

• Setting elements to zero before reducing size
• Printing without adjusting size
• Accessing invalid indices after deletion