Queue Alternative Implementations
Internal
Overview
To Refactor
The following implementation uses an array, which dictates the queue length. The queue grows circularly and wraps around the edge of the array as the data is enqueued and dequeued. Instead of using size and tail accounting, we use to pointers, "head" and "tail", containing the indexes of the corresponding head and tail elements. The "head" pointer indicates the head element - the one that will be dequeued next, while "tail" points to the position where the next enqueued element will be placed.
An empty queue is indicated by the fact that the "head" and the "tail" pointers have the same value.
We have two choices when it comes to model a full queue. If we want to use all the n elements in the array for queue element storage, then we model the "full" position with an external boolean, because otherwise there would be no way to distinguish the "empty queue" head and tail overlap and "full queue" head and tail overlap. Another possibility is to use only n - 1 elements of the array for queue element storage, and use one array element as a "marker" that always separates the head from the tail. This way, the "head" and "tail" pointers never overlap for a full queue, just for an empty queue.
The equivalent implementations are presented below:
n element Queue
We model "full" and "empty" by allowing the "head" and "tail" markers to overlap, and we maintain an extra bit of data that tells those states apart. This way we can use all n array elements for queue element storage.
/**
* A queue of ints that uses all n storage elements for queue element storage.
* It needs an additional boolean variable to maintain whether the queue is
* full or not.
*/
public class Queue {
private int[] storage;
// this is the index of the queue head element
private int head;
// this is the index of the element where the tail *would* go
private int tail;
private boolean full;
public Queue(int capacity) {
this.storage = new int[capacity];
this.head = 0;
this.tail = 0;
this.full = false;
}
public void enqueue(int i) throws QueueOverflowException {
//
// check if the queue is full
//
if (full) {
throw new QueueOverflowException();
}
storage[tail] = i;
tail = (tail + 1) % storage.length;
//
// this is the only time we can determine the queue is full
//
if (head == tail) {
this.full = true;
}
}
public int dequeue() throws QueueUnderflowException {
if (head == tail && !full) {
throw new QueueUnderflowException();
}
int result = storage[head];
head = (head + 1) % storage.length;
full = false;
return result;
}
public boolean isEmpty() {
return head == tail;
}
public boolean isFull() {
return full;
}
}
n-1 element Queue
We model by allowing the "head" and "tail" markers to overlap, and the full queue will always have a gap between head and tail. This way we can use only n-1 array elements for queue element storage.
/**
* A queue of ints that uses just n-1 storage elements for queue element storage, and
* it can tell when it is full without maintaining an additional boolean variable.
*/
public class Queue {
private int[] storage;
// this is the index of the queue head element
private int head;
// this is the index of the element where the tail *would* go
private int tail;
public Queue(int capacity) {
this.storage = new int[capacity];
this.head = 0;
this.tail = 0;
}
public void enqueue(int i) throws QueueOverflowException {
//
// verify whether by enqueueing this element the tail will overlap with the head
// if they do, it means the queue is full
//
if ((tail + 1) % storage.length == head) {
throw new QueueOverflowException();
}
storage[tail] = i;
tail = (tail + 1) % storage.length;
}
public int dequeue() throws QueueUnderflowException {
if (head == tail) {
throw new QueueUnderflowException();
}
int result = storage[head];
head = (head + 1) % storage.length;
return result;
}
public boolean isEmpty() {
return head == tail;
}
public boolean isFull() {
return (tail + 1) % storage.length == head;
}
}