Chapter 17: Stacks and Queues Java Programming: Program Design Including Data Structures Program...

Chapter 17: Stacks and QueuesChapter 17: Stacks and Queues

Java Programming: Java Programming: Program Design Including Data Program Design Including Data StructuresStructures

Java Programming: Program Design Including Data Structures 2

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


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


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


Stacks (continued)

Figure 17-1 Various types of stacks


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


Stacks (continued)

Figure 17-3 Stack operations


Stacks (continued)

Figure 17-4 UML diagram of the interface StackADT

public class StackADT<T> {…

}


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


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


Implementation of Stacks as Arrays (continued)

Figure 17-5 UML class diagram of the class StackClass

public class StackClass<T> implements StackADT<T> {…

}



public class StackClass<T> implements StackADT<T> { private int maxStackSize; private int stackTop; private T[] list;

…

}



Figure 17-6 Example of a stack


Constructors

Default constructorpublic StackClass()

{

maxStackSize = 100;

stackTop = 0; //set stackTop to 0

list = (T[]) new Object[maxStackSize]; //create the array

}//end default constructor


Initialize Stack

Method initializeStackpublic void initializeStack()

{

for (int i = 0; i < stackTop; i++)

list[i] = null;

stackTop = 0;

}//end initializeStack


Empty Stack

Method isEmptyStackpublic boolean isEmptyStack()

{

return (stackTop == 0);

}//end isEmptyStack


Full Stack

Method isFullStackpublic boolean isFullStack()

{

return (stackTop == maxStackSize);

}//end isFullStack


Push

Method pushpublic 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


Peek

Method peekpublic T peek() throws StackUnderflowException

{

if (isEmptyStack())

throw new StackUnderflowException();

return (T) list[stackTop - 1];

}//end peek


Pop

Method poppublic void pop() throws StackUnderflowException

{

if (isEmptyStack())


stackTop--; //decrement stackTop

list[stackTop] = null;

}//end pop


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 (stored in the variable highestGPA) The names of all the students with the highest GPA

The program uses a stack to keep track of the name of students with the highest GPA


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


Linked Implementation of Stacks (continued)

Figure 17-13 Nonempty linked stack

public class LinkedStackClass<T> implements StackADT<T> { private StackNode<T> stackTop;

…}


LinkedStackClass & StackNodepublic class LinkedStackClass<T> implements StackADT<T> { private StackNode<T> stackTop;

private class StackNode<T> { public T info; public StackNode<T> link;

…

} // end of StackNode<T> class private LinkedStackClass() { stackTop = null; }

…

} // end of LinkedStackClass<T> class


Default Constructor

Default constructorpublic LinkedStackClass()

{

stackTop = null;

}//end constructor


Initialize Stack

Method initializeStackpublic void initializeStack()

{

stackTop = null;

}//end initializeStack


Empty Stack and Full Stack

Methods isEmptyStack and isFullStackpublic boolean isEmptyStack()

{

return (stackTop == null);

}//end isEmptyStack

public boolean isFullStack()

{

return false;

}//end isFullStack


Push

Method pushpublic 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


Peek

Method peekpublic T peek() throws StackUnderflowException

{

if (stackTop == null)


return stackTop.info;

}//end top


Pop

Method poppublic void pop() throws StackUnderflowException

{

if (stackTop == null)


stackTop = stackTop.link; //advance stackTop to the

//next node

}//end pop


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

public class LinkedStackClass<T> extends UnorderedLinkedList<T> {

…}

COSC 237 © R.G. Eyer , 2012 32

Linked ListsInterface…

Iterable

Interface…

Collection

Interface…

Queue

Interface…

Deque

Interface…

List

Class…

LinkedList

Class…

AbstractCollection

Class…

AbstractList

Class…

AbstractSequentialList

Class…

ObjectInterface…

CloneableInterface…

Serializable


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


Applications of Stacks: Postfix Expression Calculator (continued)

Table 17-1 Infix expressions and their equivalent postfix expressions


Applications of Stacks: Postfix Expression Calculator (continued)

Algorithm to evaluate postfix expressions using a stack Scan the expression from left to right Operands are pushed onto the stack When an operator is found, back up to get the

required number of operands Perform the operation Continue processing the expression


Main Algorithm Main algorithm in pseudocode for processing a

postfix expressionGet the next expressionwhile more data to process{ a. initialize the stack b. process the expression c. output result d. get the next expression}


