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

2. 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

3. 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

4. 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

5. 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

6. Lecture 06: Queue Data Structures
International Islamic University, Islamabad

7. . 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

8. . 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

9. . . . 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

10. 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

11. 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

12. 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

13. 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

14. 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

15. 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

16. 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

17. 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

18. 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

19. 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
How can we insert more elements? Rear index can
not move beyond the last element….
International Islamic University, Islamabad

20. Drawbacks of Linear Queue

21. 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

22. 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

23. 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

24. 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

25. //********************************************
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

26. 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

27. 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

28. //********************************************
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

29. //*******************************************
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

30. //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

31. 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