Stacks and Queues

Both stacks and queues are like sequences (ordered collections of items), but with more restricted operations. They can both be implemented either using an array or using a linked list to hold the actual items.

The conceptual picture of a stack is something like this:

                  _______       _________
                 /       \     /         \
	values in	 \/   /          \/
	                | -----  |     values out
			|        |
			| -----  |
			|        |
			| -----  |
			|        |
			|        |
			----------

Here are the (conceptual) stack operations:

The conceptual picture of a queue is something like this:

                 ------------------
values in ---->  items in the queue   ----> values out
                 ------------------
                 ^                ^
                 |                |
     this is the rear of          this is the front of
     the queue                    the queue

Here are the (conceptual) queue operations:

OPERATION	DESCRIPTION
isEmpty	true iff the queue is empty
size	return the number of items in the queue
enqueue	add a given item to the rear of the queue
dequeue	remove and return the item from the front of the queue (error if the queue is empty)

The stack ADT is very similar to the sequence ADT; therefore, their implementations are also quite similar. One difference is that a stack has no "current" item (so there is no need to have a "current" field in the Stack class). In a sense, the current stack item is always the one at the top of the stack.

Below is the definition of the Stack class, using an array to store the items in the stack; note that we include a static final variable INITSIZE, to be used by the Stack constructor as the initial size of the array (the same thing was done for the Sequence class).

public class Stack {
  //*** methods ***

  // constructor
    public Stack() { ... }      

  // add items
    public void push(Object ob) { ... }  

  // remove items
    public Object pop() { ... } throws EmptyStackException { ... }

  // other methods
    public Object peek() { ... } throws EmptyStackException { ... }
    public int size() { ... }      
    public boolean isEmpty() { ... }  

  // *** fields ***
    private static final int INITSIZE = 10;  // initial array size
    private Object[] items; // the items in the stack
    private int numItems;   // the number of items in the stack
}  

To implement a stack using a linked list, we must first define the Listnode class (as a non-public class in the same file as the Stack class). The Listnode definition is the same one we used for the linked-list implementation of the Sequence class.

class Listnode {
  // fields
    Object data;
    Listnode next;

  // methods
    // 2 constructors
    Listnode(Object d) {
	this(d, null);
    }

    Listnode(Object d, Listnode n) {
	data = d;
	next = n;
    }
}

private Listnode items;  // pointer to the linked list of items in the stack

As discussed above, an important property of stacks is that items are only pushed and popped at one end (the top of the stack). If we implement a stack using a linked list, we can choose which end of the list corresponds to the top of the stack. It is easiest and most efficient to add and remove items at the front of a linked list, therefore, we will choose the front of the list as the top of the stack (i.e., the items field will be a pointer to the node that contains the top-of-stack item). Below is a picture of a stack represented using a linked list; in this case, items have been pushed in alphabetical order, so "cc" is at the top of the stack:

Notice that, in the picture, the top of stack is to left (at the front of the list), while for the array implementation, the top of stack was to the right (at the end of the array).

Let's consider how to write the pop method. It will need to perform the following steps:

1. Check whether the stack is empty; if so, throw an EmptyStackException.
2. Remove the first node from the list by setting items = items.next.
3. Decrement numItems.
4. Return the value that was in the first node in the list.

public Object pop() throws EmptyStackException {
    if (isEmpty()) throw new EmptyStackException();  // step 1
    Object tmp = items.data;  // step 2(a)
    items = items.next;       // step 2(b)
    numItems--;               // step 3
    return tmp;               // step 4
}

Now let's consider the push method. Here are before and after pictures, illustrating the effect of a call to push when the stack is implemented using a linked list:

The steps that need to be performed are:

1. Create a new node whose data field contains the object to be pushed and whose next field contains a pointer to the first node in the list (or null if the list is empty). Note that the value for the next field of the new node is the value in the Stack's items field.
2. Change items to point to the new node.
3. Increment numItems.

The main difference between a stack and a queue is that a stack is only accessed from the top, while a queue is accessed from both ends (from the rear for adding items, and from the front for removing items). This makes both the array and the linked-list implementation of a queue more complicated than the corresponding stack implementations.

Let's first consider a Queue implementation that is very similar to our (array-based) Sequence implementation. Here's the class definition:

public class Queue {
  //*** methods ***

  // constructor
    public Queue() { ... }      

  // add items
    public void enqueue(Object ob) { ... }  

  // remove items
    public Object dequeue() { ... } throws EmptyQueueException { ... }

  // other methods
    public int size() { ... }      
    public boolean isEmpty() { ... }  

  // *** fields ***
    private static final int INITSIZE = 10;  // initial array size
    private Object[] items; // the items in the queue
    private int numItems;   // the number of items in the queue
}  

To make both enqueue and dequeue efficient, we need the following insight: There is no reason to force the front of the queue always to be in items[0], we can let it "move up" as items are dequeued. To do this, we need to keep track of the indexes of the items at the front and rear of the queue (so we need to add two new fields, frontIndex and rearIndex, both of type int). To illustrate this idea, here is a picture of a queue after some enqueue and dequeue operations have been performed:

Now think about what should happen to this queue if we enqueue two more items: "dd" and "ee". Clearly "dd" should be stored in items[6]. Then what? We could increase the size of the array and put "ee" in items[7], but that would lead to wasted space -- we would never reuse items[0], items[1], or items[2]. In general, the items in the queue would keep "sliding" to the right in the array, causing more and more wasted space at the beginning of the array. A better approach is to let the rear index "wrap around" (in this case, from 6 to 0) as long as there is empty space in the front of the array. Similarly, if after enqueuing "dd" and "ee" we dequeue four items (so that only "ee" is left in the queue), the front index will have to wrap around from 6 to 0. Here's a picture of what happens when we enqueue "dd" and "ee":

Conceptually, the array is a circular array. It may be easier to visualize it as a circle. For example, the array for the final queue shown above could be thought of as:

We still need to think about what should happen if the array is full; we'll consider that case in a minute. Here's the code for the enqueue method, with the "full array" case still to be filled in:

public void enqueue(Object ob) {
  // check for full array and expand if necessary
    if (items.length == numItems) {
       // code missing here
    }

  // use auxiliary method to increment rear index with wraparound
    rearIndex = incrementIndex(rearIndex);

  // insert new item at rear of queue
    items[rearIndex] = ob;
    numItems++;
}

private int incrementIndex(int index) {
    if (index == items.length-1) return 0;
    else return index + 1;
}

Note that instead of using incrementIndex we could use the mod operator, and write: rearIndex = (rearIndex + 1) % items.length. However, the mod operator is quite slow, and it is easy to get that expression wrong, so we will use the auxiliary method (with a check for the "wrap-around" case) instead.

To see why we can't simply use expandArray when the array is full, consider the picture shown below.

After calling expandArray, the last item in the queue is still right before the first item -- there is still no place to put the new item (and there is a big gap in the middle of the queue, from items[7] to items[13]). The problem is that expandArray copies the values in the old array into the same positions in the new array. This does not work for the queue implementation; we need to move the "wrapped-around" values to come after the non-wrapped-around values in the new array.

The steps that need to be carried out when the array is full are:

1. Allocate a new array of twice the size.
2. Copy the values in the range items[frontIndex] to items[items.length-1] into the new array (starting at position frontIndex in the new array).
3. Copy the values in the range items[0] to items[rearIndex] into the new array (starting at position items.length in the new array). Note: if the front of the queue was in items[0], then all of the values were copied by step 2, so this step is not needed.
4. Set items to point to the new array.
5. Fix the value of rearIndex.

And here's the final code for enqueue:

publc void enqueue(Object ob) {
  // check for full array and expand if necessary
    if (items.length == numItems) {
        Object[] tmp = new Object[items.length*2];
        System.arraycopy(items, frontIndex, tmp, frontIndex,
	                 items.length-frontIndex);
	if (frontIndex != 0) {
	    System.arraycopy(items, 0, tmp, items.length, frontIndex);
	}
        items = tmp;
	rearIndex = frontIndex + numItems - 1;
    }

  // use auxiliary method to increment rear index with wraparound
    rearIndex = incrementIndex(rearIndex);

  // insert new item at rear of queue
    items[rearIndex] = ob;
    numItems++;
}

The dequeue method will also use method incrementIndex to add one to frontIndex (with wrap-around) before returning the value that was at the front of the queue.

The other queue methods (isEmpty and size) are the same as those methods for the Stack class -- they just use the value of the numItems field.

The first decision in planning the linked-list implementation of the Queue class is which end of the list will correspond to the front of the queue. Recall that items need to be added to the rear of the queue, and removed from the front of the queue. Therefore, we should make our choice based on whether it is easier to add/remove a node from the front/end of a linked list.

If we keep pointers to both the first and last nodes of the list, we can add a node at either end in constant time. However, while we can remove the first node in the list in constant time, removing the last node requires first locating the previous node, which takes time proportional to the length of the list. Therefore, we should choose to make the end of the list be the rear of the queue, and the front of the list be the front of the queue.

The class definition is the same as for the array implementation, except for the fields:

  // *** fields ***
    private Listnode qFront; // pointer to the front of the queue
                             // (the first node in the list)
    private Listnode qRear;  // pointer to the rear of the queue
                             // (the last node in the list)
    private int numItems;    // the number of items in the queue

Here's a picture of a Queue with three items, aa, bb, cc, with aa at the front of the queue:

You should be able to write all of the queue methods, using the code you wrote for the linked-list implementation of the Sequence class as a guide.

The advantages and disadvantages of the two implementations are essentially the same as the advantages and disadvantages in the case of the Sequence class:

• In the linked-list implementation, one pointer must be stored for every item in the stack/queue, while the array stores only the items themselves.
• On the other hand, the space used for a linked list is always proportional to the number of items in the list. This is not necessarily true for the array implementation as described: if a lot of items are added to a stack/queue and then removed, the size of the array can be arbitrarily greater than the number of items in the stack/queue. However, we could fix this problem by modifying the pop/dequeue operations to shrink the array when it becomes too empty.
• For the array implementation, the worst-case times for the push and enqueue methods are O(N), for a stack/queue with N items. This is because when the arary is full, a new array must be allocated and the values must be copied. For the linked-list implementation, push and enqueue are always O(1).

Stacks are used to manage methods at runtime (when a method is called, its parameters and local variables are pushed onto a stack; when the method returns, the values are popped from the stack). Many parsing algorithms (used by compilers to determine whether a program is syntactically correct) involve the use of stacks. Stacks can be used to evaluate arithmetic expressions (e.g., by a simple calculator program), and they are also useful for some operations on graphs, a data structure we will learn about later in the semester.

Queues are useful for many simulations, and are also used for some operations on graphs and trees.