Data Structures and Algorithms in Java 1

Module 4: Stacks and Queues

Overview
In this module we'll examine three data storage structures: the stack, the queue, and the priority queue. We'll begin by
discussing how these structures differ from arrays; then we'll examine each one in turn. In the last section, we'll look at an
operation in which the stack plays a significant role: parsing arithmetic expressions.
Programmer's Tools
The array—the data storage structure we've been examining thus far—as well as many other structures we'll encounter later
in this module (linked lists, trees, and so on), are appropriate for the kind of data you might find in a database application.
They're typically used for personnel records, inventories, financial data, and so on; data that corresponds to real-world
objects or activities. These structures facilitate access to data: they make it easy to insert, delete, and search for particular
items.
The structures and algorithms we'll examine in this module, on the other hand, are more often used as programmer's tools.
They're primarily conceptual aids rather than fullfledged data storage devices. Their lifetime is typically shorter than that of
the databasetype structures. They are created and used to carry out a particular task during the operation of a program;
when the task is completed, they're discarded.
Restricted Access
In an array, any item can be accessed, either immediately—if its index number is known—or by searching through a
sequence of cells until it's found. In the data structures in this module, however, access is restricted: only one item can be
read or removed at a given time.
The interface of these structures is designed to enforce this restricted access. Access to other items is (in theory) not
allowed.
More Abstract
Stacks, queues, and priority queues are more abstract entities than arrays and many other data storage structures. They're
defined primarily by their interface: the permissible operations that can be carried out on them. The underlying mechanism
used to implement them is typically not visible to their user.
For example, the underlying mechanism for a stack can be an array, as shown in this module, or it can be a linked list. The
underlying mechanism for a priority queue can be an array or a special kind of tree called a heap. We'll return to the topic
of one data structure being implemented by another when we discuss Abstract Data Types (ADTs) in Module 5, "Linked
Lists."
Stacks
A stack allows access to only one data item: the last item inserted. If you remove this item, then you can access the next-to-
last item inserted, and so on. This is a useful capability in many programming situations. In this section, we'll see how a
stack can be used to check whether parentheses, braces, and brackets are balanced in a computer program source file. At the
end of this module, we'll see a stack playing a vital role in parsing (analyzing) arithmetic expressions such as 3*(4+5).
A stack is also a handy aid for algorithms applied to certain complex data structures. In Module 8, "Binary Trees," we'll see
it used to help traverse the nodes of a tree.
Most microprocessors use a stack-based architecture. When a method is called, its return address and arguments are pushed
onto a stack, and when it returns they're popped off. The stack operations are built into the microprocessor.
Some older pocket calculators used a stack-based architecture. Instead of entering arithmetic expressions using parentheses,
you pushed intermediate results onto a stack. We'll learn more about this approach when we discuss parsing arithmetic
expressions in the last section in this module.
The Postal Analogy
To understand the idea of a stack, consider an analogy provided by the U. S. Postal Service. Many people, when they get
their mail, toss it onto a stack on the hall table or into an "in" basket at work. Then, when they have a spare moment, they
process the accumulated mail from the top down. First they open the letter on the top of the stack and take appropriate
action—paying the bill, throwing it away, or whatever. When the first letter has been disposed of, they examine the next
letter down, which is now the top of the stack, and deal with that. Eventually they work their way down to the letter on the
bottom of the stack (which is now the top). Figure 4.1 shows a stack of mail.
This "do the top one first" approach works all right as long as you can easily process all the mail in a reasonable time. If
you can't, there's the danger that letters on the bottom of the stack won't be examined for months, and the bills they contain
will become overdue.

Module 4: Stacks and Queues

Data Structures and Algorithms in Java 2

Of course, many people don't rigorously follow this top-to-bottom approach. They may, for example, take the mail off the
bottom of the stack, so as to process the oldest letter first. Or they might shuffle through the mail before they begin
processing it and put higher-priority letters on top. In these cases, their mail system is no longer a stack in the computer-
science sense of the word. If they take letters off the bottom, it's a queue; and if they prioritize it, it's a priority queue. We'll
look at these possibilities later.

Figure 4.1: A stack of letters

Another stack analogy is the tasks you perform during a typical workday. You're busy on a long-term project (A), but
you're interrupted by a coworker asking you for temporary help with another project (B). While you're working on B,
someone in accounting stops by for a meeting about travel expenses (C), and during this meeting you get an emergency call
from someone in sales and spend a few minutes troubleshooting a bulky product (D). When you're done with call D, you
resume meeting C; when you're done with C, you resume project B, and when you're done with B you can (finally!) get
back to project A. Lower priority projects are "stacked up" waiting for you to return to them.
Placing a data item on the top of the stack is called pushing it. Removing it from the top of the stack is called popping it.
These are the primary stack operations. A stack is said to be a Last-In-First-Out (LIFO) storage mechanism, because the
last item inserted is the first one to be removed.
Java Code for a Stack
Let's examine a program, Stack.java, that implements a stack using a class called StackX. Listing 4.1 contains this class
and a short main() routine to exercise it.
Listing 4.1 The Stack.java Program
// Stack.java
// demonstrates stacks

