1. Question of the Day  How can you change the position of 1 toothpick and leave the giraffe in exactly the same form, but possibly mirror-imaged or oriented differently, as before?

2. Question of the Day  How can you change the position of 1 toothpick and leave the giraffe in exactly the same form, but possibly mirror-imaged or oriented differently, as before?

3. CSC 212 – Data Structures

4. Using Stack

5. 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

6.  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

7. Queue Interface public interface Queue extends Collection { public E enqueue() throws EmptyQueueException; public E dequeue() throws EmptyQueueException; public void front(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

8. Stacks vs. Queues

9.  “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

10.  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

11.  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

12.  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

13.  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

14.  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

15.  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

16.  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

17.  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 r f r rrr r r r

18. f r 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 r r f r r r

19. 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

20. 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

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

22. 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