Download Java Programming: Program Design Including Data Structures

Chapter 17: Stacks and Queues
Java Programming:
Program Design Including Data Structures
Chapter Objectives





Learn about stacks
Examine various stack operations
Learn how to implement a stack as an array
Learn how to implement a stack as a linked list
Discover stack applications
Java Programming: Program Design Including Data Structures
2
Chapter Objectives (continued)





Learn how to use a stack to remove recursion
Learn about queues
Examine various queue operations
Learn how to implement a queue as an array
Discover queue applications
Java Programming: Program Design Including Data Structures
3
Stacks
 Lists of homogeneous elements
 Addition and deletion of elements occur only at one
end, called the top of the stack
 Computers use stacks to implement method calls
 Stacks are also used to convert recursive algorithms
into nonrecursive algorithms
 Especially recursive algorithms that are not tail
recursive
Java Programming: Program Design Including Data Structures
4
Stacks (continued)
Figure 17-1 Various types of stacks
Java Programming: Program Design Including Data Structures
5
Stacks (continued)
 Stacks are also called Last Input First Output (LIFO)
data structures
 Operations performed on stacks
 Push: adds an element to the stack
 Pop: removes an element from the stack
 Peek: looks at the top element of the stack
Java Programming: Program Design Including Data Structures
6
Stacks (continued)
Figure 17-3 Stack operations
Java Programming: Program Design Including Data Structures
7
Stacks (continued)
Figure 17-4 UML diagram of the interface StackADT
Java Programming: Program Design Including Data Structures
8
StackException Class
 Adding an element to a full stack and removing an
element from an empty stack would generate errors
or exceptions
 Stack overflow exception
 Stack underflow exception
 Classes that handle these exceptions
 StackException extends RunTimeException
 StackOverflowException extends StackException
 StackUnderflowException extends StackException
Java Programming: Program Design Including Data Structures
9
Implementation of Stacks as Arrays
 The array implementing a stack is an array of
reference variables
 Each element of the stack can be assigned to an
array slot
 The top of the stack is the index of the last element
added to the stack
 To keep track of the top position, declare a variable
called stackTop
Java Programming: Program Design Including Data Structures
10
Implementation of Stacks as Arrays
(continued)
Figure 17-5 UML class diagram of the class StackClass
Java Programming: Program Design Including Data Structures
11
Implementation of Stacks as Arrays
(continued)
Figure 17-6 Example of a stack
Java Programming: Program Design Including Data Structures
12
Constructors
 Default constructor
public StackClass()
{
maxStackSize = 100;
stackTop = 0;
//set stackTop to 0
list = (T[]) new Object[maxStackSize]; //create the array
}//end default constructor
Java Programming: Program Design Including Data Structures
13
Initialize Stack
 Method initializeStack
public void initializeStack()
{
for (int i = 0; i < stackTop; i++)
list[i] = null;
stackTop = 0;
}//end initializeStack
Java Programming: Program Design Including Data Structures
14
Empty Stack
 Method isEmptyStack
public boolean isEmptyStack()
{
return (stackTop == 0);
}//end isEmptyStack
Java Programming: Program Design Including Data Structures
15
Full Stack
 Method isFullStack
public boolean isFullStack()
{
return (stackTop == maxStackSize);
}//end isFullStack
Java Programming: Program Design Including Data Structures
16
Push
 Method push
public void push(T newItem) throws StackOverflowException
{
if (isFullStack())
throw new StackOverflowException();
list[stackTop] = newItem; //add newItem at the
//top of the stack
stackTop++;
//increment stackTop
}//end push
Java Programming: Program Design Including Data Structures
17
Peek
 Method peek
public T peek() throws StackUnderflowException
{
if (isEmptyStack())
throw new StackUnderflowException();
return (T) list[stackTop - 1];
}//end peek
Java Programming: Program Design Including Data Structures
18
Pop
 Method pop
public void pop() throws StackUnderflowException
{
if (isEmptyStack())
throw new StackUnderflowException();
stackTop--;
//decrement stackTop
list[stackTop] = null;
}//end pop
Java Programming: Program Design Including Data Structures
19
Programming Example: Highest
GPA
 Program reads a data file consisting of
 Each student’s GPA followed by the student’s name
 Then it prints
 Highest GPA
 The names of all the students with that GPA
 The program uses a stack to keep track of the
