Queue Datastructure

1. QUEUES

2. TOPICS COVERED
•Definition of Queue
•Representation of Queue
•Operations of Queue
•Types of Queue
•Applications of Queue

3. INTRODUCTION

4. DEFINITION
• A queue is a FIFO (first-in, first-out) data structure in which the element that is
inserted first is the first one to be taken out.
• A queue is open at both its ends.
• The elements in a queue are added at one end called the rear and removed
from the other end called the front.
• Queues can be implemented by using either arrays or linked lists
• One end is always used to insert data (enqueue) and the other is used to
remove data (dequeue).

5. REPRESENTATION OF QUEUE
OUT 2 3 IN
FRONT
REAR
1
ENQUEUE
DEQUEUE
1 2 3 4

6. OPERATIONS OF QUEUE
• Queue operations may involve initializing or defining the queue, utilizing it, and
then completely erasing it from the memory. the basic operations associated with
queues are,
• enqueue() − add (store) an item to the queue.
• dequeue() − remove (access) an item from the queue.
• peek() − Gets the element at the front of the queue without removing it.
• isfull() − Checks if the queue is full.
• isempty() − Checks if the queue is empty.
• In queue, we always dequeue (or access) data, pointed by front pointer and while
enqueuing (or storing) data in the queue we take help of rear pointer.

7. ENQUEUE
Void Enqueue (int X)
{
if (Rear > = MaxSize)
print(“Queue Overflow”);
else
{
rear = Rear + 1;
Queue[Rear] = X;
}
}
1 2 3 4
FRONT REAR
1 2 3 4 X
REARFRONT

8. DEQUEUE
Void Dequeue ( )
{
if (Front < 0 ) && ( Rear == -1)
print ( “ Queue Underflow”);
else
{
X = Queue[Front];
if( Front == Rear )
{
Front = 0;
Rear = -1;
}
else
Front = Front + 1;
}
}

9. 50
50 60 60
EMPTY QUEUE
0 1 2 3 4
R F Rear = -1 Front = 0
ENQUEUE (50 )
0 1 2 3 4
R, F
0 1 2 3 4
Front Rear ENQUEUE ( 60)
0 1 2 3 4
R, F DEQUEUE( 50 )
0 1 2 3 4
R F Rear = -1 Front = 0
DEQUEUE( 60 )

10. TYPES OF QUEUES
• Double Ended Queue ( Dequeue)
• Circular Queue
• Priority Queue
• Multiple Queue

11. DOUBLE ENDED QUEUE
• Insertion and deletion operations are allowed at both the ends.
• Types are,
• Input restricteddequeue
• Output restricteddequeue
Front End Rear End
10 20 30 40 50 60

12. • Input restricted dequeue
• Insertion allowed at one end and
deletion allowed at both the ends.
• Output restricted dequeue
• Deletion allowed at one end and
insertion allowed at both the ends.

13. CIRCULAR QUEUE
• The insertion of a new element is performed at the very first location of
the queue if the last location of the queue is full, in which the first
element comes just after the last element.
• Advantage:
• it overcomes the problem of unutilized space in linear queues, when it
is implemented as array.

14. Q[1]
Q[2]
Q[3]
Q[4]
Q[5]
Q[6]
Q[7] Q[0]
Front
10
20
30
40
10
20
30
4050
60
70
80
Rear
Front
Rear

15. OPERATIONS OF CIRCULAR QUEUE
• To perform the insertion operation in
the circular queue , the position of the
element is calculated by the relation as,
Rear = ( Rear + 1) % MaxSize
Queue [ Rear ] = Value
To perform the deletion operation ,
the position of the Front pointer is
calculated by the relation,
Value = Cqueue[Front];
Front = (Front +1) % MaxSize;

16. INSERTION
void Cenqueue ( int X )
{
if ( Front == (Rear + 1) % MaxSize
print ( “ Queue is Overflow “ );
else
{
if ( Front == -1)
Front = Rear = 0;
else
Rear = ( Rear + 1) % MaxSize;
Cqueue [ Rear ] = X;
}
}

17. DELETION
Int Dequeue ( )
{
if ( front = = - 1)
print ( “ Queue is underflow “ );
else
{
X = Cqueue [Front];
if ( Front = = Rear )
Front = Rear = – 1;
else
Front = (Front + 1) % MaxSize;
}
return (X);
}

18. PRIORITY QUEUE
• Insertion and deletion can be performed in any position of the queue based
on some priority.
• An element with higher priority is processed before an element with a
lower priority.
• Two elements with the same priority are processed on a first-come-first-
served (FCFS) basis.
• Used to sort the elements using heap sort.

19. APPLICATIONS OF QUEUE
• Batch Processing in operating systems
• Simulation
• Queueing theory
• Computer Networks