Queues Dr. Anwar Ghani Lecture 06: Queue Data Structures International Islamic University, Islamabad

Lecture 06: Queue Data Structures “A Queue is a special kind of list, where items are inserted at one end (the rear) And deleted at the other end (the front)”. Other Names First In First Out (FIFO) International Islamic University, Islamabad

Line of customers in a bank Lecture 06: Queue Data Structures Common Operations on Queues 1. 2. 3. 4. 5. MAKENULL(Q): Makes Queue Q be an empty list. FRONT(Q): Returns the first element on Queue Q. ENQUEUE(x,Q): Inserts element x at the end of Queue Q. DEQUEUE(Q): Deletes the first element of Q. EMPTY(Q): Returns true if and only if Q is an empty queue. Example: Line of customers in a bank International Islamic University, Islamabad

Applications of Queues Lecture 06: Queue Data Structures Applications of Queues Operating system multi-user/multitasking environments, where several users or task may be requesting the same resource simultaneously. Communication Software queues to hold information received over networks and dial up connections. (Information can be transmitted faster than it can be processed, so is placed in a queue waiting to be processed) Some other? International Islamic University, Islamabad

Implementation Static Dynamic Lecture 06: Queue Data Structures Implementation Static Queue is implemented by an array, and size of queue remains fix Dynamic A queue can be implemented as a linked list, and expand or shrink with each enqueue or dequeue operation. International Islamic University, Islamabad

Lecture 06: Queue Data Structures International Islamic University, Islamabad

. A pointer Implementation of Queues x y z Keep two pointers: Lecture 06: Queue Data Structures A pointer Implementation of Queues Keep two pointers: FRONT: A pointer to the first element of the queue. REAR: A pointer to the last element of the queue. . Front x y z Rear International Islamic University, Islamabad

. A pointer Implementation of Queues MAKENULL(Q) ENQUEUE(x,Q) x Lecture 06: Queue Data Structures A pointer Implementation of Queues MAKENULL(Q) NULL Q.front Q.Rear ENQUEUE(x,Q) . x Q.front Q.Rear International Islamic University, Islamabad

. . . A pointer Implementation of Queues ENQUEUE(y,Q) x y DEQUEUE(Q) y Lecture 06: Queue Data Structures A pointer Implementation of Queues ENQUEUE(y,Q) . x y Q.front Q.Rear DEQUEUE(Q) . . y Q.front Q.Rear International Islamic University, Islamabad

A class for Dynamic Queue implementation Lecture 06: Queue Data Structures A class for Dynamic Queue implementation class DynIntQueue { private: struct QueueNode int value; QueueNode *next; }; QueueNode *front; QueueNode *rear; int numItems; public: DynIntQueue(void); ~DynIntQueue(void); void enqueue(int); int dequeue(void); bool isEmpty(void); void makeNull(void); International Islamic University, Islamabad

Implemenaton Lecture 06: Queue Data Structures //************************ // Constructor * DynIntQueue::DynIntQueue(void) { front = NULL; rear = NULL; numItems = 0; } // Destructor * DynIntQueue::~DynIntQueue(void) makeNull(); International Islamic University, Islamabad

Lecture 06: Queue Data Structures //******************************************** // Function enqueue inserts the value in num * // at the rear of the queue. * void DynIntQueue::enqueue(int num) { QueueNode *newNode; newNode = new QueueNode; newNode->value = num; newNode->next = NULL; if (isEmpty()) front = newNode; rear = newNode; } else rear->next = newNode; rear = newNode; numItems++; International Islamic University, Islamabad

Lecture 06: Queue Data Structures //********************************************** // Function dequeue removes the value at the * // front of the queue, and copies it into num. * int DynIntQueue::dequeue(void) { QueueNode *temp; int num; if (isEmpty()) cout << "The queue is else { num = front->value; temp = front->next; delete front; front = temp; numItems--; } return num; empty.\n"; } International Islamic University, Islamabad

Lecture 06: Queue Data Structures //********************************************* // Function isEmpty returns true if the queue * // is empty, and false otherwise. * bool DynIntQueue::isEmpty(void) { if (numItems) return false; else return true; } International Islamic University, Islamabad

Lecture 06: Queue Data Structures //******************************************** // Function makeNull dequeues all the elements * // in the queue. * void DynIntQueue::makeNull(void) { while(!isEmpty()) dequeue(); } International Islamic University, Islamabad

value =iQueue.dequeue(); cout << value << endl; Lecture 06: Queue Data Structures Program // This program demonstrates the DynIntQeue void main(void) { DynIntQueue iQueue; class cout << "Enqueuing 5 items...\n"; // Enqueue 5 items. for (int x = 0; x < 5; x++) iQueue.enqueue(x); // Deqeue and retrieve all items in the queue cout << "The values in the queue were:\n"; while (!iQueue.isEmpty()) { int value; value =iQueue.dequeue(); cout << value << endl; } International Islamic University, Islamabad