import java.io.*; // for I/O

////////////////////////////////////////////////////////////////

class StackX
{
private int maxSize; // size of stack array
private double[] stackArray;
private int top; // top of stack

//-------------------------------------------------------------

public StackX(int s) // constructor

{
maxSize = s; // set array size
stackArray = new double[maxSize]; // create array
top = -1; // no items yet
}

//-------------------------------------------------------------

public void push(double j) // put item on top of stack

{
stackArray[++top] = j; // increment top, insert item
}

//-------------------------------------------------------------

public double pop() // take item from top of stack

Module 4: Stacks and Queues

Data Structures and Algorithms in Java 3

{
return stackArray[top--]; // access item, decrement top
}

//-------------------------------------------------------------

public double peek() // peek at top of stack

{
return stackArray[top];
}

//-------------------------------------------------------------

public boolean isEmpty() // true if stack is empty

{
return (top == -1);
}

//-------------------------------------------------------------

public boolean isFull() // true if stack is full

{
return (top == maxSize-1);
}

//-------------------------------------------------------------

} // end class StackX

////////////////////////////////////////////////////////////////

class StackApp
{
public static void main(String[] args)
{
StackX theStack = new StackX(10); // make new stack

theStack.push(20); // push items onto stack

theStack.push(40);
theStack.push(60);
theStack.push(80);

while( !theStack.isEmpty() ) // until it's empty,

{ // delete item from stack
double value = theStack.pop();
System.out.print(value); // display it
System.out.print(" ");
} // end while

System.out.println("");
} // end main()
} // end class StackApp

The main() method in the StackApp class creates a stack that can hold 10 items, pushes 4 items onto the stack, and then
displays all the items by popping them off the stack until it's empty. Here's the output:

80 60 40 20

Notice how the order of the data is reversed. Because the last item pushed is the first one popped; the 80 appears first in the
output.

This version of the StackX class holds data elements of type double.
StackX Class Methods
The constructor creates a new stack of a size specified in its argument. The fields of the stack comprise a variable to hold its
maximum size (the size of the array), the array itself, and a variable top, which stores the index of the item on the top of the
stack. (Note that we need to specify a stack size only because the stack is implemented using an array. If it had been
implemented using a linked list, for example, the size specification would be unnecessary. )
The push() method increments top so it points to the space just above the previous top, and stores a data item there. Notice
that top is incremented before the item is inserted.
The pop() method returns the value at top and then decrements top. This effectively removes the item from the stack; it's
inaccessible, although the value remains in the array (until another item is pushed into the cell).
The peek() method simply returns the value at top, without changing the stack.

Module 4: Stacks and Queues

Data Structures and Algorithms in Java 4

The isEmpty() and isFull() methods return true if the stack is empty or full, respectively. The top variable is at –1 if the
stack is empty and maxSize-1 if the stack is full.
Figure 4.3 shows how the stack class methods work.

Figure 4.3: Operation of the StackX class methods

Error Handling
There are different philosophies about how to handle stack errors. What happens if you try to push an item onto a stack
that's already full, or pop an item from a stack that's empty?
We've left the responsibility for handling such errors up to the class user. The user should always check to be sure the stack
is not full before inserting an item:
if( !theStack.isFull() )
insert(item);
else
System.out.print("Can't insert, stack is full");

Stack Example 1: Reversing a Word

For our first example of using a stack, we'll examine a very simple task: reversing a word. When you run the program, it
asks you to type in a word. When you press Enter, it displays the word with the letters in reverse order.
A stack is used to reverse the letters. First the characters are extracted one by one from the input string and pushed onto the
stack. Then they're popped off the stack and displayed. Because of its last-in-first-out characteristic, the stack reverses the
order of the characters. Listing 4.2 shows the code for the reverse.java program.
Listing 4.2 The reverse.java Program
// reverse.java
// stack used to reverse a string

import java.io.*; // for I/O

////////////////////////////////////////////////////////////////

