Queues

Queue Definition Ordered list with property: All insertions take place at one end (tail) All insertions take place at one end (tail) All deletions take place at other end (head) All deletions take place at other end (head) Queue: Q = (a 0, a 1, …, a n-1 ) a0 is the front element, a n-1 is the tail, and a i is behind a i-1 for all i, 1 <= i < n

Queue Definition Because of insertion and deletion properties, Queue is very similar to: Line at the grocery store Cars in traffic Network packets …. Also called first-in first out lists

Queue Implementation Ideas Container type class for holding data Array versus Linked List? Who’s better? Head index pointer Position right before first element in queue Tail index pointer Position of last element in queue

Array-Based Queue Definition template template class Queue {public: Queue(int MaxQueueSize = DefaultSize); ~Queue(); bool IsFull(); bool IsFull(); bool IsEmpty(); void Add(const KeyType& item); KeyType* Delete(KeyType& item); private: void QueueFull(); // error handling void QueueEmpty();// error handling int head, tail; KeyType* queue; int MaxSize; };

Queue Implementation Constructor: template template Queue ::Queue(int MaxQueueSize): MaxSize(MaxQueueSize) { queue = new KeyType[MaxSize]; head = tail = -1; }

Queue Implementation Destructor: template template Queue<KeyType>::~Queue(){ delete [] queue; head = tail = -1; }

Queue Implementation IsFull() and IsEmpty(): template template bool Queue ::IsFull() { return (tail == (MaxSize-1)); } template template bool Queue ::IsEmpty() { return (head == tail); }

Queue Implementation Add() and Delete(): template template void Queue ::Add (const KeyType& item) { if (IsFull()) {QueueFull(); return;} else { tail = tail + 1; queue[tail] = item; } } template template KeyType* Queue ::Delete(KeyType& item) { if (IsEmpty()) {QueueEmpty(); return 0}; else { head = head + 1; item = queue[head]; return &item; } }

Example: Job Scheduling OS has to manage how jobs (programs) are executed on the processor – 2 typical techniques: -Priority based: Some ordering over of jobs based on importance (Professor X’s jobs should be allowed to run first over Professor Y). -Queue based: Equal priority, schedule in first in first out order.

Queue Based Job Processing FrontRear Q[0] Q[1] Q[2] Q[3] CommentsInitial0 J1 J1 Job 1 Enters 1 J1 J2 J1 J2 Job 2 Enters 2 J1 J2 J3 J1 J2 J3 Job 3 Enters 02 J2 J3 J2 J3 Job 1 Leaves 03 J2 J3 J4 J2 J3 J4 Job 4 Enters 13 J3 J4 J3 J4 Job 2 Leaves MaxSize = 4

Job Processing When J4 enters the queue, rear is updated to 3. When J4 enters the queue, rear is updated to 3. When rear is 3 in a 4-entry queue, run out of space. When rear is 3 in a 4-entry queue, run out of space. The array may not really be full though, if head is not The array may not really be full though, if head is not Head can be > -1 if items have been removed from queue. Head can be > -1 if items have been removed from queue. Possible Solution: When rear = (maxSize – 1) attempt to shift data forwards into empty spaces and then do Add.

Queue Shift private void shiftQueue(KeyType* queue, int & head, int & tail) { int difference = head – (-1); // head + 1 for (int j = head + 1; j < maxSize; j++) { queue[j-difference] = queue[j]; } head = -1; tail = tail – difference; }

Queue Shift Worst Case For Queue Shift: Full Queue Alternating Delete and Add statements FrontRear Q[0] Q[1] Q[2] Q[3] Comments3 J1 J2 J3 J4 J1 J2 J3 J4Initial 03 J2 J3 J4 J2 J3 J4 Job 1 Leaves 3 J2 J3 J4 J5 J2 J3 J4 J5 Job 5 Enters 03 J3 J4 J5 J3 J4 J5 Job 2 Enters 3 J3 J4 J5 J6 J3 J4 J5 J6 Job 6 Leaves

Worst Case Queue Shift Worst Case: Worst Case: Shift entire queue: Cost of O(n) Shift entire queue: Cost of O(n) Do every time perform an add Do every time perform an add Too expensive to be useful Too expensive to be useful Worst case is not that unlikely, so this suggests finding an alternative implementation.

Circular Array Implementation Basic Idea: Allow the queue to wrap-around Implement with addition mod size: tail = (tail + 1) % queueSize; N-1 N-2 J1 J2 J3 J N-1 N-2 J2 J3 J1

Linked Queues Problems with implementing queues on top of arrays Problems with implementing queues on top of arrays Sizing problems (bounds, clumsy resizing, …) Sizing problems (bounds, clumsy resizing, …) Non-circular Array – Data movement problem Non-circular Array – Data movement problem Now that have the concepts of list nodes, can take advantage of to represent queues. Now that have the concepts of list nodes, can take advantage of to represent queues. Need to determine appropriate way of: Need to determine appropriate way of: Representing front and rear Representing front and rear Facilitating node addition and deletion at the ends. Facilitating node addition and deletion at the ends.

Linked Queues CAT Front Rear MATHAT FrontRear Add(Hat) Add(Mat) Add(Cat)Delete()

Linked Queues Class QueueNode{ friend class Queue; public: QueueNode(int d, QueueNode * l); private: int data; QueueNode *link; };

Linked Queues class Queue {public:Queue();~Queue(); void Add(const int); int* Delete(int&); bool isEmpty(); private: QueueNode* front; QueueNode* rear; void QueueEmpty(); }

Linked Queues Queue::Queue(){ front = 0; rear = 0; } bool Queue::isEmpty() { return (front == 0); } Front Rear 0 0

Linked Queues void Queue::Add(const int y) { // Create a new node that contains data y // Has to go at end // Set current rear link to new node pointer // Set new rear pointer to new node pointer rear = rear->link = new QueueNode(y, 0); } CAT Front MAT HAT Rear

Linked Queues int * Queue::Delete(int & retValue) { // handle empty case if (isEmpty()) { QueueEmpty(); return 0;} QueueNode* toDelete = front; retValue = toDelete.data; front = toDelete->link; delete toDelete; return &retValue; } CAT Front MAT HAT ReartoDelete HAT returnValue Front

Queue Destructor Queue destructor needs to remove all nodes from head to tail. CAT Front MAT HAT RearFront Temp 0 0 if (front) { QueueNode* temp; while (front != rear) { temp = front; front = front -> link; delete temp; } delete front; front = rear = 0; }

Front vs Delete Implementation as written has to remove the item from the queue to read data value. Implementation as written has to remove the item from the queue to read data value. Some implementations provide two separate functions: Some implementations provide two separate functions: Front() which returns the data in the first element Front() which returns the data in the first element Delete() which removes the first element from the queue, without returning a value. Delete() which removes the first element from the queue, without returning a value.