{"id":96369,"date":"2021-06-09T09:00:57","date_gmt":"2021-06-09T03:30:57","guid":{"rendered":"https:\/\/data-flair.training\/blogs\/?p=96369"},"modified":"2021-06-01T20:47:11","modified_gmt":"2021-06-01T15:17:11","slug":"queue-in-data-structure","status":"publish","type":"post","link":"https:\/\/data-flair.training\/blogs\/queue-in-data-structure\/","title":{"rendered":"Queue in Data Structure"},"content":{"rendered":"

Imagine yourself in the same example as we discussed in the last article on stacks. You are standing in a line for buffet dinner and many people are standing ahead of and behind you. People ahead of you in the line get there early. They get the food before you and they can leave before you.<\/p>\n

On the other hand, people behind you get served after you and leave after you. This line for buffet dinner is a queue. The first object to enter the queue is the first one to exit and the last object to enter in the queue is the last one to exit.<\/p>\n

In this article, we will learn about queues, types of queues, and array and linked list implementation of each type of queue. We will also see the advantages and disadvantages of different types of queues.<\/p>\n

Queue in Data Structure<\/h3>\n

A queue is an abstract data type data structure that allows operations on both ends. Just like in the above example, people exit from the front and enter from behind. Similarly, in a queue, you can add elements at one end and remove elements from the other. This makes the queue a FIFO structure.<\/p>\n

FIFO stands for First In First Out. The first object to enter the queue will be the first that can be accessed and removed. Elements after that will follow the same order.<\/p>\n

\"Queue<\/a><\/p>\n

 <\/p>\n

Complexity of Queue<\/b><\/p>\n\n\n\n\n\n\n
<\/td>\nTIME COMPLEXITY<\/span><\/td>\nSpace<\/span><\/td>\n<\/tr>\n
<\/td>\nAverage<\/span><\/td>\nworst<\/span><\/td>\nworst<\/span><\/td>\n<\/tr>\n
<\/td>\naccess<\/span><\/td>\nsearch<\/span><\/td>\ninsert<\/span><\/td>\ndelete<\/span><\/td>\naccess<\/span><\/td>\nsearch<\/span><\/td>\ninsert<\/span><\/td>\ndelete<\/span><\/td>\n<\/td>\n<\/tr>\n
QUEUE<\/span><\/td>\nO(n)<\/span><\/td>\nO(n)<\/span><\/td>\nO(1)<\/span><\/td>\nO(1)<\/span><\/td>\nO(n)<\/span><\/td>\nO(n)<\/span><\/td>\nO(1)<\/span><\/td>\nO(1)<\/span><\/td>\nO(n)<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Applications of Queues<\/h3>\n

Queues are used:<\/span><\/p>\n

1. As waiting buffered in printers, Disk, and CPU. The printer takes on the first request in the waiting queue and executes it. The new instructions are appended in the last of the waiting queue.<\/span><\/p>\n

2. In the asynchronous transfer of data in PIPES, Sockets, etc.<\/span><\/p>\n

3. In operating systems for handling interrupts and scheduling, semaphores.<\/span><\/p>\n

4. As Buffer in many applications like CD Player etc.<\/span><\/p>\n

5. In networking as a buffer queue in routers and switches.<\/span><\/p>\n

6. In Breadth-first search. A queue is maintained for the adjacent nodes of the current node that need to be traversed before going to the next level.<\/span><\/p>\n

7. To maintain the playlists in the media players.<\/span><\/p>\n

Basic operations on Queue<\/h3>\n

1. Enqueue():<\/b> insert a new element at the rear end of the queue.\u00a0<\/span><\/p>\n

2. Dequeue():<\/b> delete the element at the front end of the queue and return the deleted element.<\/span><\/p>\n

3. Peek():<\/b> returns the front element of the queue<\/span><\/p>\n

4. Isfull():<\/b> check if the queue is full or not<\/span><\/p>\n

5. Isempty():<\/b> check if the queue is empty or not.<\/span><\/p>\n

6. size(): <\/b>returns the current size of the queue.<\/span><\/p>\n

Implementation of Queue in Data Structure<\/b><\/h3>\n

1. Using Array<\/b><\/h4>\n

An array is used for the implementation of a queue. Implementation and its operation are all carried out on an array.<\/span><\/p>\n

2. Using Linked list<\/b><\/h4>\n

This is the linked list implementation of a queue. Implementation and its operations are all carried out on a linked list.<\/span><\/p>\n

Types of queue in Data Structure<\/h3>\n

1. Linear queue\u00a0<\/span><\/p>\n

2. Circular queue<\/span><\/p>\n

3. Priority queue<\/span><\/p>\n

4. Deque<\/span><\/p>\n

Let’s learn each of these types of queues now:<\/p>\n

1. Linear queue<\/h4>\n

In a linear queue, insertion of an element takes place at one end, known as the rear end and deletion takes place on the other end which is the front end. This strictly is a FIFO structure that stands for first in first out.\u00a0<\/span><\/p>\n

A major disadvantage of a linear linked list is that the elements are inserted on a rear end only. So once the rear pointer points to the last element of the queue no element can be added in a queue even if there is a space and it will return to an overflow condition.\u00a0<\/span><\/p>\n

\"Queue<\/a><\/p>\n

\"Deque\"<\/a><\/p>\n

In the above example, we can see that every time addition of data is at the rear end and deletion is at the front end.<\/span><\/p>\n

<\/h4>\n

Array implementation<\/h4>\n

Array implementation is very easy for a queue. Variables \u2018front\u2019 and \u2018rear\u2019 point to the two positions from where deletion and insertion of elements take place respectively. For an empty queue, front point to index -1.<\/span><\/p>\n

\"Array<\/a><\/p>\n

In the above figure, we can see the queue forming a word. The value of rear increases by 1 for every insertion of the new element in the above queue. After inserting \u2018r\u2019 in the last position, the queue will look something like below:<\/span><\/p>\n

\"Add<\/a><\/p>\n

After deleting an element the value of the front will increase by 1 every time and the queue will look like something below.<\/span><\/p>\n

\"Delete<\/a><\/p>\n

a. Insert a new element in Queue<\/h5>\n

1. Check if the queue is already full. If yes then return an overflow condition.<\/span><\/p>\n

2. If insertion is at the first position then set the value of the front and rear as 0 and insert the element at the rear end.<\/span><\/p>\n

3. Otherwise, keep increasing the value of the rear after inserting each element at the rear end<\/span><\/p>\n

Algorithm of Inserting Element in Queue<\/strong><\/p>\n

Step 1: If Rear = MaxSize - 1\r\nDisplay \u201cOverflow\u201d\r\nGo to step 4\r\nStep 2: If Front = -1 and Rear = -1\r\nset Front = Rear = 0\r\nelse\r\nset Rear = Rear + 1\r\n\r\nStep 3: set queue[Rear] = new\r\n\r\nStep 4: Stop\r\n\r\n<\/pre>\n
Queue in C<\/strong><\/p>\n
void insert (int queue[], int max, int front, int rear, int item)   \r\n       {\r\n            rear = rear + 1;   \r\n            queue[rear]=item;  \r\n    }  \r\n<\/pre>\n
b. Delete element in Queue<\/h5>\n
1. If the value of the front is -1 or greater than the rear, return \u201cqueue is empty\u201d
\n2. Increment the value of front by one and return the items stored at the front end each time.<\/p>\n
Algorithm to delete element in queue<\/strong><\/p>\n
Step 1: if Front = -1 or Front > Rear\r\nDisplay \u201cUnderflow\u201d\r\nelse\r\nset Value = queue[front]\r\nset front = front + 1\r\n\r\nStep 2: Stop\r\n\r\n<\/pre>\n
Delete element in queue in C Language<\/strong><\/p>\n
int delete (int queue[], int max, int front, int rear)  \r\n{  \r\n    int y;   \r\n     y = queue[front]; \r\n     front = front + 1;      \r\n     return y;  \r\n    } \r\n<\/pre>\n
c. peek() in queue<\/h5>\n
This returns the data at the front of the queue.<\/p>\n
Algorithm:<\/strong><\/p>\n
start procedure peek\r\n   return queue[front]\r\nstop procedure\r\n\r\n<\/pre>\n
Function in C:<\/strong><\/p>\n
int peek() \r\n{\r\n   return queue[front];\r\n}\r\n\r\n<\/pre>\n
d. isfull() in queue<\/h5>\n
1. Check if the rear is at the last position of the array.<\/p>\n
Algorithm:<\/strong><\/p>\n
Start procedure isfull\r\n\r\n   if rear equals to MAXSIZE - 1\r\n      return true\r\n   else\r\n      return false\r\n   endif\r\n   \r\nStop procedure\r\n\r\n<\/pre>\n
Function in C:<\/strong><\/p>\n
bool isfull() \r\n{\r\n   if(rear == MAXSIZE - 1)\r\n      return true;\r\n   else\r\n      return false;\r\n}\r\n\r\n<\/pre>\n
e. isEmpty() in queue<\/h5>\n
1.Check if the front is 0 or the front is greater than the rear.<\/p>\n
Algorithm of isEmpty()<\/strong><\/p>\n
Start procedure isempty\r\n\r\n   if front is less than MIN  OR front > rear\r\n      return true\r\n   else\r\n      return false\r\n   endif\r\n   \r\nStop procedure\r\n\r\n<\/pre>\n
Function in C:<\/strong><\/p>\n
bool isempty() \r\n{\r\n   if(front < 0 || front > rear) \r\n      return true;\r\n   else\r\n      return false;\r\n}\r\n<\/pre>\n
f. size() in queue<\/h5>\n
This function returns the current size of the queue.<\/p>\n
Algorithm:<\/strong><\/p>\n
Start procedure size\r\n        Return rear - front\r\nStop procedure\r\n\r\n<\/pre>\n
Function in C:<\/strong><\/p>\n
int size(int front, int rear) \r\n{\r\n    return (rear - front);\r\n}\r\n\r\n<\/pre>\n
Disadvantages of array implementation<\/h3>\n
1. Memory wastage<\/h4>\n
Memory that is used to store elements of queue, can never be reused, once it\u2019s free because elements can be inserted at the rear position only. So all the space before the front end is useless and a wastage of memory.<\/p>\n
\"Memory<\/a><\/h4>\n
2. Array size<\/h4>\n
One major disadvantage of array implementation is that the user needs to define the array size in advance. Since the queue might be required to change the size during the run time, this may lead to problems like memory wastage or memory shortage.<\/p>\n
Linked list implementation of queue<\/h4>\n
We know the advantages of a linked list over an array. An alternative to implementing a queue other than the array is a linked list. Worst-case time complexity is o(1) for linked list implementation of a queue.<\/p>\n
\"Linked<\/a><\/p>\n
1. Insert a new element in queue<\/h5>\n
If the queue is empty then the front is null. A new element will be added as the only element of the linked list and will point to null.<\/p>\n
If the queue is not empty, increment the rear pointer so that it points to the new node. This new node points to null.<\/p>\n
Algorithm:<\/strong><\/p>\n
Step 1: set newnode -> data = value\r\nStep 2: if front = null\r\nset front = rear = newnode\r\nset front -> next = rear -> next = null\r\nelse\r\nset rear -> next = newnode\r\nset rear = newnode\r\nset rear -> next = null\r\nStep 3: Stop\r\n\r\n<\/pre>\n
Function in C:<\/strong><\/p>\n
void insert(Node newNode)\r\n{\r\nnewNode -> data = item;  \r\n            rear -> next = newNode;  \r\n            rear = newNode;  \r\n            rear->next = NULL;  \r\n   }     \r\n\r\n<\/pre>\n
2. Delete an element in queue<\/h5>\n
If the queue is empty then the value of the front is null and returns underflow condition.
\nElse delete the element from the front of the list and increment the front pointer to the next node.<\/p>\n
Algorithm:<\/strong><\/p>\n
Step 1: if front = null\r\ndisplay \" underflow \"\r\ngo to step 5\r\nStep 2: set deletenode = front\r\nStep 3: set front = front -> next\r\nStep 4: free deletenode\r\nStep 5: end\r\n\r\n<\/pre>\n
Function in C:<\/strong><\/p>\n
int delete()\r\n{\r\ndeletedNode = front;  \r\n        front = front -> next;  \r\n        free(DeletedNode);  \r\n}\r\n<\/pre>\n
Circular queue<\/h3>\n
In a circular queue, all nodes are present in a circular order. This concept is very similar to the circular linked list. Also known as a ring buffer that connects all ends to another end.<\/p>\n
Representation of circular queue:<\/strong><\/p>\n
\"Circular<\/a><\/p>\n
The major objective behind the concept of the circular queue was to overcome the drawbacks of the linear queue. If space is available in a circular queue, a new element can be added by incrementing the value of the rear.<\/p>\n
\"Linear<\/a><\/p>\n
In the above example, you can see that although the space is available in the linear queue the new element will not be inserted. The rear is equal to the maximum size of the queue and it will return overflow condition.<\/p>\n
But in the circular queue, as represented below, the addition of elements is possible and memory is used more efficiently.<\/p>\n
\"Circular<\/a><\/p>\n
Operations on Circular Queue<\/h3>\n
1. Front()<\/strong>: returns the front element.
\n2. Rear():<\/strong> return the rear element.
\n3. Enqueue():<\/strong> insert a new element at the rear end.
\n4. Dequeue():<\/strong> delete element from the front end.<\/p>\n
Applications of Circular Queue<\/h4>\n
1. Memory management:<\/strong> Circular queue performs better memory management than a linear queue. Memory is efficiently utilized by placing the elements in empty locations.<\/p>\n
2. CPU scheduling:<\/strong> Operating systems use a circular queue to insert the processes and execute them.<\/p>\n
3. Traffic Light:<\/strong> Computer-controlled traffic light system follows the circular queue.<\/p>\n
Array implementation of the circular queue<\/h4>\n
1. Enqueue()<\/h4>\n
1. Check if the queue is full.
\n2. If the queue is empty, set front and rear to -1. Insert the first element and set both front and rear to 0
\n3. Increment the rear by one every time you insert a new element.<\/p>\n
Algorithm:<\/strong><\/p>\n
Step 1: if (rear+1)%max = front\r\n             Display \" overflow \"\r\n             Goto step 4\r\nStep 2: if front = -1 and rear = -1\r\n             Set front = rear = 0\r\n             Else if rear = max - 1 and front ! = 0\r\n             Set rear = 0\r\n             Else\r\n             Set rear = (rear + 1) % max\r\nStep 3: set circularqueue[rear] = value\r\nStep 4: stop\r\n<\/pre>\n
Function in C:<\/strong><\/p>\n
void enqueue(int new)  \r\n{  \r\n    if(front==-1 && rear==-1)  \r\n    {  \r\n        front=rear=0;  \r\n        count = 1;\r\n        circularqueue[rear]=new;  \r\n    }  \r\n    else if((rear+1)%max==front)   \r\n    {  \r\n        printf(\"OverFlow\");  \r\n    }  \r\n    else  \r\n    {  \r\n        rear=(rear+1)%max;       \r\n        circularqueue[rear]=new; \r\n       count++;   \r\n    }  \r\n} \r\n<\/pre>\n
2. Delete element in Circular Queue<\/h4>\n
1. Check if the queue is empty or not. If empty, return underflow.
\n2. Value of the front decreases by one, every time an element is deleted.
\n3. On deleting the only element left, set both front and rear to -1.<\/p>\n
Algorithm:<\/strong><\/p>\n
Step 1: if front = -1\r\n             Display \" underflow \"\r\n             Goto step 4\r\nStep 2: set value = circularqueue[front]\r\nStep 3: if front = rear\r\n             Set front = rear = -1\r\n             Else\r\n             If front = max -1\r\n             Set front = 0\r\n             Else\r\n             Set front = front + 1\r\nStep 4: Stop\r\n\r\n\r\n\r\n<\/pre>\n
Function in C:<\/strong><\/p>\n
int dequeue()  \r\n{  \r\n    if((front==-1) && (rear==-1))  \r\n        printf(\"Underflow\");  \r\n      \r\n else if(front==rear)  \r\n{    \r\n   front=-1;  \r\n   rear=-1; \r\n   count=0; \r\n}   \r\nelse    \r\n   front=(front+1)%max;   \r\nreturn queue[front];\r\ncount--;\r\n}\r\n<\/pre>\n
3. size ()<\/h4>\n
Returns the size of the current circular queue.<\/p>\n
int size(int count) \r\n{\r\n    return count;\r\n}\r\n<\/pre>\n
Linked list implementation of Circluar Queue<\/h3>\n
Linked list implementation of any data structure is always more efficient than array implementation. Inserting and deleting elements in a circular queue via a linked list has a worst-case time complexity of o(n).<\/p>\n
1. Insert element<\/h4>\n
void enqueue(Node newNode , Int datanew)  \r\n{  \r\n    newNode -> data=datanew;  \r\n    newnode->next=0;  \r\n    if(rear==-1)  \r\n    {  \r\n        front=rear=newNode;  \r\n        rear->next=front;  \r\n    }  \r\n    else  \r\n    {  \r\n        rear->next=newNode;  \r\n        rear=newNode;  \r\n        rear->next=front;  \r\n    }  \r\n}\r\n\r\n<\/pre>\n
2. Delete Element<\/h4>\n
void dequeue()  \r\n{  \r\n    if((front==-1)&&(rear==-1))     {  \r\n        printf(\"Underflow\");  \r\n    }  \r\n    else if(front==rear) \r\n        front=rear=-1;   \r\n    else  \r\n    {  \r\n        front=front->next;  \r\n        rear->next=front;  \r\n    }  \r\n} \r\n\r\n<\/pre>\n
3. Peek()<\/h4>\n
This function returns the element at the front position.<\/p>\n
int peek()  \r\n{  \r\n    if((front==-1) &&(rear==-1))   \r\n        printf(\"Empty Queue\");   \r\n    else   \r\n        printf(front->data);  \r\n}  \r\n<\/pre>\n
Deque<\/h3>\n
Deque stands for double-ended queue. It does not follow the FIFO principle and insertion and deletion of elements can take from both ends. It is also said to be the generalized version of the queue.\u00a0<\/span><\/p>\n
\"Deque\"<\/a><\/p>\n
Deque can act as both stack and queue by limiting insert or delete of conditions on either end.<\/span><\/p>\n
\"Deque<\/a><\/p>\n
\"Deque<\/a><\/p>\n
Input restricted queue:<\/b> In input restricted queue we can insert data at only one end deletion is possible on both ends.<\/span><\/p>\n
\"Input<\/a><\/p>\n
Output restricted queue:<\/b> In output restricted queue we can delete data from only one end but insertion can be done on both ends.<\/span><\/p>\n
\"Output<\/a><\/p>\n
Operations on Deque<\/h4>\n
    \n
  1. Insert at front\u00a0<\/span><\/li>\n
  2. Delete from end<\/span><\/li>\n
  3. Insert at rear<\/span><\/li>\n
  4. Delete from rear<\/span><\/li>\n
  5. Isfull()<\/span><\/li>\n
  6. Isempty ()<\/span><\/li>\n<\/ol>\n
    Deque is implemented using two data structures: circular array and circular linked list.<\/span><\/p>\n
    1. Circular array<\/h5>\n
    In a circular array, the last element is connected to the first element of the array. If we want to insert a new element but the rear is already at the last position, and the first position of the circular array is empty, then it will not show any error, since the last and first elements of the circular array are connected.<\/span><\/p>\n
    \"Circular<\/a><\/p>\n
    Applications of dequeue<\/h4>\n
    1. Deque can be used as a stack or queue.<\/span><\/p>\n
    2. It is used as a palindrome checker since a string can be read from both ends.<\/span><\/p>\n
    3. Deque is used in multiprocessor scheduling. Multiprocessor scheduling using deque is done with the help of an <\/span>A-steal algorithm<\/b>.<\/span><\/p>\n
    Array implementation of Deque<\/span><\/h3>\n
    Enqueue<\/h4>\n
    1. If the array is empty, set both front and rear to -1.<\/span><\/p>\n
    2. Insert the first element and set front and rear to 0.<\/span><\/p>\n
    3. Insert the next element and increase the value of the rear by one every time.<\/span><\/p>\n
    4. If you want to insert a new element at the front, decrease the value of the front by one. If the front is at zero, after deletion the front is set to the last index of the circular array.<\/span><\/p>\n
    Dequeue<\/h4>\n
    1. Delete an element from the front and increase the value of the front by one.<\/span><\/p>\n
    2. Delete an element from the rear and decrease the value of the rear by one.<\/span><\/p>\n
    3. If the rear is pointing to the first element, after deleting, set the rear to the last index of the circular array.<\/span><\/p>\n
    Working of Deque<\/b><\/p>\n
    Let us consider a queue of max size 9:<\/span><\/p>\n
    1: Deque is empty. Front = Rear = -1<\/span><\/p>\n
    \"Empty<\/a><\/p>\n
    2: Insert \u201cD\u2019 at the rear.<\/span><\/p>\n
    \"Insertion<\/a><\/p>\n
    3: Insert \u2018A\u2019 and \u2018T\u2019 at the rear.<\/span><\/p>\n
    \"Insertion<\/a><\/p>\n
    4: Insert \u2018R\u2019 at the front.<\/span><\/p>\n
    \"Insert<\/a><\/p>\n
    5: Insert \u2018I\u2019 at the front and \u2018A\u2019 at the rear.<\/span><\/p>\n
    \"Insert<\/a><\/p>\n
    6: Delete at rear and front.<\/span><\/p>\n
    \"Delete<\/a><\/p>\n
    7: Insert \u2018A\u2019, \u2018F\u2019, \u2018L\u2019 at the rear and \u2018I\u2019, \u2018A\u2019 at front.<\/span><\/p>\n
    \"Insert<\/a><\/p>\n
    Insert at front<\/h4>\n
    void enqueue_front(int new)  \r\n{  \r\n  \r\n    if((front==-1) && (rear==-1))  \r\n    {  \r\n        front=rear=0;  \r\n        deque[front]=new;  \r\n    }  \r\n    else if(front==0)  \r\n    {  \r\n        front=size-1;  \r\n        deque[front]=new;  \r\n    }  \r\n    else  \r\n    {  \r\n        front=front-1;  \r\n        deque[front]=new;  \r\n    }  \r\n} \r\n<\/pre>\n
    Insert at rear<\/h4>\n
    void enqueue_rear(int new)  \r\n{  \r\n      else if((front==-1) && (rear==-1))  \r\n    {  \r\n        rear=0;  \r\n        deque[rear]=new;  \r\n    }  \r\n    else if(rear==size-1)  \r\n    {  \r\n        rear=0;  \r\n        deque[rear]=new;  \r\n    }  \r\n    else  \r\n    {  \r\n        rear++;  \r\n        deque[rear]=new;  \r\n    }  \r\n}\r\n<\/pre>\n
    Delete at front<\/h4>\n
    void dequeue_front()  \r\n{  \r\n    if((front==-1) && (rear==-1))  \r\n    {  \r\n        printf(\"Underflow\");  \r\n    }  \r\n    else if(front==rear)  \r\n    {  \r\n        printf( deque[front]);  \r\n        front=-1;  \r\n        rear=-1;      \r\n    }  \r\n     else if(front==(size-1))  \r\n     {  \r\n         printf(deque[front]);  \r\n         front=0;  \r\n     }  \r\n     else  \r\n     {  \r\n          printf(deque[front]);  \r\n          front=front+1;  \r\n     }  \r\n} \r\n<\/pre>\n
    Delete at end<\/h4>\n
    void dequeue_rear()  \r\n{  \r\n    if((front==-1) && (rear==-1))  \r\n    {  \r\n        printf(\"Underflow\");  \r\n    }  \r\n    else if(front==rear)  \r\n    {  \r\n        printf(deque[rear]);  \r\n        front=-1;  \r\n        rear=-1;  \r\n          \r\n    }  \r\n     else if(rear==0)  \r\n     {  \r\n         printf(deque[rear]);  \r\n         rear=size-1;  \r\n     }  \r\n     else  \r\n     {  \r\n          printf(deque[rear]);  \r\n          rear=rear-1;  \r\n     }  \r\n}  \r\n\r\n<\/pre>\n
    Get front<\/h4>\n
    int getfront()  \r\n{  \r\n    if((front==-1) && (rear==-1))  \r\n    {  \r\n        printf(\"Underflow\");  \r\n        return -1;\r\n    }  \r\n    else  \r\n        return deque[front];  \r\n} \r\n\r\n<\/pre>\n
    Get end<\/h4>\n
    int getrear()  \r\n{  \r\n    if((front==-1) && (rear==-1))  \r\n    {  \r\n        printf(\"Underflow\"); \r\n        return -1; \r\n    }  \r\n    else  \r\n    {  \r\n       return deque[rear];  \r\n    }   \r\n} \r\n\r\n<\/pre>\n
    Priority queue<\/h3>\n
    A priority queue is also an abstract data type similar to a linear queue. The only thing that makes it different from other types of queues is that each element has a priority assigned to it. Element with the highest priority comes first in a priority queue. Priority determines the order in which elements are accessed and removed from the queue.<\/span><\/p>\n
    In the priority queue, elements are either arranged in ascending or descending order.<\/span><\/p>\n
    Characteristics of priority queue<\/b><\/p>\n