Queue

1. 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.

2. Queue is referred to be as First In First Out list.

3. For example, people waiting in line for a rail ticket form a queue.

Applications of Queue
Due to the fact that queue performs actions on first in first out basis which is quite fair for the ordering of actions. There
are various applications of queues discussed as below.

Difference between JDK, JRE, and JVM

 1. Queues are widely used as waiting lists for a single shared resource like printer, disk, CPU.
2. Queues are used in asynchronous transfer of data (where data is not being transferred at the same rate between
two processes) for eg. pipes, file IO, sockets.
3. Queues are used as buffers in most of the applications like MP3 media player, CD player, etc.
4. Queue are used to maintain the play list in media players in order to add and remove the songs from the play-list.
5. Queues are used in operating systems for handling interrupts.

Types of Queues
Before understanding the types of queues, we first look at 'what is Queue'.

What is the Queue?

A queue in the data structure can be considered similar to the queue in the real-world. A queue is a data structure in
which whatever comes first will go out first. It follows the FIFO (First-In-First-Out) policy. In Queue, the insertion is done
from one end known as the rear end or the tail of the queue, whereas the deletion is done from another end known as the
front end or the head of the queue. In other words, it can be defined as a list or a collection with a constraint that the
insertion can be performed at one end called as the rear end or tail of the queue and deletion is performed on another
end called as the front end or the head of the queue.
Operations on Queue
There are two fundamental operations performed on a Queue:

o Enqueue: The enqueue operation is used to insert the element at the rear end of the queue. It returns void.
o 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.
o Peek: This is the third operation that returns the element, which is pointed by the front pointer in the queue but does not
delete it.
o Queue overflow (isfull): When the Queue is completely full, then it shows the overflow condition.
o Queue underflow (isempty): When the Queue is empty, i.e., no elements are in the Queue then it throws the underflow
condition.

A Queue can be represented as a container opened from both the sides in which the element can be enqueued from one
side and dequeued from another side as shown in the below figure:

C++ vs Java
Implementation of Queue
There are two ways of implementing the Queue:

o Sequential allocation: The sequential allocation in a Queue can be implemented using an array.
For more details, click on the below link: https://www.javatpoint.com/array-representation-of-queue
o Linked list allocation: The linked list allocation in a Queue can be implemented using a linked list.
For more details, click on the below link: https://www.javatpoint.com/linked-list-implementation-of-queue

What are the use cases of Queue?

Here, we will see the real-world scenarios where we can use the Queue data structure. The Queue data structure is mainly
used where there is a shared resource that has to serve the multiple requests but can serve a single request at a time. In
such cases, we need to use the Queue data structure for queuing up the requests. The request that arrives first in the
queue will be served first. The following are the real-world scenarios in which the Queue concept is used:

o Suppose we have a printer shared between various machines in a network, and any machine or computer in a network can
send a print request to the printer. But, the printer can serve a single request at a time, i.e., a printer can print a single
document at a time. When any print request comes from the network, and if the printer is busy, the printer's program will put
the print request in a queue.
o . If the requests are available in the Queue, the printer takes a request from the front of the queue, and serves it.
o The processor in a computer is also used as a shared resource. There are multiple requests that the processor must execute,
but the processor can serve a single request or execute a single process at a time. Therefore, the processes are kept in a
Queue for execution.
Types of Queue
There are four types of Queues:

o 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:

The above figure shows that 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.

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.

o 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.
The circular queue can be represented as:
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.

To know more about circular queue, click on the below link: https://www.javatpoint.com/circular-queue

o Priority Queue
A priority queue is another special type of Queue data structure in which each element has some priority associated with
it. Based on the priority of the element, the elements are arranged in a priority queue. If the elements occur with the same
priority, then they are served according to the FIFO principle.

In priority Queue, the insertion takes place based on the arrival while the deletion occurs based on the priority. The priority
Queue can be shown as:

The above figure shows that the highest priority element comes first and the elements of the same priority are arranged
based on FIFO structure.

o Deque

