What is a Queue?

1. What is a Queue? • Logical (or ADT) level:A queue is an ordered group of homogeneous items (elements), in which new elements are added at one end (the rear), and elements are removed from the other end (the front). • A queue is a FIFO “first in, first out” structure.

2. Queues 2

3. Queues: Application Level • For what type of problems would queues be useful? • Print server • maintains a queue of print jobs. • Disk driver • maintains a queue of disk input/output requests. • Scheduler (e.g., in an operating system) • maintains a queue of processes awaiting a slice of machine time. 3

4. Application of Queue and Stack • Palindromes: words or phrases that read the same in both directions, e.g. EYE, RACECAR, MADAM I'M ADAM, and : • Testing if a given word or phrase is a palindrome: • Scan the string character by character, and store each character into a stack(push) and queue(enqueue) • After all characters have been processed, repeatedly pop a character from the stack, and deque a character from the queue, and compare them. Not match=>not a palindrome • If finished comparing with no mismatches => a palindrome 4

5. Queues: implementation level class QueueType { public: QueueType(int max); QueueType(); ~QueueType(); bool IsEmpty() const; bool IsFull() const; void Enqueue(ItemType item); //add newItem to the rear of the queue. void Dequeue(ItemType& item); //remove front item from queue 5

6. Array-Based Implementation private: ItemType* items; // Dynamically allocated array int maxQue; // Whatever else we need }; Implementation level 6

7. Array-Based Implementation An array with the front of the queue fixed in the first position. Enqueue A, B, C, D Dequeue Shift elements up by 1 What’s the problem with this design? 7

8. Array-Based Implementation Another data structure: An array where the front floats. What happens if we add X, Y, and Z? 8

9. Array-Based Implementation Let the queue wrap around in the array; i.e. treat the array as a circular structure. 9

10. Array-Based Implementation (a) Initial conditions front = 2 rear = 2 (b) queue.Dequeue(item) front = 3 rear = 2 A [0] [1] [2] [3] [4] [0] [1] [2] [3] [4] Empty Queue Full Queue How can we tell the difference? 10

11. Array-Based Implementation Reserve the slot (not used) before front item. front is the index of the slot before front item. Empty Queue Full Queue 11

12. DYNAMIC ARRAY IMPLEMENTATION class QueType QueType Private Data: front 1 rear 4 maxQue 5 items ~QueType Enqueue ‘C’ ‘X’ ‘J’ RESERVED Dequeue . . . items [0] [1] [2] [3] [4] 12

13. Array-Based Implementation private: int front; int rear; int maxQue; ItemType* items; }; Complete implementation level 13

14. Array-Based Implementation //returns true if the queue is empty bool QueueType::IsEmpty( ) { return ( rear == front ); } //returns true if the queue is full bool QueueType::IsFull( ) { return ( (rear + 1) % maxQue == front ) } 14

15. Array-Based Implementation //Pre: the queue is not full //Post: newItem is at the rear of the queue void QueueType::Enqueue(ItemType newItem) { rear = (rear + 1) % maxQue; items[rear] = newItem; } 15

16. Array-Based Implementation //pre: the queue is not empty //post: the front of the queue has been removed //and a copy returned in item void QueueType::Dequeue(ItemType& item) { front = (front + 1) % maxQue; item = items[front]; } 16

17. Array-Based Implementation QueueType::QueueType( int max) { maxQue = max + 1; front = maxQue - 1; rear = maxQue - 1; items = new ItemType[maxQue]; } QueueType::QueueType( ) { maxQue = 500 + 1; front = maxQue - 1; rear = maxQue - 1; items = new ItemType[maxQue]; } Why is the array declared max + 1? 17

18. Counted Queue* Counted Queue A queue that has an additional function GetLength that returns the number of items in the queue. The CountedQueType class will inherit (extend) the QueType class. What functions must be defined in class CountedQueType? 18

19. Counted Queue* class CountedQueueType : public QueueType { public: CountedQueueType(); void Enqueue(ItemType newItem); void Dequeue(ItemType& item); int GetLength( ) const; private: int length; }; 19

20. Counted Queue* 20

21. Counted Queue* void CountedQueueType::Enqueue(ItemType newItem) { try { QueueType::Enqueue(newItem); length++; } catch(FullQueue) { throw FullQueue();} } What is this? Why must the call to Enqueue be embedded within a try/catch statement? 21

22. Counted Queue* Does the derived class have access to the base class’s private data members in C++? 22

23. Linked Implementation Data structure for linked queue What data members are needed? 23

24. Linked Implementation Enqueue(newItem) Set newNode to the address of newly allocated node Set Info(newNode) to newItem Set Next(newNode) to NULL Set Next(rear) to newNode If queue is empty Set front to newNode else Set Next(rear) to newNode 24

25. Linked Implementation Dequeue(item) Set tempPtr to front Set item to Info(front) Set front to Next(front) if queue is now empty Set rear to NULL Deallocate Node(tempPtr) 25

