Chapter 5

Queue and its Application

1
 Introduction
• Queue is a linear data structure which enables insert
operations to be performed at one end called REAR
and delete operations to be performed at another end
called FRONT.
• Queue follows the First In First Out (FIFO) rule - i.e.,
the data item stored first will be accessed first.

• For example:
• people waiting in line for a FRON
rail ticket form a queue. T
REA 2
R
 Introduction
• FIFO Principle of Queue:
– A Queue is like a line waiting to purchase tickets, where the
first person in line is the first person served. (i.e., First come
first serve).
– Position of the entry in a queue ready to be served, that is,
the first entry that will be removed from the queue, is called
the front of the queue (sometimes, head of the queue),
similarly, the position of the last entry in the queue, that is,
the one most recently added, is called the rear (or the tail)
of the queue.

3
 Basic Operations of Queue
• Enqueue(): Add an element to the end of the queue.

• Dequeue(): Remove an element from the front of the

queue.

• IsEmpty(): Check if the queue is empty.

• IsFull(): Check if the queue is full.

• Peek(): Get the value of the front of the queue without

removing it.

4
Basic Operations of Queue: peek() & isfull()
peek(): Algorithm: Implementation:
int peek()
begin procedure peek
{
return queue[front]
return queue[front];
end procedure
}

isfull(): Algorithm: Implementation:

begin procedure isfull bool isfull()
if rear equals to {
MAXSIZE if(rear == MAXSIZE - 1)
return true return true;
else else
return false return false;
endif }
end procedure 5
 Basic Operations of Queue: isempty()
Algorithm:
begin procedure isempty
if front is less than MIN OR front is greater than rear
return true
else
return false
endif
end procedure
Implementation:
bool isempty() If the value of front is less
{ than MIN or 0, it tells that
if(front < 0 || front > rear) the queue is not yet
initialized, hence empty.
return true;
else
return false;
} 6
 Working of Queue
 Queue operations work as follows:
• Two pointers, FRONT and REAR, are required
• FRONT track the first element of the queue
• REAR track the last element of the queue
• Initially, set value of FRONT and REAR to -1

7
 Basic Operations of Queue: enqueue()
• The following steps should be taken to enqueue
(insert) data into a queue:
1. Check if the queue is full or not
2. If the queue is full, produce overflow error and exit.
3. If the queue is not full, increment rear pointer to point the
next empty space.
4. Add data element to the queue location, where the rear is
pointing.
5. return success.

8
 Basic Operations of Queue: enqueue()
Algorithm Implementation

begin procedure enqueue(data) int enqueue(int data)

if queue is full {
return overflow if(isfull())
endif return 0;
rear ← rear + 1 rear = rear + 1;
queue[rear] ← data queue[rear] = data;
return true return 1;
end procedure }

9
 Basic Operations of Queue: dequeue()
• The following steps are taken to perform dequeue
operation:
1. Check if the queue is empty or not.
2. If the queue is empty, produce underflow error and exit.
3. If the queue is not empty, access the data where front is
pointing.
4. Increment front pointer to point to the next available data
element.
5. Return success.

10
 Basic Operations of Queue: dequeue()
Algorithm Implementation

begin procedure dequeue int dequeue()

if queue is empty {
return underflow if(isempty())
endif return 0;
data = queue[front] int data = queue[front];
front ← front + 1 front = front + 1;
return true return data;
end procedure }

11
 Types of Queue
In Linear Queue, an insertion
takes place from one end while the
deletion occurs from another end.
It is a special type of queue
data structure in which
every element has a
priority associated with it.

It is similar to the linear Queue

except that the last element of
the queue is connected to the
first element.
In Double Ended Queue, insertion and
deletion can be done from both ends of
the queue either from the front or rear.

12
 Ways to implement the queue
• There are two ways of implementing the Queue: Array
and Linked list.
Using Array
void enqueue(int queue[], int item) int dequeue (int queue[], int item)
{ {
if (isfull()) if (isempty())
{ {
cout<<"overflow"; cout<<"underflow";
} }
else else
{ {
rear = rear + 1; item = queue[front];
queue[rear]=item; front = front + 1;
} return item;
} }
}
13
 Ways to implement the queue: using Linked list
void enqueue(struct node *ptr, int item) { void dequeue (struct node *ptr)
ptr = (struct node *) malloc (sizeof(struct node) {
); if(ptr == NULL) { if(front == NULL)
cout<<"\nOVERFLOW\n"; {
return; cout<<"\nUNDERFLOW\n";
} return;
else { }
ptr -> data = item; else
if(front == NULL) { {
front = ptr; ptr = front;
rear = ptr; front = front -> next;
front -> next = NULL; delete ptr;
rear -> next = NULL; }
} }
else {
rear -> next = ptr;
rear = ptr;
rear->next = NULL;
}
}
} 14
 Applications of Queue
• In CPU scheduling and Disk Scheduling.
• In asynchronous transfer of data (where data is not
being transferred at the same rate between two
processes) for eg. pipes, file IO, sockets.
• In operating systems for handling interrupts.
• As buffers in most of the applications like MP3 media
player, CD player, etc.
• To maintain the play list in media players in order to
add and remove the songs from the play-list.
• Center phone systems use Queues to hold people
calling them in order.
15
Thank You

Question?

16