Both the Linear Queue and Deque are different as the linear queue follows the FIFO principle whereas, deque does not
follow the FIFO principle. In Deque, the insertion and deletion can occur from both ends.

Array representation of Queue

We can easily represent queue by using linear arrays. 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 queue is -1 which represents an empty queue. Array representation of a queue
containing 5 elements along with the respective values of front and rear, is shown in the following figure.
The above figure shows 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 something like following. The value of rear will become 5 while the value of front remains same.
After deleting an element, the value of front will increase from -1 to 0. however, the queue will look something like
following.
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

o Step 1: IF REAR = MAX - 1

Write OVERFLOW
 Go to step
[END OF IF]
o Step 2: IF FRONT = -1 and REAR = -1
SET FRONT = REAR = 0
ELSE
SET REAR = REAR + 1
[END OF IF]
o Step 3: Set QUEUE[REAR] = NUM
o Step 4: EXIT

C Function

1. void insert (int queue[], int max, int front, int rear, int item)
2. {
3. if (rear + 1 == max)
4. {
5. printf("overflow");
6. }
7. else
8. {
9. if(front == -1 && rear == -1)
10. {
11. front = 0;
12. rear = 0;
13. }
14. else
15. {
16. rear = rear + 1;
17. }
18. queue[rear]=item;
19. }
20. }

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

o Step 1: IF FRONT = -1 or FRONT > REAR

Write UNDERFLOW
ELSE
SET VAL = QUEUE[FRONT]
SET FRONT = FRONT + 1
[END OF IF]
o Step 2: EXIT

C Function
1. int delete (int queue[], int max, int front, int rear)
2. {
3. int y;
4. if (front == -1 || front > rear)
5.
6. {
7. printf("underflow");
8. }
9. else
10. {
11. y = queue[front];
12. if(front == rear)
13. {
14. front = rear = -1;
15. else
16. front = front + 1;
17.
18. }
19. return y;
20. }
21. }

Menu driven program to implement queue using array

1. #include<stdio.h>
2. #include<stdlib.h>
3. #define maxsize 5
4. void insert();
5. void delete();
6. void display();
7. int front = -1, rear = -1;
8. int queue[maxsize];
9. void main ()
10. {
11. int choice;
12. while(choice != 4)
13. {
14. printf("\n*************************Main Menu*****************************\n");
15. printf("\n=================================================================\n");
16. printf("\n1.insert an element\n2.Delete an element\n3.Display the queue\n4.Exit\n");
17. printf("\nEnter your choice ?");
18. scanf("%d",&choice);
19. switch(choice)
20. {
21. case 1:
22. insert();
23. break;
24. case 2:
25. delete();
26. break;
27. case 3:
28. display();
29. break;
30. case 4:
31. exit(0);
32. break;
33. default:
34. printf("\nEnter valid choice??\n");
35. }
36. }
37. }
38. void insert()
39. {
40. int item;
41. printf("\nEnter the element\n");
42. scanf("\n%d",&item);
43. if(rear == maxsize-1)
44. {
45. printf("\nOVERFLOW\n");
46. return;
47. }
48. if(front == -1 && rear == -1)
49. {
50. front = 0;
51. rear = 0;
52. }
53. else
54. {
55. rear = rear+1;
56. }
57. queue[rear] = item;
58. printf("\nValue inserted ");
59.
60. }
61. void delete()
62. {
63. int item;
64. if (front == -1 || front > rear)
65. {
66. printf("\nUNDERFLOW\n");
67. return;
68.
69. }
70. else
71. {
72. item = queue[front];
73. if(front == rear)
74. {
75. front = -1;
76. rear = -1 ;
77. }
78. else
79. {
80. front = front + 1;
81. }
82. printf("\nvalue deleted ");
83. }
84.
85.
86. }
87.
88. void display()
89. {
90. int i;
91. if(rear == -1)
92. {
93. printf("\nEmpty queue\n");
94. }
95. else
96. { printf("\nprinting values .....\n");
97. for(i=front;i<=rear;i++)
98. {
99. printf("\n%d\n",queue[i]);
100. }
101. }
102. }