Program Ouput Lecture 06: Queue Data Structures Enqueuing 5 items... The values in the queue 0 were: 1 2 3 4 International Islamic University, Islamabad

Array Implementation Lecture 06: Queue Data Structures When queue is empty both front and rear are set to -1 While enqueueing increment rear by 1, and while dequeueing increment front by 1 When there is only one value in the Queue, both rear and front have same index Front First Element Second Elem. ent . Rear Last Element maxlength International Islamic University, Islamabad

Array Implementation How can we insert more elements? Rear index can Lecture 06: Queue Data Structures Array Implementation 5 4 6 7 8 1 2 Front=0 Rear=6 3 4 5 6 7 8 8 7 6 1 2 Front=4 Rear=6 3 4 5 6 7 8 7 6 12 67 1 2 Front=5 Rear=8 3 4 5 6 7 8 How can we insert more elements? Rear index can not move beyond the last element…. International Islamic University, Islamabad

Drawbacks of Linear Queue

Solution: Using circular queue Lecture 06: Queue Data Structures Solution: Using circular queue Allow rear to wrap around the array. if(rear == queueSize-1) rear = 0; else rear++; Or use module arithmetic rear = (rear + 1) % queueSize; International Islamic University, Islamabad

Rear=(Rear+1) mod Queue Size = (8+1) mod 9 = 0 39 7 6 12 67 Data Structures Lecture 06: Queue 7 6 12 67 1 2 Front=5 Rear=8 3 4 5 6 7 8 Enqueue 39 Rear=(Rear+1) mod Queue Size = (8+1) mod 9 = 0 39 7 6 12 67 1 2 Front=5 Rear=0 3 4 5 6 7 8 International Islamic University, Islamabad

Lecture 06: Queue Data Structures Implementation class IntQueue { private: int *queueArray; int queueSize; int front; int rear; int numItems; public: IntQueue(int); ~IntQueue(void); void enqueue(int); int dequeue(void); bool bool void isEmpty(void); isFull(void); clear(void); }; Note, the member function clear, which clears the queue by resetting the front and rear indices, and setting the numItems to 0. International Islamic University, Islamabad

IntQueue::IntQueue(int s) //constructor Lecture 06: Queue Data Structures IntQueue::IntQueue(int s) //constructor { queueArray = new int[s]; queueSize = s; front = -1; rear = -1; numItems = 0; } IntQueue::~IntQueue(void) //destructor delete [] queueArray; International Islamic University, Islamabad

//******************************************** Lecture 06: Queue Data Structures //******************************************** // Function enqueue inserts the value in num * * // at the rear of the queue. //******************************************** void IntQueue::enqueue(int num) { if (isFull()) cout << "The else { // Calculate rear = (rear queue is full.\n"; the new rear position + 1) % queueSize; // Insert new item queueArray[rear] = num; // Update item count numItems++; } International Islamic University, Islamabad

Lecture 06: Queue Data Structures //********************************************* // Function dequeue removes the value at the * // front of the queue, and copies t into num. * int IntQueue::dequeue(void) { if (isEmpty()) cout << else { // Move front = "The queue is empty.\n"; front (front + 1) % queueSize; item // Retrieve the front int num = queueArray[front]; // Update item count numItems--; } return num; International Islamic University, Islamabad

Lecture 06: Queue Data Structures //********************************************* // Function isEmpty returns true if the queue * // is empty, and false otherwise. * bool IntQueue::isEmpty(void) { if (numItems) return false; else return true; } International Islamic University, Islamabad

//******************************************** Lecture 06: Queue Data Structures //******************************************** // Function isFull returns true if the queue * // is full, and false otherwise. * bool IntQueue::isFull(void) { if (numItems < queueSize) return false; else return true; } International Islamic University, Islamabad

//******************************************* Lecture 06: Queue Data Structures //******************************************* // Function clear resets the front and rear * // indices, and sets numItems to 0. * void IntQueue::clear(void) { front = - 1; rear = - 1; numItems = 0; } International Islamic University, Islamabad

//Program demonstrating the IntQueue class Lecture 06: Queue Data Structures //Program demonstrating the IntQueue class void main(void) { IntQueue iQueue(5); cout << "Enqueuing 5 items...\n"; // Enqueue 5 items. for (int x = 0; x < 5; x++) iQueue.enqueue(x); // Attempt to enqueue a 6th item. cout << "Now attempting to iQueue.enqueue(5); // Deqeue and retrieve all cout << "The values in the while (!iQueue.isEmpty()) { int value; enqueue again...\n"; items in the queue queue were:\n"; value=iQueue.dequeue(); cout << value << endl; } International Islamic University, Islamabad

Program Output Lecture 06: Queue Data Structures Enqueuing 5 items... Now attempting to enqueue again... The queue is full. The 0 values in the queue were: 1 2 3 4 International Islamic University, Islamabad