Array Insertion at End in DSA Java

Mental Model

Adding a new item means placing it right after the last filled spot in the list.

Analogy: Imagine a row of empty boxes where you put toys one by one from left to right. Inserting at the end means putting the next toy in the first empty box after all filled ones.

Index: 0   1   2   3   4
Array: [5] [8] [3] [ ] [ ]
               ↑ next insert here

Dry Run Walkthrough

Input: array: [5, 8, 3, _, _], insert value 7 at end

Goal: Place the value 7 in the first empty spot after the last filled element

Step 1: Find the first empty spot after filled elements

Index: 0   1   2   3   4
Array: [5] [8] [3] [ ] [ ]
               ↑ next insert here

Why: We need to know where to put the new value

Step 2: Insert value 7 at index 3

Index: 0   1   2   3   4
Array: [5] [8] [3] [7] [ ]

Why: We place the new value in the first empty spot

Step 3: Update the count of filled elements to 4

Index: 0   1   2   3   4
Array: [5] [8] [3] [7] [ ]
                    ↑ next insert here

Why: We track how many elements are now filled

Result:

Index: 0   1   2   3   4
Array: [5] [8] [3] [7] [ ]
                    ↑ next insert here

Annotated Code

DSA Java

public class ArrayInsertion {
    static class ArrayList {
        int[] arr;
        int size;
        int capacity;

        public ArrayList(int capacity) {
            this.capacity = capacity;
            arr = new int[capacity];
            size = 0;
        }

        public void insertAtEnd(int value) {
            if (size == capacity) {
                System.out.println("Array is full, cannot insert.");
                return;
            }
            arr[size] = value; // place value at first empty spot
            size++; // increase count of filled elements
        }

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

