Queue

• Queue is an abstract data structure, somewhat similar to Stacks.

• Unlike stacks, a queue is open at both its ends.

• One end is always used to insert data (enqueue) and the other is used
to remove data (dequeue).

• Queue follows First-In-First-Out methodology, i.e., the data item

stored first will be accessed first.
Example

• A real-world example of queue can be a single-lane one-way road,

where the vehicle enters first, exits first.
• More real-world examples can be seen as queues at the ticket
windows and bus-stops.
Queue Representation

• A queue can be defined as an ordered list which enables insert

operations to be performed at one end called REAR and delete
operations to be performed at another end called FRONT.
• Queue is referred to be as First In First Out list.
• For example, people waiting in line for a rail ticket form a queue.
Operations on Queue

• Enqueue:
• The enqueue operation is used to insert the element at the rear end of the queue. It
returns void.

• Dequeue:
• The dequeue operation performs the deletion from the front-end of the queue. It also
returns the element which has been removed from the front-end. It returns an integer
value. The dequeue operation can also be designed to void.

• Queue overflow (isfull):

• When the Queue is completely full, then it shows the overflow condition.

• Queue underflow (isempty):

• When the Queue is empty, i.e., no elements are in the Queue then it throws the
underflow condition.
Implementation of Queue

• Sequential allocation:
• The sequential allocation in a Queue can be implemented using an array.

• Linked list allocation:

• The linked list allocation in a Queue can be implemented using a linked list.
Array representation of Queue

• There are two variables i.e. front and rear, that are implemented in the case
of every queue.

• Front and rear variables point to the position from where insertions and
deletions are performed in a queue.

• Initially, the value of front and rear is -1 which represents an empty queue.

• Array representation of a queue containing 5 elements along with the

respective values of front and rear,
Continue

• The queue of characters forming the English word "HELLO".

• Since, No deletion is performed in the queue till now, therefore the value of
front remains -1 .
• However, the value of rear increases by one every time an insertion is
performed in the queue.
• After inserting an element into the queue shown in the above figure, the
queue will look like given in figure.
• The value of rear will become 5 while the value of front remains same.
Insertion
Deletion
• After deleting an element, the value of front will increase from -1 to 0.
Algorithm to insert any element in a queue

• Check if the queue is already full by comparing rear to max - 1. if so,

then return an overflow error.

• If the item is to be inserted as the first element in the list, in that case
set the value of front and rear to 0 and insert the element at the rear
end.

• Otherwise keep increasing the value of rear and insert each element
one by one having rear as the index.
Algorithm
Step 1: IF REAR = MAX - 1
Write OVERFLOW
Go to step
[END OF IF]
Step 2: IF FRONT = -1 and REAR = -1
SET FRONT = REAR = 0
ELSE
SET REAR = REAR + 1
[END OF IF]
Step 3: Set QUEUE[REAR] NUM
Step 4: EXIT
Algorithm to delete an element from the queue

• If, the value of front is -1 or value of front is greater than rear , write
an underflow message and exit.

• Otherwise, keep increasing the value of front and return the item
stored at the front end of the queue at each time.
Algorithm
Step 1: IF FRONT = -1 or FRONT > REAR
Write UNDERFLOW
ELSE
SET VAL QUEUE[FRONT]
SET FRONT = FRONT + 1
[END OF IF]
Step 2: EXIT
Applications of Queue

• Serving requests on a single shared resource, like a printer, CPU task

scheduling etc.

• In real life scenario, Call Center phone systems uses Queues to hold
people calling them in an order, until a service representative is free.

• Handling of interrupts in real-time systems. The interrupts are

handled in the same order as they arrive i.e First come first served.
Recursion (Stack Application)
• The process in which a function calls itself directly or indirectly is
called recursion and the corresponding function is called as recursive
function.

• Using recursive algorithm, certain problems can be solved quite easily.

Examples of such problems are Towers of Hanoi (TOH),
Inorder/Preorder/Postorder Tree Traversals, DFS of Graph, etc.
Continue
• When printFun(3) is called from main(), memory is allocated to
printFun(3) and a local variable test is initialized to 3 and statement 1
to 4 are pushed on the stack.
• It first prints ‘3’. In statement 2, printFun(2) is called and memory is
allocated to printFun(2) and a local variable test is initialized to 2 and
statement 1 to 4 are pushed in the stack.
• Similarly, printFun(2) calls printFun(1) and printFun(1) calls
printFun(0). printFun(0) goes to if statement and it return to
printFun(1).
• Remaining statements of printFun(1) are executed and it returns to
printFun(2) and so on. In the output, value from 3 to 1 are printed
and then 1 to 3 are printed.
Types of Queue

