0% found this document useful (0 votes)
125 views

Lecture5 Csc0015 Module5 Week5

The document discusses queues and their implementation. It begins by describing queues as first-in, first-out (FIFO) data structures and provides examples of their use in printing jobs and network communications. It then covers implementing queues as both static arrays and dynamic linked lists, describing the key operations of enqueue and dequeue. Code snippets are provided for C++ classes demonstrating static and dynamic queue implementations.

Uploaded by

NoLife AJ
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
125 views

Lecture5 Csc0015 Module5 Week5

The document discusses queues and their implementation. It begins by describing queues as first-in, first-out (FIFO) data structures and provides examples of their use in printing jobs and network communications. It then covers implementing queues as both static arrays and dynamic linked lists, describing the key operations of enqueue and dequeue. Code snippets are provided for C++ classes demonstrating static and dynamic queue implementations.

Uploaded by

NoLife AJ
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 49

MODULE 5

Queues
Module 5A

Queue ADT & Its


Operations
• Learn about queues
• Learn about different operations on
queues
• The Queue ADT
• Applications of Queue
• Types of Queue
• Queue Operations
• 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.
• 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.
• 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.
• Think of queues as having a front and a rear. This
is illustrated below:
• The two primary queue operations are
enqueuing and dequeuing.
• To enqueue means to insert an element at the
rear of a queue.
• To dequeue means to remove an element
from the front of a queue.
• 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);
• The figure on the
right illustrates the
state of the queue
after each of the
enqueue
operations.
• Now let's see how dequeue
operations are performed. The
figure on the right illustrates
the state of the queue after
each of three consecutive
dequeue operations.
• When the last dequeue
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.
• Wittenberg, Lee.(2018). Data structures and algorithms in C++. s.l.: Mercury
Learning
• Baka, Benjamin(2017). Python data structures and algorithms : improve the
performance and speed of your applications. Birmingham, U.K : Packt
Publishing
• Downey, Allen.(2017). Think data structures : algorithms and information
retrieval in Java. Sebastopol, CA: O'Reilly
• Chang, Kung-Hua(2017). Data Structures Practice Problems for C++
Beginners. S.l : Simple and Example
• Hemant Jain(2017). Problem Solving in Data Structures & Algorithms Using
C++: Programming Interview Guide. USA: CreateSpace Independent
Publishing Platform
• Malik, D.S. (2018). C++ Programming: Program Design Including Data
Structures. USA: Cengage Learning
MODULE 5
Queues
Module 5B

Static & Dynamic


Queue
• Understand how to implement a
static and dynamic queue
• Static Queue
• Dynamic Queue
class IntQueue
{
private:
int *queueArray;
int queueSize;
int front;
int rear;
int numItems;
public:
IntQueue(int);
~IntQueue();
void enqueue(int);
void dequeue(int &);
bool isEmpty();
bool isFull();
void clear();
}; Contents of IntQueue.cpp
#include <iostream>
#include "IntQueue.h“ //*************************
using namespace std; // Destructor *
//************************* //*************************
// Constructor *
//************************* IntQueue::~IntQueue()
{
delete [] queueArray;
IntQueue::IntQueue(int s) }
{
queueArray = new int[s];
queueSize = s;
front = -1;
rear = -1;
numItems = 0;
}
Contents of IntQueue.cpp
//********************************************
// 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++;
}
}
Contents of IntQueue.cpp
//*********************************************
// 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--;
}
}
Contents of IntQueue.cpp
//*********************************************
// Function isEmpty returns true if the queue *
// is empty, and false otherwise. *
//*********************************************

bool IntQueue::isEmpty()
{
bool status;

if (numItems)
status = false;
else
status = true;

return status;
}
Contents of IntQueue.cpp
//********************************************
// Function isFull returns true if the queue *
// is full, and false otherwise. *
//********************************************

bool IntQueue::isFull()
{
bool status;

if (numItems < queueSize)


status = false;
else
status = true;

return status;
}

Contents of IntQueue.cpp
//*******************************************
// Function clear resets the front and rear *
// indices, and sets numItems to 0. *
//*******************************************

void IntQueue::clear()
{
front = queueSize - 1;
rear = queueSize - 1;
numItems = 0;
}

Contents of IntQueue.cpp
Main Program
// This program demonstrates the IntQeue class
#include <iostream>
#include "intqueue.h“
using namespace std;

int main()
{
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);
Main Program
// 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
• A dynamic queue starts as an empty linked list.
• With the first enqueue operation, a node is added,
which is pointed to by front and rear pointers.
• As each new item is added to the queue, a new node
is added to the rear of the list, and the rear pointer is
updated to point to the new node.
• As each item is dequeued, the node pointed to by the
front pointer is deleted, and front is made to point
to the next node in the list.
• The figure below shows the structure of a dynamic
queue.
Contents of DynIntQueue.cpp
#include <iostream>
#include "dynintqueue.h“ //************************
using namespace std; // Destructor *
//************************
//************************
DynIntQueue::~DynIntQueue()
// Constructor *
{
//************************
clear();
}
DynIntQueue::DynIntQueue(void)
{
front = NULL;
rear = NULL;
numItems = 0;
}
Contents of DynIntQueue.cpp
//********************************************
// 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++;
}
Contents of DynIntQueue.cpp
//**********************************************
// Function dequeue removes the value at the *
// front of the queue, and copies it into num. *
//**********************************************

