ArrayQueue: An Array-Based Queue

ArrayQueue operations

In this lesson, we present the ArrayQueue data structure, which implements a FIFO (first-in-first-out) queue; elements are removed (using the remove() operation) from the queue in the same order they are added (using the add(x) operation).

Notice that an ArrayStack is not a good choice for an implementation of a FIFO queue because we must choose one end of the list upon which to add elements and then remove elements from the other end. One of the two operations must work on the head of the list, which involves calling add(i, x) or remove(i) with a value of i = 0. This gives a running time proportional to $n$.

To obtain an efficient array-based implementation of a queue, we first notice that the problem would be easy if we had an infinite array $a$. We could maintain one index j that keeps track of the next element to remove and an integer n that counts the number of elements in the queue. The queue elements would always be stored in

$$a[j],a[j+1],...,a[j+n−1]$$

Initially, both j and n would be set to $0$. To add an element, we would place it in a[j + n] and increment n. To remove an element, we would remove it from a[j], increment j, and decrement n.

Of course, the problem with this solution is that it requires an infinite array. An ArrayQueue simulates this by using a finite array $a$ and modular arithmetic. This is the kind of arithmetic used when we are talking about the time of day. For example $10:00$ plus five hours gives $3:00$ ...