• Linear Queue
• Circular Queue
• Priority Queue
• Dequeue
Linear Queue

• In Linear Queue, an insertion takes place from one end while the
deletion occurs from another end.
• The end at which the insertion takes place is known as the rear end,
and the end at which the deletion takes place is known as front end.
• It strictly follows the FIFO rule. The linear Queue can be represented,
as shown in the below figure:
Continue
• The elements are inserted from the rear end, and if we insert more
elements in a Queue, then the rear value gets incremented on every
insertion.
• If we want to show the deletion, then it can be represented as:

• In the above figure, we can observe that the front pointer points to
the next element, and the element which was previously pointed by
the front pointer was deleted.
Drawback
• The major drawback of using a linear Queue is that insertion is done
only from the rear end.

• If the first three elements are deleted from the Queue, we cannot
insert more elements even though the space is available in a Linear
Queue.

• In this case, the linear Queue shows the overflow condition as the
rear is pointing to the last element of the Queue.
Circular Queue

• In Circular Queue, all the nodes are represented as circular.

• It is similar to the linear Queue except that the last element of the
queue is connected to the first element.
•
• It is also known as Ring Buffer as all the ends are connected to
another end.

• A circular queue is similar to a linear queue as it is also based on

the FIFO (First In First Out) principle except that the last position is
connected to the first position in a circular queue that forms a
circle.

• It is also known as a Ring Buffer.

Need of Circular Queue
• The drawback that occurs in a linear queue is overcome by using the
circular queue.

• If the empty space is available in a circular queue, the new element

can be added in an empty space by simply incrementing the value of
rear.
Why was the concept of the circular queue introduced?
• There was one limitation in the array
implementation of Queue.

• If the rear reaches to the end position of the Queue

then there might be possibility that some vacant
spaces are left in the beginning which cannot be
utilized.

• So, to overcome such limitations, the concept of

the circular queue was introduced.
Continue
• As we can see in the above image, the rear is at the last position of the
Queue and front is pointing somewhere rather than the 0th position.
• In the above array, there are only two elements and other three positions
are empty.
• The rear is at the last position of the Queue; if we try to insert the element
then it will show that there are no empty spaces in the Queue.
• There is one solution to avoid such wastage of memory space by shifting
both the elements at the left and adjust the front and rear end accordingly.
• It is not a practically good approach because shifting all the elements will
consume lots of time.
• The efficient approach to avoid the wastage of the memory is to use the
circular queue data structure.
Operations on Circular Queue

• Front:
• It is used to get the front element from the Queue.

• Rear:
• It is used to get the rear element from the Queue.

• enQueue(value):
• This function is used to insert the new value in the Queue. The new element
is always inserted from the rear end.

• deQueue():
• This function deletes an element from the Queue. The deletion in a Queue
always takes place from the front end.
Applications of Circular Queue

• Memory management:
• The circular queue provides memory management. As we have already seen
that in linear queue, the memory is not managed very efficiently. But in case
of a circular queue, the memory is managed efficiently by placing the
elements in a location which is unused.

• CPU Scheduling:
• The operating system also uses the circular queue to insert the processes and
then execute them.

• Traffic system:
• In a computer-control traffic system, traffic light is one of the best examples
of the circular queue. Each light of traffic light gets ON one by one after every
interval of time. Like red light gets ON for one minute then yellow light for
one minute and then green light. After green light, the red light gets ON.
Algorithm to insert an element in a circular queue
Step 1: IF (FRONT == 0 and REAR == N-1) or (FRONT == REAR + 1)
Write " OVERFLOW "
Goto step 4
[End OF IF]

Step 2: IF FRONT = -1 and REAR = -1

SET FRONT = REAR = 0
ELSE IF
REAR = MAX - 1 and FRONT ! = 0
SET REAR = 0
ELSE
SET REAR = (REAR + 1)
[END OF IF]

Step 3: SET QUEUE[REAR] VAL

Step 4: EXIT
Need of Circular Queue
• The drawback that occurs in a linear queue is overcome by using the
circular queue.

• If the empty space is available in a circular queue, the new element

can be added in an empty space by simply incrementing the value of
rear.