void DynIntQueue::dequeue(int &num)


{
QueueNode *temp;

if (isEmpty())
cout << "The queue is empty.\n";
else
{
num = front->value;
temp = front->next;
delete front;
front = temp;
numItems--;
}
}
Contents of DynIntQueue.cpp
//*********************************************
// Function isEmpty returns true if the queue *
// is empty, and false otherwise. *
//*********************************************

bool DynIntQueue::isEmpty()
{
bool status;

if (numItems)
status = false;
else
status = true;

return status;
}
Contents of DynIntQueue.cpp
//********************************************
// Function clear dequeues all the elements *
// in the queue. *
//********************************************

void DynIntQueue::clear()
{
int value; // Dummy variable for dequeue

while(!isEmpty())
dequeue(value);
}
Main Program
// This program demonstrates the DynIntQeue class
#include <iostream>
#include "dynintqueue.h“
using namespace std;
int main()
{
DynIntQueue iQueue;

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;
iQueue.dequeue(value);
cout << value << endl;
}
}
Main Program
Program Output
Enqueuing 5 items...
The values in the queue
were:
0
1
2
3
4
• Wittenberg, Lee.(2018). Data structures and algorithms in C++. s.l.: Mercury
Learning
• Baka, Benjamin(2017). Python data structures and algorithms : improve the
performance and speed of your applications. Birmingham, U.K : Packt
Publishing
• Downey, Allen.(2017). Think data structures : algorithms and information
retrieval in Java. Sebastopol, CA: O'Reilly
• Chang, Kung-Hua(2017). Data Structures Practice Problems for C++
Beginners. S.l : Simple and Example
• Hemant Jain(2017). Problem Solving in Data Structures & Algorithms Using
C++: Programming Interview Guide. USA: CreateSpace Independent
Publishing Platform
• Malik, D.S. (2018). C++ Programming: Program Design Including Data
Structures. USA: Cengage Learning
MODULE 5
Queues
Module 5C

Queue STL
• Know the existing C++ STL
containers for queues: the queue
and dequeue
• The STL dequeue Container
• The STL queue Container
• A deque (pronounced "deck" or "deek") is a
double-ended queue. It similar to a vector, but
allows efficient access to values at both the front
and the rear.
• The queue ADT is like the the stack ADT: it is
actually a container adapter.
• Programs that use the deque ADT must include the
deque header file.
Sample Program 1
// This program demonstrates the STL deque
// container.
#include <iostream>
#include <deque>
using namespace std;

int main()
{
int x;
deque<int> iDeque;

cout << "I will now enqueue items...\n";


for (x = 2; x < 8; x += 2)
{
cout << "Pushing " << x << endl;
iDeque.push_back(x);
}
cout << "I will now dequeue items...\n";
for (x = 2; x < 8; x += 2)
{
cout << "Popping " << iDeque.front() << endl;
iDeque.pop_front();
}
}
Sample Program 1
Program Output
I will now enqueue items...
Pushing 2
Pushing 4
Pushing 6
I will now dequeue items...
Popping 2
Popping 4
Popping 6
• The queue container adapter can be
built upon vectors, lists, or
deques.
• By default, it uses deque as its base.
• The queue insertion and removal operations are
the same as those supported by the stack ADT:
push, pop, and top.
• The queue version of push always inserts an
element at the rear of the queue.
• The queue version of pop always removes an
element from the structure's front.
• The top function returns the value of the element
at the front of the queue.
Sample Program 2
// This program demonstrates the STL queue
// container adapter.
#include <iostream>
#include <queue>
using namespace std;
int main()
{
int x;
queue<int> iQueue;

cout << "I will now enqueue items...\n";


for (x = 2; x < 8; x += 2)
{
cout << "Pushing " << x << endl;
iQueue.push(x);
}
cout << "I will now dequeue items...\n";
for (x = 2; x < 8; x += 2)
{
cout << "Popping " << iQueue.front() << endl;
iQueue.pop();
}
}
Sample Program 2
Program Output

I will now enqueue items...


Pushing 2
Pushing 4
Pushing 6
I will now dequeue items...
Popping 2
Popping 4
Popping 6
• Wittenberg, Lee.(2018). Data structures and algorithms in C++. s.l.: Mercury
Learning
• Baka, Benjamin(2017). Python data structures and algorithms : improve the
performance and speed of your applications. Birmingham, U.K : Packt
Publishing
• Downey, Allen.(2017). Think data structures : algorithms and information
retrieval in Java. Sebastopol, CA: O'Reilly
• Chang, Kung-Hua(2017). Data Structures Practice Problems for C++
Beginners. S.l : Simple and Example
• Hemant Jain(2017). Problem Solving in Data Structures & Algorithms Using
C++: Programming Interview Guide. USA: CreateSpace Independent
Publishing Platform
• Malik, D.S. (2018). C++ Programming: Program Design Including Data
Structures. USA: Cengage Learning

You might also like