highest GPA
Java Programming: Program Design Including Data Structures
20
Linked Implementation of Stacks
 Arrays have fixed sizes
 Only a fixed number of elements can be pushed onto
the stack
 Dynamically allocate memory using reference
variables
 Implement a stack dynamically
 Similar to the array representation, stackTop is
used to locate the top element
 stackTop is now a reference variable
Java Programming: Program Design Including Data Structures
21
Linked Implementation of Stacks
(continued)
Figure 17-13 Nonempty linked stack
Java Programming: Program Design Including Data Structures
22
Default Constructor
 Default constructor
public LinkedStackClass()
{
stackTop = null;
}//end constructor
Java Programming: Program Design Including Data Structures
23
Initialize Stack
 Method initializeStack
public void initializeStack()
{
stackTop = null;
}//end initializeStack
Java Programming: Program Design Including Data Structures
24
Empty Stack and Full Stack
 Methods isEmptyStack and isFullStack
public boolean isEmptyStack()
{
return (stackTop == null);
}//end isEmptyStack
public boolean isFullStack()
{
return false;
}//end isFullStack
Java Programming: Program Design Including Data Structures
25
Push
 Method push
public void push(T newElement)
{
StackNode<T> newNode; //reference variable to create
//the new node
newNode = new
StackNode<T>(newElement, stackTop); //create
//newNode and insert
//before stackTop
stackTop = newNode;
//set stackTop to point to
//the top element
} //end push
Java Programming: Program Design Including Data Structures
26
Peek
 Method peek
public T peek() throws StackUnderflowException
{
if (stackTop == null)
throw new StackUnderflowException();
return stackTop.info;
}//end top
Java Programming: Program Design Including Data Structures
27
Pop
 Method pop
public void pop() throws StackUnderflowException
{
if (stackTop == null)
throw new StackUnderflowException();
stackTop = stackTop.link; //advance stackTop to the
//next node
}//end pop
Java Programming: Program Design Including Data Structures
28
Stack as Derived from the class
UnorderedLinkedList
 The class LinkedStackClass can be derived
from the class LinkedListClass
 The class LinkedListClass is an abstract class
 You can derive the class LinkedStackClass
from the class UnorderedLinkedList
Java Programming: Program Design Including Data Structures
29
Applications of Stacks: Postfix
Expression Calculator
 Infix notation
 The operator is written between the operands
 Prefix or Polish notation
 Operators are written before the operands
 Does not require parentheses
 Reverse Polish or postfix notation
 Operators follow the operands
 Has the advantage that the operators appear in the
order required for computation
Java Programming: Program Design Including Data Structures
30
Applications of Stacks: Postfix
Expression Calculator (continued)
Table 17-1 Infix expressions and their equivalent postfix expressions
Java Programming: Program Design Including Data Structures
31
Applications of Stacks: Postfix
Expression Calculator (continued)
 Algorithm to evaluate postfix expressions
 Scan the expression from left to right
 When an operator is found, back up to get the
required number of operands
 Perform the operation
 Continue processing the expression
Java Programming: Program Design Including Data Structures
32
Main Algorithm
 Main algorithm in pseudocode for processing a
postfix expression
Get the next expression
while more data to process
{
a. initialize the stack
b. process the expression
c. output result
d. get the next expression
}
Java Programming: Program Design Including Data Structures
33
Method evaluateExpression
 General algorithm for evaluateExpression
get the next token
while (token != '=')
{
if (token is a number)
{
output number
push number into stack
}
else
{
token is an operation
call method evaluateOpr to evaluate the operation
}
if (no error in the expression)
get next token
else
discard the expression
}
Java Programming: Program Design Including Data Structures
34
Method evaluateOpr
 This method evaluates an operation
 Two operands are needed to evaluate an operation
 Operands are stored in the stack
 The stack must contain at least two operands
 Otherwise, the operation cannot be evaluated
Java Programming: Program Design Including Data Structures
35
Method printResult
public static void printResult(StackClass<Double> pStack,
PrintWriter outp)
{
Double result;
Double temp;
if (expressionOk) //if no error, print the result
{
if (!pStack.isEmptyStack())
{
result = (Double) pStack.peek();
pStack.pop();
if (pStack.isEmptyStack())
outp.printf(“%s %.2f %n”, strToken, result);
else
outp.println(strToken
+ “ (Error: Too many operands)”);
}//end if
else
outp.println(“ (Error in the expression)”);
}
else
outp.println(“ (Error in the expression)”);
outp.println(“_________________________________”);
}//end printResult
Java Programming: Program Design Including Data Structures
36
Postfix Expression Calculator:
Graphical User Interface (GUI)
Figure 17-28 GUI for the postfix calculator
Java Programming: Program Design Including Data Structures
37
Postfix Expression Calculator:
Graphical User Interface (GUI)
(continued)
 Methods evaluateExpression,