    public static void main(String[] args) {
        ArrayList list = new ArrayList(5);
        list.insertAtEnd(5);
        list.insertAtEnd(8);
        list.insertAtEnd(3);
        list.printArray();
        list.insertAtEnd(7);
        list.printArray();
    }
}

if (size == capacity) {

check if array is full to avoid overflow

arr[size] = value; // place value at first empty spot

insert new value at the end of filled elements

size++; // increase count of filled elements

update size to reflect new element added

Output

5 -> 8 -> 3 -> null

5 -> 8 -> 3 -> 7 -> null

Complexity Analysis

Time: O(1) because insertion at the end is direct without shifting elements

Space: O(n) because the array size is fixed and stores n elements

vs Alternative: Compared to inserting at the start or middle which requires shifting elements O(n), insertion at end is faster and simpler

Edge Cases

inserting into a full array

insertion is rejected with a message, no change to array

DSA Java

if (size == capacity) {

inserting into an empty array

value is placed at index 0, size becomes 1

DSA Java

arr[size] = value;

When to Use This Pattern

When you need to add items to a list and want fast insertion at the end, use array insertion at end pattern because it avoids shifting elements.

Common Mistakes

Mistake: Trying to insert at an index beyond current size causing gaps
Fix: Always insert at index equal to current size to keep elements contiguous

Mistake: Not checking if array is full before inserting
Fix: Add a check to prevent overflow before insertion

Summary

Adds a new element at the first empty spot after the last filled element in an array.

Use when you want to quickly add items to the end of a fixed-size list without shifting.

Remember to track the current size to know where to insert next.

Practice

1. What happens when you insert an element at the end of a fixed-size array in Java without resizing?

easy

A. The insertion throws an error if the array is full

B. The element is added at the next free position if available

C. The array automatically resizes to fit the new element

D. The element replaces the last element if the array is full

Solution

1. Step 1: Understand fixed-size array behavior

   Java arrays have a fixed size and cannot grow automatically. Attempting arr[size] where size == length throws ArrayIndexOutOfBoundsException.

2. Step 2: Inserting at end when full

   Standard insertion arr[size++] = element; if full (size == arr.length), accesses arr[length] and throws runtime error.

3. Final Answer:

   The insertion throws an error if the array is full -> Option A

4. Quick Check:

   Fixed-size array throws error when full [OK]

Hint: Fixed arrays don't resize; throws error if full [OK]

Common Mistakes:

• Assuming arrays resize automatically
• Thinking insertion overwrites last element
• Believing new element is added beyond array size

2. Which of the following is the correct syntax to insert an element at the end of an array in Java if the array has space?

easy

A. arr[size] = newElement; size++;

B. arr[arr.length - 1] = newElement;

C. arr[arr.length] = newElement;

D. arr.add(newElement);

Solution

1. Step 1: Understand array indexing and size tracking

   Arrays use zero-based indexing; last index is length-1. We track current size separately.

2. Step 2: Insert element at next free position

   Use size as index to insert, then increment size to reflect new element count.

3. Final Answer:

   arr[size] = newElement; size++; -> Option A

4. Quick Check:

   Use size as index and increment after insertion [OK]

Hint: Use size variable as index, then increment size [OK]

Common Mistakes:

• Using arr.length as index (out of bounds)
• Trying to use arr.add() which is for lists
• Overwriting last element without size tracking

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

int[] arr = new int[5];
int size = 0;
arr[size++] = 10;
arr[size++] = 20;
arr[size++] = 30;
System.out.print(java.util.Arrays.toString(arr));

medium

A. [10, 20, 30]

B. [10, 20, 30, 0, 0]

C. [10, 20, 30, 30, 30]

D. [0, 10, 20, 30, 0]

Solution

1. Step 1: Trace insertions with size increment

   Elements 10, 20, 30 are inserted at indexes 0, 1, 2 respectively; size increments after each insertion.

2. Step 2: Understand default array values

   Remaining positions (indexes 3 and 4) remain 0 as default for int arrays.

3. Final Answer:

   [10, 20, 30, 0, 0] -> Option B

4. Quick Check:

   Inserted elements at start; rest are zeros [OK]

Hint: Inserted elements fill start; rest remain default zero [OK]

Common Mistakes:

• Assuming array shrinks to inserted elements only
• Confusing index positions
• Expecting uninitialized elements to be null

4. Identify the error in the following code that tries to insert an element at the end of an array:

int[] arr = new int[3];
int size = 3;
arr[size] = 5;

medium

A. Compilation error due to wrong syntax

B. No error; element inserted at the end

C. ArrayIndexOutOfBoundsException because size equals array length

D. Logical error; element overwrites first element

Solution

1. Step 1: Check array size and index used

   Array length is 3, valid indexes are 0,1,2. Using index 3 causes error.

2. Step 2: Understand runtime exception

   Accessing arr[3] throws ArrayIndexOutOfBoundsException at runtime.

3. Final Answer:

   ArrayIndexOutOfBoundsException because size equals array length -> Option C

4. Quick Check:

   Index equals length causes runtime error [OK]

Hint: Index must be less than array length to avoid error [OK]

Common Mistakes:

• Assuming index == length is valid
• Expecting compile-time error instead of runtime
• Ignoring size variable correctness

5. You have an integer array of size 4: int[] arr = {1, 2, 3, 4}; and a variable size = 4;. You want to insert 5 at the end but the array is full. Which approach correctly adds 5 at the end without losing existing data?

hard

A. Overwrite arr[3] with 5 directly

B. Increase size variable to 5 and assign arr[4] = 5

C. Use arr[size] = 5 without resizing

D. Create a new array of size 5, copy old elements, then add 5 at index 4

Solution

1. Step 1: Recognize fixed array size limitation

   Original array size is 4; cannot add element beyond index 3 without resizing.

2. Step 2: Create new larger array and copy elements

   Create new array of size 5, copy existing elements, then insert 5 at index 4.

3. Final Answer:

   Create a new array of size 5, copy old elements, then add 5 at index 4 -> Option D

4. Quick Check:

   Resize by new array and copy before insertion [OK]

Hint: Resize array by copying before adding new element [OK]

Common Mistakes:

• Trying to insert without resizing
• Overwriting last element losing data
• Assuming size variable controls array length