Data Structures - Lecture 6 [queues]

Queues
Muhammad Hammad Waseem
m.hammad.wasim@gmail.com

Introduction to the Queue
• Like a stack, a queue (pronounced "cue") is a data structure that holds
a sequence of elements.
• A queue, however, provides access to its elements in first-in, first-out
(FIFO) order.
• The elements in a queue are processed like customers standing in a
grocery check-out line: the first customer in line is the first one
served.

Example Applications of Queues
• In a multi-user system, a queue is used to hold print jobs submitted
by users , while the printer services those jobs one at a time.
• Communications software also uses queues to hold information
received over networks and dial-up connections. Sometimes
information is transmitted to a system faster than it can be processed,
so it is placed in a queue when it is received.

Static and Dynamic Queues
• Just as stacks are implemented as arrays or linked lists, so are queues.
• Dynamic queues offer the same advantages over static queues that
dynamic stacks offer over static stacks.
Note: We’ll implement Stack and Queues using linked lists after studying Linked List data structures

Queue Operations
• Think of queues as having a front and a rear. This is illustrated in
Figure.

Queue Operations
• The two primary queue operations are
• enqueuing and
• dequeuing.
• To enqueue means to insert an element at te rear of a queue.
• To dequeue means to remove an element from the front of a queue.

Queue Operations
• Suppose we have an empty static integer queue that is capable of
holding a maximum of three values. With that queue we execute the
following enqueue operations.
Enqueue(3);
Enqueue(6);
Enqueue(9);

Queue Operations
• Figure illustrates the state of the queue after
each of the enqueue operations.

Queue Operations
• Now let's see how dequeue operations are
performed.
• Figure illustrates the state of the queue after
each of three consecutive dequeue operations.
• When the last deqeue operation is performed
in the illustration, the queue is empty. An
empty queue can be signified by setting both
front and rear indices to –1.

Contents of IntQueue.h
class IntQueue
{
private:
int *queueArray;
int queueSize;
int front;
int rear;
int numItems;
public:
IntQueue(int);
~IntQueue(void);
void enqueue(int);
void dequeue(int &);
bool isEmpty(void);
bool isFull(void);
void clear(void);
};

Contents of IntQueue.cpp
#include <iostream.h>
#include "IntQueue.h“
// ******Constructor*******
IntQueue::IntQueue(int s)
{
queueArray = new int[s];
queueSize = s;
front = 0;
rear = 0;
numItems = 0;
}
// *******Destructor*******
IntQueue::~IntQueue(void)
{
delete [] queueArray;
}

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

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

//*********************************************
// Function isEmpty returns true if the queue *
// is empty, and false otherwise. *
//*********************************************
bool IntQueue::isEmpty(void)
{
bool status;
if (numItems)
status = false;
else
status = true;
return status;
}

//********************************************
// Function isFull returns true if the queue *
// is full, and false otherwise. *
//********************************************
bool IntQueue::isFull(void)
{
bool status;
if (numItems < queueSize)
status = false;
else
status = true;
return status;
}

//*******************************************
// Function clear resets the front and rear *
// indices, and sets numItems to 0. *
//*******************************************
void IntQueue::clear(void)
{
front = queueSize - 1;
rear = queueSize - 1;
numItems = 0;
}

Program: 1
// This program demonstrates the IntQeue class
#include <iostream.h>
#include "intqueue.h“
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 enqueue again...n";
iQueue.enqueue(5);

Program: 1 (continued)
// Deqeue and retrieve all items in the queue
cout << "The values in the queue were:n";
while (!iQueue.isEmpty())
{
int value;
iQueue.dequeue(value);
cout << value << endl;
}
}
Program Output
Enqueuing 5 items...
Now attempting to enqueue again...
The queue is full.
The values in the queue were:
0

Data Structures - Lecture 6 [queues]

More Related Content

What's hot (20)

Viewers also liked (11)

Similar to Data Structures - Lecture 6 [queues] (20)

More from Muhammad Hammad Waseem (20)

Recently uploaded (20)

Data Structures - Lecture 6 [queues]