evaluateOpr, and printResult need minor
modifications
 The data are no longer coming from a file
 The output is no longer stored in a file
 To simplify the accessing of the stack
 Declare it as an instance variable of the class
containing the GUI program
Java Programming: Program Design Including Data Structures
38
Postfix Expression Calculator:
Graphical User Interface (GUI)
(continued)
 To create the GUI, the class containing the GUI must
extend the class JFrame
 The GUI interface contains several labels, three
buttons, and a textfield
 When the user clicks a button, it should generate an
action event
 You need to handle this event
 The class constructor creates the GUI components
and initialize them
Java Programming: Program Design Including Data Structures
39
Postfix Expression Calculator:
Graphical User Interface (GUI)
(continued)
Figure 17-29 Sample run of PostfixCalculator program
Java Programming: Program Design Including Data Structures
40
Removing Recursion: Nonrecursive
Algorithm to Print a Linked List
Backward
 Naïve approach
 Get the last node of the list and print it
 Traverse the link starting at the first node
 Repeat this process for every node
 Traverse the link starting at the first node until you
reach the desired node
 Very inefficient
Java Programming: Program Design Including Data Structures
41
Removing Recursion: Nonrecursive
Algorithm to Print a Linked List
Backward (continued)
current = first;
while (current != null)
{
stack.push(current);
current = current.link;
}
Java Programming: Program Design Including Data Structures
//Line 1
//Line 2
//Line 3
//Line 4
42
Removing Recursion: Nonrecursive
Algorithm to Print a Linked List
Backward (continued)
Figure 17-36 List and stack after the staments stack.push(current);
and current = current.link; executes
Java Programming: Program Design Including Data Structures
43
The class Stack
Table 17-2 Members of the class Stack
Java Programming: Program Design Including Data Structures
44
Queues
 Data structure in which the elements are added at
one end, called the rear, and deleted from the other
end, called the front
 A queue is a First In First Out data structure
 As in a stack, the middle elements of the queue are
inaccessible
Java Programming: Program Design Including Data Structures
45
Queue Operations
 Queue operations







initializeQueue
isEmptyQueue
isFullQueue
front
back
addQueue
deleteQueue
Java Programming: Program Design Including Data Structures
46
QueueException Class
 Adding an element to a full queue and removing an
element from an empty queue would generate errors
or exceptions
 Queue overflow exception
 Queue underflow exception
 Classes that handle these exceptions
 QueueException extends RunTimeException
 QueueOverflowException extends QueueException
 QueueUnderflowException extends QueueException
Java Programming: Program Design Including Data Structures
47
Implementation of Queues as
Arrays
 Instance variables




An array to store the queue elements
queueFront: keeps track of the first element
queueRear: keeps track of the last element
maxQueueSize: specifies the maximum size of the
queues
Java Programming: Program Design Including Data Structures
48
Implementation of Queues as
Arrays (continued)
Figure 17-42 Queue after two more addQueue operations
Java Programming: Program Design Including Data Structures
49
Implementation of Queues as
Arrays (continued)
Figure 17-43 Queue after the deleteQueue operation
Java Programming: Program Design Including Data Structures
50
Implementation of Queues as
Arrays (continued)
 Problems with this implementation
 Arrays have fixed sizes
 After various insertion and deletion operations,
queueRear will point to the last array position
 Giving the impression that the queue is full
 Solutions
 Slide all of the queue elements toward the first array
position
 Use a circular array
Java Programming: Program Design Including Data Structures
51
Implementation of Queues as
Arrays (continued)
Figure 17-45 Circular queue
Java Programming: Program Design Including Data Structures
52
Implementation of Queues as
Arrays (continued)
Figure 17-46 Queue with two elements at positions 98 and 99
Java Programming: Program Design Including Data Structures
53
Implementation of Queues as
Arrays (continued)
Figure 17-47 Queue after one more addQueue operation
Java Programming: Program Design Including Data Structures
54
Constructors
 Default constructor
