Array Deletion at Beginning in DSA C++

Mental Model

Deleting the first item in an array means removing it and shifting all other items left by one position.

Analogy: Imagine a line of people waiting to buy tickets. When the first person leaves, everyone else steps forward to fill the empty spot.

Index: 0   1   2   3   4
Array: [1]->[2]->[3]->[4]->[5]

Dry Run Walkthrough

Input: array: [1, 2, 3, 4, 5], delete element at beginning

Goal: Remove the first element and shift all others left to keep order

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

[1]->[2]->[3]->[4]->[5]

Why: We start by identifying the element to delete at the beginning

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

[2]->[2]->[3]->[4]->[5]

Why: Move the second element forward to fill the empty first spot

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

[2]->[3]->[3]->[4]->[5]

Why: Continue shifting elements left to maintain order

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

[2]->[3]->[4]->[4]->[5]

Why: Keep shifting elements left

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

[2]->[3]->[4]->[5]->[5]

Why: Last element moves left to fill the gap

Step 6: Reduce array size by 1, ignore last duplicate

[2]->[3]->[4]->[5]

Why: Remove the last duplicate element to complete deletion

Result:

Index: 0   1   2   3
Array: [2]->[3]->[4]->[5]

Annotated Code

DSA C++

#include <iostream>
using namespace std;

class Array {
public:
    int* data;
    int size;

    Array(int arr[], int n) {
        size = n;
        data = new int[size];
        for (int i = 0; i < size; i++) {
            data[i] = arr[i];
        }
    }

    void deleteAtBeginning() {
        if (size == 0) return; // handle empty array
        for (int i = 1; i < size; i++) {
            data[i - 1] = data[i]; // shift elements left
        }
        size--; // reduce size by one
    }

    void print() {
        for (int i = 0; i < size; i++) {
            cout << data[i];
            if (i != size - 1) cout << " -> ";
        }
        cout << "\n";
    }

    ~Array() {
        delete[] data;
    }
};

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    Array array(arr, 5);
    array.deleteAtBeginning();
    array.print();
    return 0;
}

if (size == 0) return; // handle empty array

check if array is empty to avoid errors

for (int i = 1; i < size; i++) { data[i - 1] = data[i]; // shift elements left }

shift each element left by one to overwrite the first element

size--; // reduce size by one

reduce array size to reflect deletion

Output

2 -> 3 -> 4 -> 5

Complexity Analysis

Time: O(n) because we shift all n-1 elements one position left

Space: O(n) because we store the array elements in memory

vs Alternative: Compared to linked lists where deletion at beginning is O(1), array deletion requires shifting elements, making it slower for large arrays

Edge Cases

empty array

function returns immediately without error

DSA C++

if (size == 0) return; // handle empty array

array with one element

deletion results in empty array with size zero

DSA C++

size--; // reduce size by one

When to Use This Pattern

When you need to remove the first item from a fixed-size list and keep order, think of array deletion at beginning which requires shifting elements.

Common Mistakes

Mistake: Not shifting elements left after deleting the first element
Fix: Add a loop to move each element one position to the left

Mistake: Not reducing the size after deletion
Fix: Decrease the size variable by one to reflect the new array length

Summary

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

Use when you must remove the first item but keep the order of remaining items.

The key insight is that arrays need shifting to fill the gap left by 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 deletion at beginning

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

2. Step 2: Effect on array elements

   All other elements move one position left to fill the gap.

3. Final Answer:

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

4. Quick Check:

   Deletion at start shifts elements left [OK]

Hint: Deleting start means shift left all elements [OK]

Common Mistakes:

• Thinking elements shift right instead of left
• Assuming array size increases
• Believing array stays unchanged

2. Which of the following C++ code snippets correctly deletes the first element of an array arr of size n by shifting elements left?

easy

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

B. for (int i = n - 1; i > 0; i--) arr[i] = arr[i - 1]; n++;

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

D. for (int i = 0; i < n; i++) arr[i] = arr[i]; n--;

Solution

1. Step 1: Identify correct loop for shifting left

   The loop must start at 0 and assign arr[i] = arr[i+1] to shift left.

2. Step 2: Check array size update

   After shifting, size decreases by 1 (n--).

3. Final Answer:

   for (int i = 0; i < n - 1; i++) arr[i] = arr[i + 1]; n--; -> Option C

4. Quick Check:

   Shift left loop from 0 to n-2, then n-- [OK]

Hint: Shift left from i=0 to n-2, then reduce size [OK]

Common Mistakes:

• Looping backwards instead of forwards
• Increasing size instead of decreasing
• Copying elements incorrectly

3. What is the output of the following C++ code?

int arr[5] = {10, 20, 30, 40, 50};
int n = 5;
for (int i = 0; i < n - 1; i++) {
    arr[i] = arr[i + 1];
}
n--;
for (int i = 0; i < n; i++) {
    std::cout << arr[i] << " ";
}

medium

A. 50 40 30 20

B. 20 30 40 50

C. 10 20 30 40 50

D. 30 40 50

Solution

1. Step 1: Perform element shifting

   Elements shift left: arr[0]=20, arr[1]=30, arr[2]=40, arr[3]=50.

2. Step 2: Update size and print

   Size n becomes 4, so print arr[0] to arr[3]: 20 30 40 50.

3. Final Answer:

   20 30 40 50 -> Option B

4. Quick Check:

   First element removed, rest shifted left [OK]

Hint: After deletion, print first n-1 elements shifted left [OK]

Common Mistakes:

• Printing original array without shift
• Printing one extra element
• Confusing order of elements

4. Identify the error in the following code that attempts to delete the first element of an array arr of size n:

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

medium

A. The loop should start from i = 0 and go to n - 1.

B. The loop correctly shifts elements left, no error.

C. The array size should increase, not decrease.

D. The loop shifts elements right instead of left, causing data overwrite.

Solution

1. Step 1: Analyze loop direction and assignment

   The loop assigns arr[i] = arr[i - 1], shifting elements right, which is wrong for deletion at start.

2. Step 2: Understand correct shifting for deletion

   Deletion requires shifting elements left: arr[i] = arr[i + 1].

3. Final Answer:

   The loop shifts elements right instead of left, causing data overwrite. -> Option D

4. Quick Check:

   Deletion needs left shift, not right [OK]

Hint: Deletion shifts left; right shift is wrong [OK]

Common Mistakes:

• Shifting elements in wrong direction
• Not updating array size
• Starting loop at wrong index

5. Given an array arr of size n, you want to delete the first element multiple times until the array is empty. Which approach is the most efficient to handle this repeated deletion without shifting elements every time?

hard

A. Use a variable to track the start index and increment it on each deletion.

B. Shift all elements left on every deletion and decrease size.

C. Create a new array each time with one less element.

D. Reverse the array and delete from the end.

Solution

1. Step 1: Understand cost of shifting on repeated deletions

   Shifting elements left every time costs O(n) per deletion, inefficient for many deletions.

2. Step 2: Use a start index pointer

   Keep a start index that moves forward on each deletion, avoiding shifting.

3. Step 3: Adjust size accordingly

   Decrease size or track remaining elements using start index and size.

4. Final Answer:

   Use a variable to track the start index and increment it on each deletion. -> Option A

5. Quick Check:

   Track start index to avoid shifting [OK]

Hint: Track start index to delete efficiently [OK]

Common Mistakes:

• Shifting elements every time causing slow code
• Creating new arrays repeatedly wasting memory
• Reversing array unnecessarily