Data Structures and Algorithms: Queue

Data Structures and Algorithms
Queue
Lecture 5
Lecture 5
QUEUE ADT And Problem Solving 11

◼Introduction to the Queue data structure
◼Designing a Queue class using dynamic
arrays
◼Linked Queues
Lecture 5
◼An Application of Queues

▪ A simple data container consisting of a linear list
of elements
▪ Access is by position (order of insertion)
▪ Insertions at one end (rear) , deletions at another
end (front)
▪ First In First Out (FIFO) structure
Lecture 5
▪ Two basic operations:

enqueue: add to rear
dequeue: remove from front

4
1 2 3 1 2 3
Enqueue
Lecture 5
1 2 3 4 2 3 4
Dequeue
o Problem of Array representation
o Solution using Circular Array.
o When last array element is reached, we move back to start
o The queue is viewed as a circular array
o To enqueue:
rear = (rear + 1) % size
o To dequeue:
front = (front + 1) % size
Lecture 5
o Both rear and front advance clockwise

Lecture 5
QUEUE ADT And Problem Solving

Fall 2010 Prof. Amr Goneid, AUC
◼Simulation of waiting lines
◼Simulation of serviceable events
◼Job scheduling
◼Input/Output Buffering
Lecture 5

◼ construct: construct an empty queue
◼ queueIsEmpty → bool : return True if queue is
empty
◼ queueIsFull → bool : return True if queue is full
◼ enqueue(el) : add element (el) at the rear
◼ dequeue(el): retrieve and remove the front element
Lecture 5
◼ queueFront(el): retrieve front without removing it

◼ queueLength → int : return the current queue length

◼The queue may be implemented as a
dynamic array.
◼The capacity (MaxSize) will be input as
a parameter to the constructor (default
is 128)
Lecture 5
◼The queue ADT will be implemented as

a template class to allow for different
element types.

// File: Queuet.h
// Queue template class definition
// Dynamic array implementation
#ifndef QUEUET_H
#define QUEUET_H
template <class Type>

Lecture 5
class Queuet
{
public:
Queuet (int nelements = 128); // Constructor

Queuet (const Queuet <Type> &); // Copy Constructor
~Queuet (); // Destructor
QUEUE ADT And Problem Solving10

// Member Functions
void enqueue(Type ); // Add to rear
void dequeue(Type &); // Remove from front
void queueFront(Type &) const; // Retrieve front
bool queueIsEmpty() const; // Test for Empty queue
bool queueIsFull() const; // Test for Full queue
int queueLength() const; // Queue Length
private:
Lecture 5
Type *queue; // pointer to dynamic array

int front, rear, count, MaxSize;
};
#endif // QUEUET_H
#include "Queuet.cpp"

Stack::Stack(const Stack& other)
{
stkLength = other. stkLength;
stkSize = other.stkSize;
stkArray = new int[stkLength];
Lecture 5
for (int i = 0; i < stkSize; i++)

stkArray[i] = other.stkArray[i];
stkTop = other.stkTop;
}
Fall 2010 Prof. Amr Goneid, AUC
template<typename Type >
bool queue< Type>::enqueue(const Type & item)
{
if (count == array_size) return false;
array[tail] = item;
Lecture 5
tail = (tail + 1) % array_size;

count++;
return true;
}

Fall 2010
◼A Queue can be implemented as a linked
structure.
◼Requires more space than array
implementations, but more flexible in size.
◼Two pointers are needed: front for dequeue
Lecture 5
and rear for enqueue

// The linked structure for a node can be
// specified as a Class in the private part of
// the main queue class.
class node // Hidden from user
{
public:
Type e; // stack element
node *next; // pointer to next node
}; // end of class node declaration
Lecture 5
typedef node * NodePointer;
NodePointer front , rear; // pointers

rear
front
New
Lecture 5
enqueue(v):
NodePointer pnew = new node;
1 pnew->e = v;
pnew pnew->next = NULL;
rear->next = pnew;
rear = pnew;

1 cursor rear
front
2
Lecture 5
dequeue(&v):
v = front->e;
cursor = front;
front = front->next;
delete cursor;
// File: QueueL.h
// Linked List Queue class definition
#ifndef QUEUEL_H
#define QUEUEL_H
class QueueL
{
Lecture 5
public:
QueueL(); // Constructor
~QueueL(); // Destructor
void enqueue(Type ); // Add to rear

void dequeue(Type &); // Remove from front
void queueFront(Type &) const; // retrieve front
bool queueIsEmpty() const; // Test for Empty queue
int queueLength() const; // Queue Length
private:
// Node Class
class node
Lecture 5
{
public:
Type e; // queue element
node *next; // pointer to next node
}; // end of class node declaration

typedef node * NodePointer;
NodePointer front , rear; // Pointers

int count; // length
};
#endif // QUEUEL_H
Lecture 5
#include "QueueL.cpp"

void QueueL<Type>::enqueue(Type v)
{
NodePointer pnew = new node;
pnew->e = v; pnew->next = NULL;
if(queueIsEmpty())
{
Lecture 5
front = pnew; rear = pnew;}

else
{rear->next = pnew; rear = pnew;}
count++;
}
void QueueL<Type>::dequeue(Type &v)
{ NodePointer cursor;
if(queueIsEmpty()) cout<<” Queue is empty “<<endl;
else {
V = front-> e;
cursor = front;
Lecture 5
front =front->next;
delete cursor;
count--;
}
}
void QueueL<Type>::queueFront(Type &v)
const
{
if(queueIsEmpty())
cout << "Queue is Empty" << endl;
Lecture 5
else { v = front->e; }
}

• Implement Queue using ADT of
linked List
• Implement Queue using ADT of
circular dynamic array
Lecture 5

Data Structures and Algorithms: Queue

Uploaded by

Copyright:

Available Formats

Data Structures and Algorithms: Queue

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Data Structures and Algorithms: Queue

Uploaded by

Copyright:

Available Formats

Data Structures and Algorithms

QUEUE ADT And Problem Solving 11

◼An Application of Queues

QUEUE ADT And Problem Solving 2

▪ Two basic operations:

QUEUE ADT And Problem Solving 3

o Both rear and front advance clockwise

QUEUE ADT And Problem Solving 5

QUEUE ADT And Problem Solving

QUEUE ADT And Problem Solving 7

◼ queueFront(el): retrieve front without removing it

QUEUE ADT And Problem Solving 8

◼The queue ADT will be implemented as

QUEUE ADT And Problem Solving 9

template <class Type>

Queuet (int nelements = 128); // Constructor

QUEUE ADT And Problem Solving10

Type *queue; // pointer to dynamic array

QUEUE ADT And Problem Solving 11

for (int i = 0; i < stkSize; i++)

tail = (tail + 1) % array_size;

QUEUE ADT And Problem Solving

and rear for enqueue

QUEUE ADT And Problem Solving14

typedef node * NodePointer;

NodePointer front , rear; // pointers

QUEUE ADT And Problem Solving15

QUEUE ADT And Problem Solving16

QUEUE ADT And Problem Solving18

QUEUE ADT And Problem Solving19

NodePointer front , rear; // Pointers

QUEUE ADT And Problem Solving20

front = pnew; rear = pnew;}

QUEUE ADT And Problem Solving 23

QUEUE ADT And Problem Solving

You might also like