Method evaluateExpression General algorithm for evaluateExpressionget the next tokenwhile (token != '='){ if (token is a number) { output number push number onto 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}


Method evaluateOpr This method evaluates an arithmetic 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


Method printResultpublic 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


Postfix Expression Calculator: Graphical User Interface (GUI)

Figure 17-28 GUI for the postfix calculator



(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



(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



(continued)

Figure 17-29 Sample run of PostfixCalculator program


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


Removing Recursion: Nonrecursive Algorithm to Print a Linked List Backward (continued)

current = first; //Line 1

while (current != null) //Line 2

{

stack.push(current); //Line 3

current = current.link; //Line 4

}


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


The class Stack

Table 17-2 Members of the class Stack


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

public class QueueADT<T> {…

}


Queue Operations Queue operations

initializeQueue isEmptyQueue isFullQueue front back addQueue deleteQueue


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


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


Implementation of Queues as Arrays (continued)

Figure 17-42 Queue after two more addQueue operations

public class QueueClass<T> implements QueueADT<T> {…

}



public class QueueClass<T> implements QueueADT<T> { private int maxQueueSize; private int count; private int queueFront; private int queueRear; private T[] list;

…

}



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



Figure 17-45 Circular queue



Figure 17-46 Queue with two elements at positions 98 and 99



Figure 17-47 Queue after one more addQueue operation


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

}


initializeQueue Method initilializeQueuepublic void initializeQueue()

{

for (int i = queueFront; i < queueRear;

i = (i + 1) % maxQueueSize)

list[i] = null;

queueFront = 0;

queueRear = maxQueueSize - 1;

count = 0;

}


Empty Queue and Full Queue Methods isEmptyQueue and isFullQueuepublic boolean isEmptyQueue()

{

return (count == 0);

}

public boolean isFullQueue()

{

return (count == maxQueueSize);

}


Front Method frontpublic T front() throws QueueUnderflowException

{

if (isEmptyQueue())

throw new QueueUnderflowException();

return (T) list[queueFront];

}


Back Method backpublic T back() throws QueueUnderflowException

{

if (isEmptyQueue())


return (T) list[queueRear];

}


addQueue Method addQueuepublic 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;

}


deleteQueue Method deleteQueuepublic void deleteQueue() throws QueueUnderflowException

{

if (isEmptyQueue())


count--;

list[queueFront] = null;

queueFront = (queueFront + 1) % maxQueueSize; //use the

//mod operator to advance queueFront

//because the array is circular

}


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


LinkedQueueClass & QueueNodepublic class LinkedQueueClass<T> implements QueueADT<T> { private QueueNode<T> queueFront; private QueueNode<T> queueRear;

private class QueueNode<T> { public T info; public QueueNode<T> link;

…

} // end of QueueNode<T> class private LinkedQueueClass() { queueFront = null; queueRear = null; }

…

} // end of LinkedStackClass<T> class


Linked Implementation of Queues (continued)

Method initializeQueuepublic void initializeQueue()

{

queueFront = null;

queueRear = null;

}


Linked Implementation of Queues (continued)

Methods isEmptyQueue and isFullQueuepublic boolean isEmptyQueue()

{

return (queueFront == null);

}

public boolean isFullQueue()

{

return false;

}


front and back

Methods front and backpublic T front() throws QueueUnderflowException

{

if (isEmptyQueue())


return queueFront.info;

}

public T back() throws QueueUnderflowException

{

if (isEmptyQueue())


return queueRear.info;

}


addQueue

Method addQueuepublic 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


deleteQueue

Method deleteQueuepublic void deleteQueue() throws QueueUnderflowException

{

if (isEmptyQueue())


queueFront = queueFront.link; //advance queueFront

if (queueFront == null) //if after deletion the queue

queueRear = null; //is empty, set queueRear to null

} //end deleteQueue

public class LinkedQueueClass<T> extends DoublyLinkedList<T> { …}

72

Queue Derived from the class DoublyLinkedList

The class LinkedQueueClass can be derived from the class UnorderedLinkedListClass addQueue and deleteQueue Likewise, the operations initializeQueue, initializeList, isEmptyQueue, and isEmptyList are similar

queueFront is the same as front queueRear is the same as back


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


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


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


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


Customer

Figure 17-54 UML class diagram of the class Customer


Customer (continued)

Methods getWaitingTime and incrementWaitingTime

public int getWaitingTime()

{

return waitingTime;

}

public void incrementWaitingTime()

{

waitingTime++;

}


Server

Figure 17-55 UML class diagram of the class Server


Server (continued)

Methods setTransactionTime and decreaseTransactionTime

public void setTransactionTime(int t)

{

transactionTime = t;

}

public void setTransactionTime()

{

transactionTime = currentCustomer.getTransactionTime();

}

public void decreaseTransactionTime()

{

transactionTime--;

}


Server List

Figure 17-56 UML class diagram of the class serverList


Server List (continued)

Method setServerBusypublic 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);

}


Waiting Customer Queue

Class WaitingCustomerQueueclass WaitingCustomerQueue extends QueueClass

{

public WaitingCustomerQueue()

{

super();

}

public WaitingCustomerQueue(int size)

{

super(size);

}

public void updateWaitingQueue()

{

//...

}

}


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


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


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


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

Chapter 17: Stacks and Queues Java Programming: Program Design Including Data Structures Program...

Documents

Transcript of Chapter 17: Stacks and Queues Java Programming: Program Design Including Data Structures Program...