Stacks and Queues

Stacks and Queues Starring: IndexOutOfBOundsException Co-Starring: NoSuchElementException

Purpose: • In this lecture series we will discuss two more ADTs • The Stack and Queue data types are used to process data in a linear fashion

Resources: • Barrons Chapter 9 p.300 (EXCEPT Priority Queues p.305-309) • Fundamentals of Java Chapter 15 p.583 • Java Essentials Chapter 19 p.757 • Java Essentials Study Guide Chapter 16 p.281 • Java Methods Chapter 3 p.61

Handouts: 1. Stack and Queue Interfaces & Implementations 2. The Following Java Code/API: Stack API (class) Queue API (interface) ArrayStack.java ListQueue.java

Intro: • A STACK is a linearly ordered list • A STACK is a data structure used for storing and retrieving data elements in such a way that the element stored last will be retrieved first. • LIFO --- last in first out

Intro: • A QUEUE is a data structure used for temporary storage from which the data elements are retrieved in the same order as they were stored. • FIFO – first in first out • Used for processing events that have to be processed in the order of their arrival (events are buffered in the queue)

Stacks: • Think of the mountain of clothes piled in a corner of your room • As you hurry to dress so as not to be late for school, you begin your search from the TOP of the clothes pile • The last stuff to be thrown on to the pile is the first to be examined • This is a “messy” stack

TO implement a Stack ADT, you must provide a way to store (push) and remove (pop) elements from a Stack • Elements on the stack should be of the same type (or in the same class hierarchy) • A Stack has no limits as to its size

TO add an element on to the stack you “Push” that item and it goes to the front of the stack • TO remove an element from the stack, you can only “Pop” off the element currently at the top of the stack • PUSH --- adds elements to the top of the stack • POP --- removes the element from the top of the stack

The PUSH and POP operations should be in Constant time O(1) • PEEK --- return the top element of the Stack without removing it • EMPTY --- see if the Stack has any elements left in it • SEARCH --- returns the position where an object is on the Stack

For testing purposes, we will use the Java Stack Class (the actual Java class is posted on the website and provided as a handout)