//Default constructor
public QueueClass()
{
maxQueueSize = 100;
queueFront = 0;
//initialize queueFront
queueRear = maxQueueSize - 1;
//initialize queueRear
count = 0;
list = (T[]) new Object[maxQueueSize]; //create the
//array to implement the queue
}
Java Programming: Program Design Including Data Structures
55
initializeQueue
 Method initilializeQueue
public void initializeQueue()
{
for (int i = queueFront; i < queueRear;
i = (i + 1) % maxQueueSize)
list[i] = null;
queueFront = 0;
queueRear = maxQueueSize - 1;
count = 0;
}
Java Programming: Program Design Including Data Structures
56
Empty Queue and Full Queue
 Methods isEmptyQueue and isFullQueue
public boolean isEmptyQueue()
{
return (count == 0);
}
public boolean isFullQueue()
{
return (count == maxQueueSize);
}
Java Programming: Program Design Including Data Structures
57
Front
 Method front
public T front() throws QueueUnderflowException
{
if (isEmptyQueue())
throw new QueueUnderflowException();
return (T) list[queueFront];
}
Java Programming: Program Design Including Data Structures
58
Back
 Method back
public T back() throws QueueUnderflowException
{
if (isEmptyQueue())
throw new QueueUnderflowException();
return (T) list[queueRear];
}
Java Programming: Program Design Including Data Structures
59
addQueue
 Method addQueue
public void addQueue(T queueElement)
throws QueueOverflowException
{
if (isFullQueue())
throw new QueueOverflowException();
queueRear = (queueRear + 1) % maxQueueSize; //use the
//mod operator to advance queueRear
//because the array is circular
count++;
list[queueRear] = queueElement;
}
Java Programming: Program Design Including Data Structures
60
deleteQueue
 Method deleteQueue
public void deleteQueue() throws QueueUnderflowException
{
if (isEmptyQueue())
throw new QueueUnderflowException();
count--;
list[queueFront] = null;
queueFront = (queueFront + 1) % maxQueueSize; //use the
//mod operator to advance queueFront
//because the array is circular
}
Java Programming: Program Design Including Data Structures
61
Linked Implementation of Queues
 Simplifies many of the special cases of the array
implementation
 Because the memory to store a queue element is
allocated dynamically, the queue is never full
 Class LinkedQueueClass implements a queue as
a linked data structure
 It uses nodes of type QueueNode
Java Programming: Program Design Including Data Structures
62
Linked Implementation of Queues
(continued)
 Method initializeQueue
public void initializeQueue()
{
queueFront = null;
queueRear = null;
}
Java Programming: Program Design Including Data Structures
63
Linked Implementation of Queues
(continued)
 Methods isEmptyQueue and isFullQueue
public boolean isEmptyQueue()
{
return (queueFront == null);
}
public boolean isFullQueue()
{
return false;
}
Java Programming: Program Design Including Data Structures
64
addQueue
 Method addQueue
public void addQueue(T newElement)
{
QueueNode<T> newNode;
newNode = new QueueNode<T>(newElement, null); //create
//newNode and assign newElement to newNode
if (queueFront == null) //if initially the queue is empty
{
queueFront = newNode;
queueRear = newNode;
}
else
//add newNode at the end
{
queueRear.link = newNode;
queueRear = queueRear.link;
}
}//end addQueue
Java Programming: Program Design Including Data Structures
65
front and back
 Methods front and back
public T front() throws QueueUnderflowException
{
if (isEmptyQueue())
throw new QueueUnderflowException();
return queueFront.info;
}
public T back() throws QueueUnderflowException
{
if (isEmptyQueue())
throw new QueueUnderflowException();
return queueRear.info;
}
Java Programming: Program Design Including Data Structures
66
deleteQueue
 Method deleteQueue
public void deleteQueue() throws QueueUnderflowException
{
if (isEmptyQueue())
throw new QueueUnderflowException();
queueFront = queueFront.link; //advance queueFront
if (queueFront == null) //if after deletion the queue
queueRear = null; //is empty, set queueRear to null
} //end deleteQueue
Java Programming: Program Design Including Data Structures
67
Queue Derived from the class
UnorderedLinkedList
 The class LinkedQueueClass can be derived
from the class UnorderedLinkedListClass
 addQueue is similar to insertFirst
 Likewise, the operations initializeQueue,
