1 / 43

Question of the Day

Question of the Day.

eshana
Télécharger la présentation

Question of the Day

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Question of the Day • Three people check into a hotel for which they pay the manager $30. The manager finds out the rate is $25 and gives $5 to the bellboy to return. To make it easier, the bellboy pockets $2 and gives $1 back to each person.Each person paid $10 and got back $1. So they paid $9 each, totaling $27. The bellboy has $2, totaling $29. Where is the remaining dollar?

  2. Question of the Day • Three people check into a hotel for which they pay the manager $30. The manager finds out the rate is $25 and gives $5 to the bellboy to return. To make it easier, the bellboy pockets $2 and gives $1 back to each person.Each person paid $10 and got back $1. So they paid $9 each, totaling $27. The bellboy has $2, totaling $29. Where is the remaining dollar? • $25 (manager) + $2 (bellboy) + $3 (customers) = $30

  3. CSC 212 – Data Structures Lecture 23:Queues

  4. Using Stack • Last-In, First-Out principle used to access data • Also called LIFO ordering • Top of stack is where data added & removed • Only useful location; cannot access anything else

  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& others prevent cutting in line • Use first-come, first-served getting food at dining hall

  6. 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& others prevent cutting in line • Use first-come, first-served getting food at dining hall

  7. Stack Limitations • Great for web browsers, 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& others prevent cutting in line • Use first-come, first-served getting food at dining hall

  8. Queue ADT • 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 first element in structure • Also includes method to peek in at first element • first()returns first element without removing

  9. Queue Interface public interface Queue<E> extends Collection {public Efirst()throws EmptyCollectionException;public Edequeue() throws EmptyCollectionException;public void enqueue(E element); } • Very similar to Stackinterface • Defines specific methods to add, remove, & view data • Holds many elements, but can access only one • Stack & Queuealways addto the end • Remove element at start of this Queue… • …while Stack removes element at the end

  10. Stacks vs. Queues • Access data with Stack in LIFO order • LastIn-First Out • Completely unfair (unless you are always late) • Data accessed in Queue using FIFO order • FirstIn-First Out • Lines at bank, airports represented fairly with these

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

  12. Does Space Matter?

  13. Does Space Matter?

  14. “Well-Known Study” On Space

  15. “Well-Known Study” On Space

  16. “Well-Known Study” On Space

  17. Linked-list based Queue • Class defines fields aliased to first & last nodes • front & rearoften used as fields’ names (creative!) • enqueue element by adding new Node after rear rear front

  18. Linked-list based Queue • Class defines fields aliased to first & last nodes • front & rearoften used as fields’ names (creative!) • enqueue element by adding new Node after rear rear front elem

  19. Linked-list based Queue • Class defines fields aliased to first & last nodes • front & rearoften used as fields’ names (creative!) • enqueue element by adding new Node after rear rear front elem

  20. Linked-list based Queue • Class defines fields aliased to first & last nodes • front & rearoften used as fields’ names (creative!) • enqueue element by adding new Node after rear rear front elem

  21. Linked-list based Queue • Class defines fields aliased to first & last nodes • front & rearoften used as fields’ names (creative!) • enqueue element by adding new Node after rear rear front elem

  22. Linked-list based Queue • Class defines fields aliased to first & last nodes • front & rearoften used as fields’ names (creative!) • enqueue element by adding new Node after rear • Set front to next Nodein list to dequeue element rear front retVal

  23. Linked-list based Queue • Class defines fields aliased to first & last nodes • front & rearoften used as fields’ names (creative!) • enqueue element by adding new Node after rear • Set front to next Nodein list to dequeue element rear front retVal

  24. Linked-list based Queue • Class defines fields aliased to first & last nodes • front & rearoften used as fields’ names (creative!) • enqueue element by adding new Node after rear • Set front to next Nodein list to dequeue element rear front retVal

  25. Circular Access queue front rear • Stacks are easy for arrays: only 1 end “moves” • Stack can rely on index 0 since bottom stationary • Queues are harder, because both ends move • dequeue calls will remove element at front • Add element to rear with calls to enqueue • Ends of a array-based Queue like clock time

  26. Circular Access queue front rear • Stacks are easy for arrays: only 1 end “moves” • Stack can rely on index 0 since bottom stationary • Queues are harder, because both ends move • dequeue calls will remove element at front • Add element to rear with calls to enqueue • Ends of a array-based Queue like clock time

  27. Circular Access queue front rear • Stacks are easy for arrays: only 1 end “moves” • Stack can rely on index 0 since bottom stationary • Queues are harder, because both ends move • dequeue calls will remove element at front • Add element to rear with calls to enqueue • Ends of a array-based Queue like clock time

  28. Circular Access queue front rear • Stacks are easy for arrays: only 1 end “moves” • Stack can rely on index 0 since bottom stationary • Queues are harder, because both ends move • dequeue calls will remove element at front • Add element to rear with calls to enqueue • Ends of a array-based Queue like clock time

  29. Circular Access queue front rear • Stacks are easy for arrays: only 1 end “moves” • Stack can rely on index 0 since bottom stationary • Queues are harder, because both ends move • dequeue calls will remove element at front • Add element to rear with calls to enqueue • Ends of a array-based Queue like clock time

  30. Circular Access queue front rear • Stacks are easy for arrays: only 1 end “moves” • Stack can rely on index 0 since bottom stationary • Queues are harder, because both ends move • dequeue calls will remove element at front • Add element to rear with calls to enqueue • Ends of a array-based Queue like clock time

  31. Circular Access queue front rear • Stacks are easy for arrays: only 1 end “moves” • Stack can rely on index 0 since bottom stationary • Queues are harder, because both ends move • dequeue calls will remove element at front • Add element to rear with calls to enqueue • Ends of a array-based Queue like clock time

  32. Circular Access queue front rear • Stacks are easy for arrays: only 1 end “moves” • Stack can rely on index 0 since bottom stationary • Queues are harder, because both ends move • dequeue calls will remove element at front • Add element to rear with calls to enqueue • Ends of a array-based Queue like clock time

  33. Circular Access queue front rear • Stacks are easy for arrays: only 1 end “moves” • Stack can rely on index 0 since bottom stationary • Queues are harder, because both ends move • dequeue calls will remove element at front • Add element to rear with calls to enqueue • Ends of a array-based Queue like clock time

  34. Array-based Queue Operations • Based on clock math • Uses mod (remainder) • Java expressed mod as % • How mod works:0 % 3 = 01 % 3 = 12 % 3 = 23 % 3 = 0

  35. Array-based Queue • Two fields track front and rear of Queue frontequals indexof front element rearholds indeximmediately after rear element (Queue stores number of elements using count) • Adds & removes elements from opposite ends • Uses circular indexing within array • When end reached, index loops back to 0; just like clock queue front rear

  36. Array-based Queue • Two fields track front and rear of Queue frontequals indexof front element rearholds indeximmediately after rear element (Queue stores number of elements using count) • Adds & removes elements from opposite ends • Uses circular indexing within array • When end reached, index loops back to 0; just like clock queue front rear

  37. Array-based Queue • Two fields track front and rear of Queue frontequals indexof front element rearholds indeximmediately after rear element (Queue stores number of elements using count) • Adds & removes elements from opposite ends • Uses circular indexing within array • When end reached, index loops back to 0; just like clock queue front rear

  38. Array-based Queue • Two fields track front and rear of Queue frontequals indexof front element rearholds indeximmediately after rear element (Queue stores number of elements using count) • Adds & removes elements from opposite ends • Uses circular indexing within array • When end reached, index loops back to 0; just like clock queue rear front

  39. Array-based Queue • Two fields track front and rear of Queue frontequals indexof front element rearholds indeximmediately after rear element (Queue stores number of elements using count) • Adds & removes elements from opposite ends • Uses circular indexing within array • When end reached, index loops back to 0; just like clock queue rear front

  40. Array-based Queue • Two fields track front and rear of Queue frontequals indexof front element rearholds indeximmediately after rear element (Queue stores number of elements using count) • Adds & removes elements from opposite ends • Uses circular indexing within array • When end reached, index loops back to 0; just like clock queue front rear

  41. queue front rear Array-based Queue Operations Algorithmenqueue(e) ifsize() = queue.lengththen expandCapacity() endif queue[rear]e rear(rear+ 1) rearrear%queue.length countcount+ 1 Algorithmdequeue() ifisEmpty() then throw EmptyCollectionException else retValqueue[front] front(front+ 1)front front%queue.length countcount - 1 returnretVal

  42. Your Turn • Get into your groups and complete activity

  43. For Next Lecture • Tomorrow at 5PM weekly assignment #8 due • Wednesday’s class: quiz on Stacks & Queues • Project #1 due on Saturday at 11:59PM

More Related