class StackX
{
private int maxSize;
private char[] stackArray;
private int top;

//-------------------------------------------------------------

public StackX(int max) // constructor

{
maxSize = max;
stackArray = new char[maxSize];
top = -1;
}

//-------------------------------------------------------------

public void push(char j) // put item on top of stack

{
stackArray[++top] = j;
}

Module 4: Stacks and Queues

Data Structures and Algorithms in Java 5

//-------------------------------------------------------------

public char pop() // take item from top of stack

{
return stackArray[top--];
}

//-------------------------------------------------------------

public char peek() // peek at top of stack

{
return stackArray[top];
}

//-------------------------------------------------------------

public boolean isEmpty() // true if stack is empty

{
return (top == -1);
}

//-------------------------------------------------------------

} // end class StackX

////////////////////////////////////////////////////////////////
class Reverser
{
private String input; // input string
private String output; // output string

//-------------------------------------------------------------

public Reverser(String in) // constructor

{ input = in; }

//-------------------------------------------------------------

public String doRev() // reverse the string

{
int stackSize = input.length(); // get max stack size
StackX theStack = new StackX(stackSize); // make stack

for(int j=0; j<input.length(); j++)

{
char ch = input.charAt(j); // get a char from input
theStack.push(ch); // push it
}

output = "";

while( !theStack.isEmpty() )
{
char ch = theStack.pop(); // pop a char,
output = output + ch; // append to output
}

return output;
} // end doRev()
//-------------------------------------------------------------
-
} // end class Reverser
////////////////////////////////////////////////////////////////
class ReverseApp
{
public static void main(String[] args) throws IOException
{
String input, output;

while(true)
{
System.out.print("Enter a string: ");

System.out.flush();

input = getString(); // read a string from kbd

if( input.equals("") ) // quit if [Enter]

break;

// make a Reverser
Reverser theReverser = new Reverser(input);

output = theReverser.doRev(); // use it

Module 4: Stacks and Queues

Data Structures and Algorithms in Java 6

System.out.println("Reversed: " + output);

} // end while

} // end main()

//-------------------------------------------------------------

public static String getString() throws IOException

{
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
return s;
}

//-------------------------------------------------------------

} // end class ReverseApp

We've created a class Reverser to handle the reversing of the input string. Its key component is the method doRev(),
which carries out the reversal, using a stack. The stack is created within doRev(), which sizes it according to the length of
the input string.
In main() we get a string from the user, create a Reverser object with this string as an argument to the constructor, call this
object's doRev() method, and display the return value, which is the reversed string. Here's some sample interaction with the
program:
Enter a string: part
Reversed: trap
Enter a string:

Queues
The word queue is British for line (the kind you wait in). In Britain, to "queue up" means to get in line. In computer science
a queue is a data structure that is similar to a stack, except that in a queue the first item inserted is the first to be removed
(FIFO), while in a stack, as we've seen, the last item inserted is the first to be removed (LIFO). A queue works like the line
at the movies: the first person to join the rear of the line is the first person to reach the front of the line and buy a ticket. The
last person to line up is the last person to buy a ticket (or—if the show is sold out—to fail to buy a ticket). Figure 4.4 shows
how this looks.

Figure 4.4: A queue of people

Queues are used as a programmer's tool as stacks are. They're also used to model real-world situations such as people
waiting in line at a bank, airplanes waiting to take off, or data packets waiting to be transmitted over the Internet.
There are various queues quietly doing their job in your computer's (or the network's) operating system. There's a printer
queue where print jobs wait for the printer to be available. A queue also stores keystroke data as you type at the keyboard.
This way, if you're using a word processor but the computer is briefly doing something else when you hit a key, the
keystroke won't be lost; it waits in the queue until the word processor has time to read it. Using a queue guarantees the
keystrokes stay in order until they can be processed.
Java Code for a Queue
The queue.java program features a Queue class with insert(), remove(), peek(), isFull(), isEmpty(), and size()
methods.
The main() program creates a queue of five cells, inserts four items, removes three items, and inserts four more. The sixth
insertion invokes the wraparound feature. All the items are then removed and displayed. The output looks like this:
40 50 60 70 80

Listing 4.4 shows the Queue.java program.

Listing 4.4 The Queue.java Program
// Queue.java
// demonstrates queue

import java.io.*; // for I/O

Module 4: Stacks and Queues

Data Structures and Algorithms in Java 7

////////////////////////////////////////////////////////////////
class Queue
{
private int maxSize;
private int[] queArray;
private int front;
private int rear;
private int nItems;

//-------------------------------------------------------------

public Queue(int s) // constructor

{
maxSize = s;
queArray = new int[maxSize];
front = 0;
rear = -1;
nItems = 0;
}

//-------------------------------------------------------------

public void insert(int j) // put item at rear of queue

{
if(rear == maxSize-1) // deal with wraparound
rear = -1;
queArray[++rear] = j; // increment rear and insert
nItems++; // one more item
}

//-------------------------------------------------------------

public int remove() // take item from front of queue

{
int temp = queArray[front++]; // get value and incr front
if(front == maxSize) // deal with wraparound
front = 0;
nItems--; // one less item

return temp;
}

//-------------------------------------------------------------

public int peekFront() // peek at front of queue

{
return queArray[front];
}

//-------------------------------------------------------------

public boolean isEmpty() // true if queue is empty

{
return (nItems==0);
}

//-------------------------------------------------------------

public boolean isFull() // true if queue is full

{
return (nItems==maxSize);
}

//-------------------------------------------------------------

public int size() // number of items in queue

{
return nItems;
}

//-------------------------------------------------------------

} // end class Queue