initializeList, isEmptyQueue, and
isEmptyList are similar
 queueFront is the same as first
 queueRear is the same as last
Java Programming: Program Design Including Data Structures
68
Application of Queues: Simulation
 Simulation
 A technique in which one system models the behavior
of another system
 Used when it is too expensive or dangerous to
experiment with real systems
 You can also design computer models to study the
behavior of real systems
 Queuing systems
 Queues of objects are waiting to be served
Java Programming: Program Design Including Data Structures
69
Designing a Queuing System
 Terms
 Server
 Object that provides a service
 Customer
 Object receiving a service
 Transaction time
 The time it takes to serve a customer
Java Programming: Program Design Including Data Structures
70
Designing a Queuing System
(continued)
 Components
 List of servers
 Queue of waiting objects
 Process
 The customer at the front of the queue waits for the
next available server
 When a server becomes free, the customer at the front
of the queue moves to be served
 At the beginning, all servers are free
Java Programming: Program Design Including Data Structures
71
Designing a Queuing System
(continued)
 What you need to know




The number of servers
The customer expected arrival time
The time between the arrivals of customers
The number of events affecting the system
 Time-driven simulation
 Uses a clock that can be implemented as a counter
 The simulation is run for a fixed amount of time
Java Programming: Program Design Including Data Structures
72
Customer
Figure 17-54 UML class diagram of the class Customer
Java Programming: Program Design Including Data Structures
73
Customer (continued)
 Methods getWaitingTime and
incrementWaitingTime
public int getWaitingTime()
{
return waitingTime;
}
public void incrementWaitingTime()
{
waitingTime++;
}
Java Programming: Program Design Including Data Structures
74
Server
Figure 17-55 UML class diagram of the class Server
Java Programming: Program Design Including Data Structures
75
Server (continued)
 Methods setTransactionTime and
decreaseTransactionTime
public void setTransactionTime(int t)
{
transactionTime = t;
}
public void setTransactionTime()
{
transactionTime = currentCustomer.getTransactionTime();
}
public void decreaseTransactionTime()
{
transactionTime--;
}
Java Programming: Program Design Including Data Structures
76
Server List
Figure 17-56 UML class diagram of the class serverList
Java Programming: Program Design Including Data Structures
77
Server List (continued)
 Method setServerBusy
public void setServerBusy(int serverID, Customer cCustomer,
int tTime)
{
servers[serverID].setBusy();
servers[serverID].setTransactionTime(tTime);
servers[serverID].setCurrentCustomer(cCustomer);
}
public void setServerBusy(int serverID, Customer cCustomer)
{
int time;
time = cCustomer.getTransactionTime();
servers[serverID].setBusy();
servers[serverID].setTransactionTime(time);
servers[serverID].setCurrentCustomer(cCustomer);
}
Java Programming: Program Design Including Data Structures
78
Waiting Customer Queue
 Class WaitingCustomerQueue
class WaitingCustomerQueue extends QueueClass
{
public WaitingCustomerQueue()
{
super();
}
public WaitingCustomerQueue(int size)
{
super(size);
}
public void updateWaitingQueue()
{
//...
}
}
Java Programming: Program Design Including Data Structures
79
Main Program
 To run the simulation, you need the following
simulation parameters
 Number of time units the simulation should run
 Number of servers
 Amount of time it takes to serve a customer
 Transaction time
 Approximate time between customer arrivals
Java Programming: Program Design Including Data Structures
80
Main Program (continued)
 General algorithm
 Declare and initialize the variables, including the
simulation parameters
 Run the main loop that moves customers from
waiting queue to the next available server and updates
simulation times
 Customer waiting time
 Server busy time
 Print the appropriate results
Java Programming: Program Design Including Data Structures
81
Chapter Summary
 Stacks
 Addition and deletion of elements occur only at one
end, called the top of the stack
 Follow a LIFO policy
 Stack implementation
 Array-based stacks
 Linked stacks
 Stacks are used to convert recursive algorithms into
nonrecursive algorithms
Java Programming: Program Design Including Data Structures
82
Chapter Summary (continued)
 Queues
 Elements are added at one end, called the rear, and
deleted from the other end, called the front
 Follow a FIFO policy
 Queue implementation
 Array-based queues
 Linked queues
 Queues are used to construct computer-aided
simulation programs
Java Programming: Program Design Including Data Structures
83