1. CSC 212 – Data Structures

2. Using Stack

3. Stack Limitations  Great for Pez dispensers, JVMs,& methods  All of these use most recent item added only  Do not complain when later additions served first  Many situations use items in order added  Checker at Wegmans & other stores do not cut line  Use first-come, first-served getting food at dining hall

4.  Collection ’s operations are part of Queue  As in Stack, declares size() & isEmpty()  Add & remove elements using 2 methods  Element gets added to end with enqueue(elem)  dequeue() removes front element in structure  Also includes method to peek in at first element  front() returns element at front without removing Queue ADT

5. Queue Interface public interface Queue extends Collection { public E front() throws EmptyQueueException; public E dequeue() throws EmptyQueueException; public void enqueue(E element); }  Very similar to Stack interface  Defines specific methods to add, remove, & view data  Holds many elements, but can access only one  Stack & Queue always add to the end  Remove element at start of this Q UEUE …  …while S TACK removes element at the end

6. Stacks vs. Queues

7.  “Obvious” implementation uses an array  Must consume a constant amount of space  enqueue() throws exception when it lacks space  Instead write linked list-based implementation  Singly-, doubly-, or circular-linked list could work  Size of the Queue grows & shrinks as needed  No additional exceptions needed, but is it slower? Queue Implementation

8.  Class defines fields aliased to first & last nodes  head & rear often used as fields’ names (creative!)  enqueue element by adding new Node after rear  Set head to next Node in list to dequeue element Linked-list based Queue head rear

9.  Class defines fields aliased to first & last nodes  head & rear often used as fields’ names (creative!)  enqueue element by adding new Node after rear  Set head to next Node in list to dequeue element Linked-list based Queue head rear retVal

10.  S TACKS are easy for arrays: only 1 end “moves”  Can always find Stack’s bottom at index 0  Q UEUES are harder, because both ends move  dequeue calls will remove element at front  Add element to back with calls to enqueue  Ends of a array-based Q UEUE like clock time Circular Access q

11. Array-based Queue  Two fields track front and rear of Q UEUE f equals index of front element r holds index immediately after rear element  Add & remove elements from opposite ends  Uses circular access to the array  Works like clock: when end (12) reached, loop to start Array must be empty at index in r q

12. Array-based Queue Operations  Based on clock math  Uses mod (remainder)  Java expressed mod as %  How mod works: 0 % 3 = 0 1 % 3 = 1 2 % 3 = 2 3 % 3 = 0 Algorithm size() N  q.length return (N  f + r) mod N

13. Array-based Queue Operations Algorithm enqueue(e) if size() = q.length  1 then throw FullQueueException else q[r]  e r  (r + 1) mod q.length q rf Algorithm dequeue() if isEmpty() then throw EmptyQueueException else retVal  q[f] f  (f + 1) mod q.length return retVal

14. Your Turn  Get into your groups and complete activity

15. For Next Lecture  Read GT section 5.3 before Friday's class  Discusses design of the Deque ADT  Array-based implementation of Deque presented  Deque implementation of linked-list also shown  Week #9 weekly assignment due on Tuesday  Midterm #2  Midterm #2 will be in class next Wednesday