1) How many values can the queue hold?#

The queue can hold 4 values (not 5, despite the capacity=5).

Why? The addItem method uses the condition if (firstFree < capacity - 1). For capacity=5, this means firstFree can only go up to 3 (since 3 < 4). Thus, indices 0-3 are used (4 elements total).

2) How can you fix this? What then happens?#

Fix: Change the condition in addItem from firstFree < capacity - 1 to firstFree < capacity.

1
void addItem(int item) {
2
    if (firstFree < capacity) {  // Fixed: removed "- 1"
3
        theQueue[firstFree] = item;
4
        firstFree++;
5
    }
6
}

Result: The queue now holds the full 5 values (indices 0-4), as intended.

3) Where is the real problem? Fix that too.#

The real problem is in the remove method: its loop causes an ArrayIndexOutOfBoundsException when shifting elements.

Original loop:

1
for (int i = 0; i < firstFree; i++)
2
    theQueue[i] = theQueue[i+1];  // i+1 exceeds array bounds when i = firstFree-1

When firstFree = n, i runs from 0 to n-1, so i+1 becomes n (which is out of bounds for an array of size capacity).

Fix: Change the loop condition to i < firstFree - 1:

1
int remove() {
2
    if (firstFree == 0) return 0;
3
    int item = theQueue[0];
4
    for (int i = 0; i < firstFree - 1; i++)  // Fixed: stop at firstFree-2
5
        theQueue[i] = theQueue[i+1];
6
    firstFree--;
7
    return item;
8
}

4) What happens if a calling program tries to add too many values to the queue?#

The addItem method silently ignores the extra values—it does nothing (no error, no exception, no feedback to the caller).

5) What do you think of that way of handling that issue?#

This is poor practice. Silent failures make debugging difficult: the caller has no way of knowing their item was not added. A better approach would be to:

• Throw an exception (e.g., IllegalStateException), or
• Return a boolean (true = added, false = queue full).

6) When corrected, what is the big-O performance of addItem?#

O(1) (constant time). Adding an item only involves checking the condition, writing to the array, and incrementing firstFree—no loops or data shifting.

7) When corrected, what is the big-O performance of remove?#

O(n) (linear time). Removing an item requires shifting all remaining elements left by one position (the loop runs firstFree - 1 times, where n is the number of elements in the queue).

8) Does this have any advantages over a “circular” queue?#

The only advantage is simplicity:

• This implementation uses fewer variables (no front/rear indices or modulo arithmetic).
• The code is easier for beginners to read and understand.

However, circular queues are far more efficient for remove operations (O(1) vs. O(n) here), so this simplicity comes at a performance cost.