////////////////////////////////////////////////////////////////

class QueueApp
{
public static void main(String[] args)
{
Queue theQueue = new Queue(5); // queue holds 5 items

theQueue.insert(10); // insert 4 items

Module 4: Stacks and Queues

Data Structures and Algorithms in Java 8

theQueue.insert(20);
theQueue.insert(30);
theQueue.insert(40);

theQueue.remove(); // remove 3 items

theQueue.remove(); // (10, 20, 30)
theQueue.remove();

theQueue.insert(50); // insert 4 more items

theQueue.insert(60); // (wraps around)
theQueue.insert(70);
theQueue.insert(80);

while( !theQueue.isEmpty() ) // remove and display

{ // all items
int n = theQueue.remove(); // (40, 50, 60, 70, 80)
System.out.print(n);
System.out.print(" ");
}

System.out.println("");

} // end main()
} // end class QueueApp

We've chosen an approach in which Queue class fields include not only front and rear, but also the number of items
currently in the queue: nItems. Some queue implementations don't use this field; we'll show this alternative later.
The insert() Method
The insert() method assumes that the queue is not full. We don't show it in main(), but normally you should only call
insert() after calling isFull() and getting a return value of false. (It's usually preferable to place the check for fullness in
the insert() routine, and cause an exception to be thrown if an attempt was made to insert into a full queue.)
Normally, insertion involves incrementing rear and inserting at the cell rear now points to. However, if rear is at the top
of the array, at maxSize-1, then it must wrap around to the bottom of the array before the insertion takes place. This is done
by setting rear to – 1, so when the increment occurs rear will become 0, the bottom of the array. Finally nItems is
incremented.
The remove() Method
The remove() method assumes that the queue is not empty. You should call isEmpty() to ensure this is true before calling
remove(), or build this error-checking into remove().

Removal always starts by obtaining the value at front and then incrementing front. However, if this puts front beyond
the end of the array, it must then be wrapped around to 0. The return value is stored temporarily while this possibility is
checked. Finally, nItems is decremented.
The peek() Method
The peek() method is straightforward: it returns the value at front. Some implementations allow peeking at the rear of the
array as well; such routines are called something like peekFront() and peekRear() or just front() and rear().
The isEmpty(), isFull(), and size() Methods
The isEmpty(), isFull(), and size() methods all rely on the nItems field, respectively checking if it's 0, if it's maxSize,
or returning its value.
Deques
A deque is a double-ended queue. You can insert items at either end and delete them from either end. The methods might
be called insertLeft() and insertRight(), and removeLeft() and removeRight().
If you restrict yourself to insertLeft() and removeLeft() (or their equivalents on the right), then the deque acts like a
stack. If you restrict yourself to insertLeft() and removeRight() (or the opposite pair), then it acts like a queue.
A deque provides a more versatile data structure than either a stack or a queue, and is sometimes used in container class
libraries to serve both purposes. However, it's not used as often as stacks and queues, so we won't explore it further here.
Priority Queues
A priority queue is a more specialized data structure than a stack or a queue. However, it's a useful tool in a surprising
number of situations. Like an ordinary queue, a priority queue has a front and a rear, and items are removed from the front.
However, in a priority queue, items are ordered by key value, so that the item with the lowest key (or in some
implementations the highest key) is always at the front. Items are inserted in the proper position n to maintain the order.

Module 4: Stacks and Queues

Data Structures and Algorithms in Java 9

Here's how the mail sorting analogy applies to a priority queue. Every time the postman hands you a letter, you insert it into
your pile of pending letters according to its priority. If it must be answered immediately (the phone company is about to
disconnect your modem line), it goes on top, while if it can wait for a leisurely answer (a letter from your Aunt Mabel), it
goes on the bottom.
When you have time to answer your mail, you start by taking the letter off the top (the front of the queue), thus ensuring
that the most important letters are answered first.
This is shown in Figure 4.10.

Figure 4.10: Letters in a priority queue

Also, like ordinary queues, priority queues are used in various ways in certain computer systems. In a preemptive
multitasking operating system, for example, programs may be placed in a priority queue so the highest-priority program is
the next one to receive a time-slice that allows it to execute.

Module 4: Stacks and Queues