public class Stack<E> extends Vector<E> { public Stack() { } public E push(E item) { addElement(item); return item; } public synchronized E pop() { E obj; int len = size(); obj = peek(); removeElementAt(len - 1); return obj; } public synchronized E peek() { int len = size(); if (len == 0) throw new EmptyStackException(); return elementAt(len - 1); }

public boolean empty() { return size() == 0; } public synchronized int search(Object o) { int i = lastIndexOf(o); if (i >= 0) { return size() - i; } return -1; }

RUNTIME STACK • Remember the “runtime stack” ? • It uses stacks to handle function calls • The stack holds the function specific data PLUS the memory address of the NEXT instruction to execute • Elements are “on the stack”

The stack is controlled by the two main operations: PUSH & POP • Lets look at an example of how we can use the Stack Class, YOU are required to understand the BIG-O of each method and the use of Generics in the Stack class. • After we examine the Stack class, we will write our own implementation of the Stack class.

Stack<Integer> sI = new Stack<Integer>(); sI.push(21); sI.push(42); sI.push(84); for(Integer i:sI) { System.out.println(i.toString()); } sI.pop(); System.out.println(sI.peek().toString()); System.out.println(sI.empty()); System.out.println(sI.search(21));

You could Implement a Stack as a singly linked list enhanced by an additional reference to the tail of the list Elements are added at the tail of the list and removed at the head of the list. • However, lets look at an ArrayList Implementation

public class arrayStack <E> extends Stack<E>{ private ArrayList<E> array; public arrayStack() //(E i) { // value = i; array = new ArrayList<E>(); } public E push(E item) { array.add (item); return item; } public E pop() { return array.remove(array.size() - 1); }

public E peek() { return array.get(array.size() - 1); } public boolean empty() { return array.size() == 0; } public int search(Object o) { int i = array.lastIndexOf(o); if (i >= 0) { return array.size() - i; } return -1; } }

To use the Stack: // SPVM arrayStack<String> mS = new arrayStack<String>(); mS.push("Billy"); mS.push("Joe"); mS.push("Bob"); mS.push("Sally"); mS.push("Lucy"); • The Stack Should now look like this: Lucy Sally Bob Joe Billy

String o = mS.pop( ); String s = mS.pop( ); String y = mS.peek( ); boolean ee = mS.empty(); • The Stack Should now look like this: Bob Joe Billy The String y contains “Bob” The Boolean empty is False

Errors: • The pop and peek methods can throw an Unchecked Exception IndexOutOfBOundsException or NoSuchElementException in cases where the stack is empty

If you use the ArrayList or the LinkedList Java class to implement your Stack, then these errors are handled , for you, from within these classes

Queues: • Its lunch time and you leave class early to get into the food line • “SaLee” dashes as fast as he can and is first to grab a tray and get into line • After SaLee, “AJ” trips over a floor tile and skins his knee

As a result, “Eli” stops to help wipe away AJ’s tears and to give him a Scooby Doo bandaid • So, Eli winds up behind SalLee and AJ follows • Since the line is implemented as a Queue, SalLee gets the best lunch choices and AJ gets the crumbs

TO implement a Queue ADT, you must provide a way to store (add) and remove (remove) elements from a Queue • Elements on the Queue should be of the same type (or in the same class hierarchy) • A Queue has no limits as to its size

TO add an element on to the Queue you “add” that item and it goes to the end of the Queue • TO remove an element from the Queue, you can only “remove” off the element currently at the top of the Queue

ADD --- adds elements to the end of the Queue • REMOVE --- removes the element from the top of the Queue • These operations should be in Constant time O(1)

Other behaviors of the Queue should return the top element of the Queue without removing it (peek) and to see if the Queue has any elements left in it (isEmpty) • For our purposes, we will use the Java standard Queue Interface:

public interface Queue { // postcondition: returns true if queue is empty, false otherwise boolean isEmpty(); // precondition: queue is [e1, e2, ..., en] with n >= 0 // postcondition: queue is [e1, e2, ..., en, x] void enqueue(Object x); // precondition: queue is [e1, e2, ..., en] with n >= 1 // postcondition: queue is [e2, ..., en]; returns e1 // throws an unchecked exception if the queue is empty Object dequeue(); // precondition: queue is [e1, e2, ..., en] with n >= 1 // postcondition: returns e1 // throws an unchecked exception if the queue is empty Object peekFront(); }

As we can see, the QUEUE is merely an Interface in Java and can be Implemented using specific data structures. • The LinkedList class supports the rules of the Queue ADT and therefore is the preferred implementation of a Queue.

The College Board uses this implementation to execute a Queue, therefore you must understand the LinkedList methods that will PERFORM the list as a QUEUE. • boolean add(E x) • E remove() • E peek() • boolean isEmpty()

Therefore, the QUEUE interface method OFFER is implemented in the LinkedList class as add • We will examine the following code that utilizes a LinkedList AS A QUEUE, however, you will implement your own QUEUE.

As far as the AP requirements, understanding the rules of the QUEUE ADT as well as the BIG-O and the LinkedList implementation will suffice, however, you will be held responsible, for our tests, for everything we cover in class and accomplish in our labs.

Here is a Queue example: LinkedList<Integer> r = new LinkedList<Integer>(); r.add(32); r.add(64); r.add(128); for(Integer x:r) { System.out.println(x.toString()); } r.remove(); System.out.println( r.isEmpty()); System.out.println( r.peek());

Ring Buffer • An array used in a circular manner. • Adjust the pointer that defines the “logical” first array element. • The state of the queue is maintained with the help of 2 indices, FRONT and REAR.

Front points to the first element in the queue (returned by the next call to the remove) • Rear points to the empty slot following the last stored element. • Add method stores the next element in the slot pointed to by the rear and increments the rear index.

PC’s have a keyboard queue implemented as a ring buffer. When a key is pressed its code does not go directly to the active program but is placed in the keyboard buffer until the program requests it.

Queues are best when simulating bank lines, or any other system where there is a “First Come First Served” basis

BIG-O • OperationStackQueue Insert/Add push add O(1) O(1) Remove pop remove O(1) O(1) Peek peek peek O(1) O(1)

TPS: Implement a Queue by Writing your own Class • Implement the Possible Unchecked Exceptions

AP AB Subset Requirements: • stacks, queues and priority queues always refer to the conceptual data structure e.g. don’t add to the middle of a queue

AP AB Subset Requirements: • students who carry out operations in a free-response question that are incompatible with the conceptual nature of a data structure may not receive full credit

AP AB Subset Requirements: • Students are also responsible for understanding that these ADT’s can be implemented as an array or a linked list, although you will NOT be tested on any SPECIFIC implementation

AP AB Subset Requirements: • You will see Multiple Choice questions regarding analysis of Stack and Queue implementations and processes • Multiple Choice questions may focus on your ability to evaluate the effectiveness of and to determine the best use of Stacks and Queues

Projects: • Barrons M/C Questions Chapter 9 p.310 Do ALL Questions Except the following: # 14, 15 • Decimal to Binary • Expression • McDonalds • Palendrome

TEST FOLLOWS COMPLETION OF PROJECTS !!!

Stacks and Queues