26. Circular Linked Queue • Make the linked queue circular: • Make the next member of rear node point to the front node of the queue • Maintain a single pointer: rear • Accessing front node is a constant time operation: rear->next 26

27. Storage Requirements What does this table tell you? 27

28. Big-O Comparison (Queue) 28

29. //-------------------------------------------------------- // CLASS TEMPLATE DEFINITION FOR CIRCULAR QUEUE #include "ItemType.h" // for ItemType template<class ItemType> class QueType { public: QueType( ); QueType( int max ); // PARAMETERIZED CONSTRUCTOR ~QueType( ); // DESTRUCTOR . . . bool IsFull( ) const; void Enqueue( ItemType item ); void Dequeue( ItemType& item ); private: int front; int rear; int maxQue; ItemType* items; // DYNAMIC ARRAY IMPLEMENTATION }; 29

30. //-------------------------------------------------------- // CLASS TEMPLATE DEFINITION FOR CIRCULAR QUEUE cont’d //-------------------------------------------------------- template<class ItemType> QueType<ItemType>::QueType( int max ) // PARAMETERIZED { maxQue = max + 1; front = maxQue - 1; rear = maxQue - 1; items = new ItemType[maxQue]; // dynamically allocates } template<class ItemType> bool QueType<ItemType>::IsEmpty( ) { return ( rear == front ) } 30

31. //-------------------------------------------------------- // CLASS TEMPLATE DEFINITION FOR CIRCULAR QUEUE cont’d //-------------------------------------------------------- template<class ItemType> QueType<ItemType>::~QueType( ) { delete [ ] items; // deallocates array } . . . template<class ItemType> bool QueType<ItemType>::IsFull( ) { // WRAP AROUND return ( (rear + 1) % maxQue == front ) } 31

32. ALL PUBLIC MEMBERS OF QueType CAN BE INVOKED FOR OBJECTS OF TYPE CountedQueType // DERIVED CLASS CountedQueType FROM BASE CLASS QueType template<class ItemType> class CountedQueType : public QueType<ItemType> { public: CountedQueType( ); void Enqueue( ItemType newItem ); void Dequeue( ItemType& item ); int LengthIs( ) const; // Returns number of items on the counted queue. private: int length; };

33. // Member function definitions for class CountedQue template<class ItemType> CountedQueType<ItemType>::CountedQueType( ) : QueType<ItemType>( ) { length = 0 ; } template<class ItemType> int CountedQueType<ItemType>::LengthIs( ) const { return length ; } 33

34. template<class ItemType> void CountedQueType<ItemType>::Enqueue( ItemType newItem ) // Adds newItem to the rear of the queue. // Increments length. { length++; QueType<ItemType>::Enqueue( newItem ); } template<class ItemType> void CountedQueType<ItemType>::Dequeue(ItemType& item ) // Removes item from the rear of the queue. // Decrements length. { length--; QueType<ItemType>::Dequeue( item ); }

35. ‘C’ ‘Z’ ‘T’ class QueType<char> QueType Private Data: qFront qRear ~QueType Enqueue Dequeue . . .

36. // DYNAMICALLY LINKED IMPLEMENTATION OF QUEUE #include "ItemType.h" // for ItemType template<class ItemType> class QueType { public: QueType( ); // CONSTRUCTOR ~QueType( ) ; // DESTRUCTOR bool IsEmpty( ) const; bool IsFull( ) const; void Enqueue( ItemType item ); void Dequeue( ItemType& item ); void MakeEmpty( ); private: NodeType<ItemType>* qFront; NodeType<ItemType>* qRear; }; 36

37. // DYNAMICALLY LINKED IMPLEMENTATION OF QUEUE continued // member function definitions for class QueType template<class ItemType> QueType<ItemType>::QueType( ) // CONSTRUCTOR { qFront = NULL; qRear = NULL; } template<class ItemType> bool QueType<ItemType>::IsEmpty( ) const { return ( qFront == NULL ) } 37

38. template<class ItemType> void QueType<ItemType>::Enqueue( ItemType newItem ) // Adds newItem to the rear of the queue. // Pre: Queue has been initialized. // Queue is not full. // Post: newItem is at rear of queue. { NodeType<ItemType>* ptr; ptr = new NodeType<ItemType>; ptr->info = newItem; ptr->next = NULL; if ( qRear == NULL ) qFront = ptr; else qRear->next = ptr; qRear = ptr; } 38

39. template<class ItemType> void QueType<ItemType>::Dequeue( ItemType& item ) // Removes element from from front of queue // and returns it in item. // Pre: Queue has been initialized. // Queue is not empty. // Post: Front element has been removed from queue. // item is a copy of removed element. { NodeType<ItemType>* tempPtr; tempPtr = qFront; item = qFront->info; qFront = qFront->next; if ( qFront == NULL ) qRear = NULL; delete tempPtr; } 39