Getting queues right … finally (?) EECE.3220 Data Structures Instructor: Dr. Michael Geiger Spring 2019 Lecture 27: Getting queues right … finally (?)

Announcements/reminders Program 3 due today Program 4 to be posted, due some time before end of semester Today’s lecture: fixing all of the queue stuff Array-based queues Outlining the issues one last time Going through one specific implementation Linked queues 7/5/2019 Data Structures: Lecture 27

Data Structures: Lecture 27 Review: Queue ADT Queue is first-in, first-out (FIFO) data structure Definition Ordered collection of data items Items only removed (or read) from the front Items only added to the back Operations Construction (start with empty queue) Check if queue is empty Enqueue: add data to the back of the queue Dequeue: remove data from the front of the queue Read item at front of queue 7/5/2019 Data Structures: Lecture 27

Review: Queue implementation Like stack, very similar to list ADT Same basic idea: sequence of items Restrict access only to front, back element What data do we need in a queue object? Actual queue storage Locations of front and back elements Capacity (if array-based) Implementation options Array-based queue Linked queue 7/5/2019 Data Structures: Lecture 27

Array-based queue issues, part 1 Where should front, back of queue be in array? Consider where you add, remove items Add to back  “highest indexed element” Remove from front  “lowest indexed element” One implementation Increment “back” when you enqueue Increment “front” when you dequeue What’s problem? “Walk off” end of array Solution: array as circular buffer Use modulo arithmetic when incrementing index, e.g. front = (front + 1) % capacity 7/5/2019 Data Structures: Lecture 27

Array-based queue issues, part 2 What’s with the quotes on the last slide? Add to back  “highest indexed element” Remove from front  “lowest indexed element” Two reasons If array is circular, could have back < front Some flexibility in how you actually treat front/back indexes (and there’s no “right” way) 7/5/2019 Data Structures: Lecture 27

Array-based queue issues, part 2 (cont.) Approach #1: index == position to operate on next So, front = location to read next Refers to spot containing data (unless empty) Initialize to 0 Back = location to write next Refers to spot after data was last written In both cases: operate on position, then inc. index “operate on position” = write (enqueue) / read (dequeue) 3 2 back front Enqueue 7: 7 7/5/2019 Data Structures: Lecture 27

Array-based queue issues, part 2 (cont.) Approach #2: index == position most recently operated on So, front = location that was just read Refers to spot behind data to be read next Initialize to -1 or capacity - 1 Back = location that was just written Refers to spot behind data to be written next Initialize to -1 or capacity – 1 In both cases, inc. index, then operate on position 3 2 front back Enqueue 7: 7 7/5/2019 Data Structures: Lecture 27

Array-based queue issues, part 3 How do we check for full/empty conditions? Need something extra Leave one spot in array empty Track full/empty with separate variable Unsigned var with number of slots used (or unused) Boolean for empty condition (or full) Examples that follow assume: Initially, front = back = 0 Therefore, index = position to operate on next 7/5/2019 Data Structures: Lecture 27

Array-based queue issues, part 3 (cont.) Approach #1: Keep one array spot empty Empty condition: front == back Full condition (tested when enqueueing): front == (back + 1) % capacity Empty  Enqueue 7 7 front back Prior state  Enqueue 13, 52, 31, 10 13 52 31 10 Prior state  Dequeue 5 times front / back 7/5/2019 Data Structures: Lecture 27

Array-based queue issues, part 3 (cont.) Approach #2: Track full/empty (let’s use unsigned nVals) Init to 0, increment on enqueue, decrement on dequeue Empty condition: nVals == 0 Full condition: nVals == capacity Empty  Enqueue 7, so nVals = 1 7 front back Prior state  Enqueue 13, 52, 31, 10, 15, so nVals = 6 13 52 31 10 15 front / back Prior state  Dequeue 6 times, so nVals = 0 7/5/2019 Data Structures: Lecture 27

Array-based queue examples Describe, in code or pseudo-code, how to write the following queue member functions Default constructor: Queue(unsigned maxSize = 1024); Destructor: ~Queue(); Check if empty: bool isEmpty(); Add new element: void enqueue(const QueueElement &val); Remove front element: void dequeue(); Retrieve front element: QueueElement getFront(); Assume “QueueElement” defined using typedef to represent data stored in queue Assume queue has following members QueueElement *list int front, back Locations of front & back elements unsigned cap Max size of array This implementation will leave one spot empty I think tracking # of values is easier, which is why we won’t cover it in class! 7/5/2019 Data Structures: Lecture 27

Array-based queue example solutions Queue::Queue(unsigned maxSize) : front(0), back(0), cap(maxSize) { list = new QueueElement[cap]; } Queue::~Queue(unsigned maxSize) { delete [] list; bool Queue::empty() const { return (front == back); void Queue::enqueue(const QueueElement &val) { int newBack = (back + 1) % cap; if (newBack != front) { // Queue isn’t full list[newBack] = val; myBack = newBack; else // handle error appropriately 7/5/2019 Data Structures: Lecture 27

Array-based queue example solutions void Queue::dequeue() { if (!empty()) front = (front + 1) % capacity; else // handle error } QueueElement Queue::front() { return list[front]; else { // return garbage value cout << "Can’t read from empty queue\n"; return list[capacity-1]; 7/5/2019 Data Structures: Lecture 27

Data Structures: Lecture 27 Linked queues Implementation similar to linked list Like linked stack, insert/delete functions O(1) since each only accesses one end of list … … as long as you have pointers to each end Queue class Needs two pointers—front and back of queue We’ll cover some details of this next lecture 7/5/2019 Data Structures: Lecture 27

Data Structures: Lecture 27 Circular linked queue One other option for linked queue: circular linked list Maintain pointer only to last node: back of queue Where’s front of queue? last->next 7/5/2019 Data Structures: Lecture 27

Data Structures: Lecture 27 Final notes Next time Linked queues Linked lists Reminders: Program 3 due today Program 4 to be posted, due TBD 7/5/2019 Data Structures: Lecture 27