Deletion in array implementation of queues reduces capacity? - c++

Question

In all queue array implementations I have seen, when they 'pop an element from front', they basically change the front tag of the queue to the next element. but then the capacity of the queue is technically reduced (since array is used). How hasn't this caused problems yet or how is this considered valid?
Edit : https://www.softwaretestinghelp.com/queue-in-cpp/
Take the illustration in this link under consideration. When we perform the dequeue operation, we change the pointer of front to the next element. From this point on, any operation we perform will be done with respect to the 2nd position of array as the front element. Now if we go on adding elements to the full capacity of queue, we would, the maximum no. of elements that we could fit in the queue would be 1 less than the capacity of the array (which we had defined earlier).

Answer 1

You are right with your concern about the C++ implementation given in the article https://www.softwaretestinghelp.com/queue-in-cpp/. With that implementation, basically when you dequeue an element, the pointer to the "first" of the queue shift 1 unit to the right (in the underlying array), and that reduce the capacity of the queue.
The correct way to implement such a queue should be similar to the Java implementation provided in that very article. As you can see, every array indices are pre-processed with % this.max_size. That makes the array accessing become "circular", i.e. when we access an index k >= this.max_size, the real array index is back to the range [0, this.max_size - 1]. As a result, all the slot in the underlying array are used, which makes the capacity of the queue remain the same after the dequeue or enqueue operation.
Here is the corrected version of the C++ implementation.
#include <iostream>
#define MAX_SIZE 5
using namespace std;
class Queue
{
private:
int myqueue[MAX_SIZE], front, rear;
public:
Queue ()
{
front = -1;
rear = -1;
}
bool isFull ()
{
if ((rear - front + MAX_SIZE) % MAX_SIZE == MAX_SIZE - 1)
{
return true;
}
return false;
}
bool isEmpty ()
{
if (front == -1)
return true;
else
return false;
}
void enQueue (int value)
{
if (isFull ())
{
cout << endl << "Queue is full!!";
}
else
{
if (front == -1)
front = 0;
rear++;
myqueue[rear % MAX_SIZE] = value;
cout << value << " ";
}
}
int deQueue ()
{
int value;
if (isEmpty ())
{
cout << "Queue is empty!!" << endl;
return (-1);
}
else
{
value = myqueue[front % MAX_SIZE];
if (front >= rear)
{ //only one element in queue
front = -1;
rear = -1;
}
else
{
front++;
}
cout << endl << "Deleted => " << value << " from myqueue";
return (value);
}
}
/* Function to display elements of Queue */
void displayQueue ()
{
int i;
if (isEmpty ())
{
cout << endl << "Queue is Empty!!" << endl;
}
else
{
cout << endl << "Front = " << front;
cout << endl << "Queue elements : ";
for (i = front; i <= rear; i++)
cout << myqueue[i % MAX_SIZE] << "\t";
cout << endl << "Rear = " << rear << endl;
}
}
};
int
main ()
{
Queue myq;
myq.deQueue (); //deQueue
cout << "Queue created:" << endl;
myq.enQueue (10);
myq.enQueue (20);
myq.enQueue (30);
myq.enQueue (40);
myq.enQueue (50); //enqueue 60 => queue is full
myq.enQueue (60);
myq.displayQueue ();
//deQueue =>removes 10, 20
myq.deQueue ();
myq.deQueue ();
//queue after dequeue
myq.displayQueue ();
myq.enQueue (70);
myq.enQueue (80);
myq.enQueue (90); //enqueue 90 => queue is full
myq.displayQueue ();
return 0;
}