Array Deletion at Beginning in DSA Java

Mental Model

Deleting the first item in an array means shifting all other items one step left to fill the empty space.

Analogy: Imagine a row of chairs with people sitting. If the first person leaves, everyone else moves one chair forward to fill the empty spot.

Index:  [0]  [1]  [2]  [3]  [4]
Array:  10 -> 20 -> 30 -> 40 -> 50

Dry Run Walkthrough

Input: array: [10, 20, 30, 40, 50], delete element at beginning

Goal: Remove the first element and shift all others left, reducing array size by one

Step 1: Remove element at index 0 (value 10)

Index:  [0]  [1]  [2]  [3]  [4]
Array:  null 20 -> 30 -> 40 -> 50

Why: We want to delete the first element, so it becomes empty

Step 2: Shift element at index 1 (20) to index 0

Index:  [0]  [1]  [2]  [3]  [4]
Array:  20 -> null 30 -> 40 -> 50

Why: Fill the empty spot at the start by moving the next element left

Step 3: Shift element at index 2 (30) to index 1

Index:  [0]  [1]  [2]  [3]  [4]
Array:  20 -> 30 -> null 40 -> 50

Why: Continue shifting elements left to fill gaps

Step 4: Shift element at index 3 (40) to index 2

Index:  [0]  [1]  [2]  [3]  [4]
Array:  20 -> 30 -> 40 -> null 50

Why: Keep shifting elements left

Step 5: Shift element at index 4 (50) to index 3

Index:  [0]  [1]  [2]  [3]  [4]
Array:  20 -> 30 -> 40 -> 50 -> null

Why: Last element moves left, last index becomes empty

Step 6: Reduce array size by one (ignore last null)

Index:  [0]  [1]  [2]  [3]
Array:  20 -> 30 -> 40 -> 50

Why: Array size shrinks because first element was deleted

Result:

Index:  [0]  [1]  [2]  [3]
Array:  20 -> 30 -> 40 -> 50

Annotated Code

DSA Java

public class ArrayDeletionAtBeginning {
    public static int[] deleteAtBeginning(int[] arr) {
        if (arr == null || arr.length == 0) {
            return arr; // empty array, nothing to delete
        }
        int n = arr.length;
        for (int i = 1; i < n; i++) {
            arr[i - 1] = arr[i]; // shift element left
        }
        // create new array with size one less
        int[] newArr = new int[n - 1];
        for (int i = 0; i < n - 1; i++) {
            newArr[i] = arr[i];
        }
        return newArr;
    }

    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            if (i != arr.length - 1) {
                System.out.print(" -> ");
            }
        }
        System.out.println(" -> null");
    }

    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};
        System.out.print("Original array: ");
        printArray(arr);
        arr = deleteAtBeginning(arr);
        System.out.print("After deletion: ");
        printArray(arr);
    }
}

for (int i = 1; i < n; i++) { arr[i - 1] = arr[i]; // shift element left }

shift all elements one position left to overwrite the first element

int[] newArr = new int[n - 1]; for (int i = 0; i < n - 1; i++) { newArr[i] = arr[i]; }

create new smaller array and copy shifted elements to it

return newArr;

return the new array without the first element

Output

Original array: 10 -> 20 -> 30 -> 40 -> 50 -> null

After deletion: 20 -> 30 -> 40 -> 50 -> null

Complexity Analysis

Time: O(n) because we shift all elements once and copy them to a new array

Space: O(n) because we create a new array with size one less than original

vs Alternative: Compared to linked lists where deletion at beginning is O(1), arrays require shifting elements making it O(n)

Edge Cases

empty array

returns the same empty array without error

DSA Java

if (arr == null || arr.length == 0) {
    return arr; // empty array, nothing to delete
}

single element array

returns an empty array after deletion

DSA Java

int[] newArr = new int[n - 1];

When to Use This Pattern

When you need to remove the first item from an array and keep order, think about shifting elements left to fill the gap.

Common Mistakes

Mistake: Not shifting elements left, just setting first element to null or zero
Fix: Shift all elements left to overwrite the first element before resizing

Mistake: Trying to reduce array size without creating a new array
Fix: Create a new smaller array and copy shifted elements into it

Summary

Deletes the first element of an array by shifting all other elements left and resizing the array.

Use when you need to remove the first item but keep the order of remaining elements.

The key insight is that arrays require shifting elements left to fill the empty spot after deletion.

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