Array Deletion at Beginning in DSA Java - Time & Space Complexity

Time Complexity: Array Deletion at Beginning

O(n)

Understanding Time Complexity

When we delete an element from the start of an array, the rest of the elements need to move. We want to understand how this moving affects the time it takes.

How does the time to delete grow as the array gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

public void deleteAtBeginning(int[] arr, int size) {
    for (int i = 1; i < size; i++) {
        arr[i - 1] = arr[i];
    }
    size--;
}
    

This code removes the first element by shifting all other elements one position to the left.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The for-loop that shifts elements left by one.
• How many times: It runs once for each element after the first, so roughly n - 1 times.

How Execution Grows With Input

As the array size grows, the number of moves grows almost the same way.

Input Size (n)	Approx. Operations
10	9 moves
100	99 moves
1000	999 moves

Pattern observation: The number of moves grows linearly with the array size.

Final Time Complexity

Time Complexity: O(n)

This means the time to delete the first element grows directly with the number of elements in the array.

Common Mistake

[X] Wrong: "Deleting the first element is quick because we just remove it."

[OK] Correct: Actually, all other elements must move to fill the gap, so the operation takes time proportional to the array size.

Interview Connect

Understanding this helps you explain why some data structures are better for certain operations. It shows you can think about how code runs, not just what it does.

Self-Check

"What if we deleted the last element instead of the first? How would the time complexity change?"

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