Why does Queue have front but Priority-queue has top in stl?
Last Updated :
06 May, 2023
Why does the queue have front but the priority queue has top in stl?
The main difference between a queue and a priority queue is that a queue follows the FIFO (First-In-First-Out) principle, while a priority queue follows a specific priority order. In other words, the elements in a queue are processed in the order they were added, whereas the elements in a priority queue are processed based on their priority.
Queue:
A queue is a data structure that follows the FIFO (First-In-First-Out) principle, which means that the first element that is added to the queue is the first element that is removed. The elements in a queue are processed in the order they were added, and new elements are added to the back of the queue.
In the STL, the queue container is implemented as an adapter on top of other container classes, such as deque or list. The queue class provides a number of member functions, including the "front" member function, which returns a reference to the first element in the queue. This is the element that will be processed next when we call the "pop" member function to remove it from the queue.
For example: let's say we have a queue of integers {1, 2, 3}. We can use the "front" member function to access the first element in the queue, which is 1:
C++
#include <bits/stdc++.h>
using namespace std;
int main()
{
queue<int> myQueue;
myQueue.push(1);
myQueue.push(2);
myQueue.push(3);
// Accessing first element
int firstElement = myQueue.front();
cout << firstElement << endl;
return 0;
}
// Java code implementation
import java.io.*;
import java.util.*;
class GFG {
public static void main(String[] args)
{
Queue<Integer> myQueue = new LinkedList<Integer>();
myQueue.add(1);
myQueue.add(2);
myQueue.add(3);
// Accessing first element
int firstElement = myQueue.peek();
System.out.println(firstElement);
}
}
// This code is contributed by sankar.
// C# code implementation
using System;
using System.Collections.Generic;
public class GFG {
public static void Main()
{
Queue<int> myQueue = new Queue<int>();
myQueue.Enqueue(1);
myQueue.Enqueue(2);
myQueue.Enqueue(3);
// Accessing first element
int firstElement = myQueue.Peek();
Console.WriteLine(firstElement);
}
}
// This code is contributed by prasad264
from queue import Queue
myQueue = Queue()
myQueue.put(1)
myQueue.put(2)
myQueue.put(3)
# Accessing first element
firstElement = myQueue.queue[0]
print(firstElement)
# This code is contributed by Akash Jha
let myQueue = [];
myQueue.push(1);
myQueue.push(2);
myQueue.push(3);
// Accessing first element
let firstElement = myQueue[0];
console.log(firstElement);
// This code is contributed by Akash Jha
Time Complexity: O(1)
Auxiliary Space: O(1)
If we then call the "pop" member function to remove the first element from the queue, the next element in the queue (which is 2) becomes the first element, and we can access it using the "front" member function again:
C++
#include <bits/stdc++.h>
using namespace std;
int main()
{
queue<int> myQueue;
myQueue.push(1);
myQueue.push(2);
myQueue.push(3);
myQueue.pop();
int newFirstElement = myQueue.front();
cout << newFirstElement << endl;
return 0;
}
import java.util.Queue;
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
Queue<Integer> myQueue = new LinkedList<Integer>();
myQueue.add(1);
myQueue.add(2);
myQueue.add(3);
myQueue.remove();
int newFirstElement = myQueue.peek();
System.out.println(newFirstElement);
}
}
// This code is contributed by Akash Jha
using System;
using System.Collections.Generic;
class Program {
static void Main(string[] args)
{
Queue<int> myQueue = new Queue<int>();
myQueue.Enqueue(1);
myQueue.Enqueue(2);
myQueue.Enqueue(3);
myQueue.Dequeue();
int newFirstElement = myQueue.Peek();
Console.WriteLine(newFirstElement);
}
}
// This code is contributed by Akash Jha
from queue import Queue
myQueue = Queue()
myQueue.put(1)
myQueue.put(2)
myQueue.put(3)
myQueue.get()
newFirstElement = myQueue.queue[0]
print(newFirstElement)
# This code is contributed by Akash Jha
const myQueue = [];
myQueue.push(1);
myQueue.push(2);
myQueue.push(3);
myQueue.shift();
const newFirstElement = myQueue[0];
console.log(newFirstElement);
// This code is contributed by Akash Jha
Time Complexity: O(1)
Auxiliary Space: O(1)
Priority Queue
A priority queue, on the other hand, is a data structure that orders elements based on their priority. The elements in a priority queue are processed in order of their priority, with the highest-priority element processed first. New elements are added to the priority queue based on their priority order, and the highest-priority element is always at the front of the queue.
In the STL, the priority queue container is implemented as an adapter on top of a vector or a deque, and it requires a comparison function to determine the priority order of elements. The priority queue class provides a number of member functions, including the "top" member function, which returns a reference to the element with the highest priority in the queue. This is the element that will be processed next when we call the "pop" member function to remove it from the queue.
For example, let's say we have a priority queue (Max-Heap) of integers {3, 1, 2}. We can use the "top" member function to access the element with the highest priority, which is 3:
C++
#include <bits/stdc++.h>
using namespace std;
int main()
{
priority_queue<int> myPriorityQueue;
myPriorityQueue.push(3);
myPriorityQueue.push(1);
myPriorityQueue.push(2);
int highestPriorityElement
= myPriorityQueue.top();
cout << highestPriorityElement << endl;
return 0;
}
import java.util.*;
public class Main {
public static void main(String[] args) {
PriorityQueue<Integer> myPriorityQueue = new PriorityQueue<Integer>();
myPriorityQueue.add(3);
myPriorityQueue.add(1);
myPriorityQueue.add(2);
int highestPriorityElement = myPriorityQueue.peek();
System.out.println(highestPriorityElement);
}
}
// This code is contributed by Akash Jha
using System;
using System.Collections.Generic;
class MainClass {
public static void Main (string[] args) {
PriorityQueue<int> myPriorityQueue = new PriorityQueue<int>();
myPriorityQueue.Push(3);
myPriorityQueue.Push(1);
myPriorityQueue.Push(2);
int highestPriorityElement = myPriorityQueue.Top();
Console.WriteLine(highestPriorityElement);
}
}
public class PriorityQueue<T> where T : IComparable<T> {
private List<T> data;
public PriorityQueue() {
this.data = new List<T>();
}
public void Push(T item) {
data.Add(item);
int ci = data.Count - 1;
while (ci > 0) {
int pi = (ci - 1) / 2;
if (data[ci].CompareTo(data[pi]) >= 0)
break;
T tmp = data[ci]; data[ci] = data[pi]; data[pi] = tmp;
ci = pi;
}
}
public T Top() {
if (this.data.Count == 0)
throw new InvalidOperationException("The priority queue is empty.");
return data[0];
}
}
// This code is contributed by Akash Jha
import queue
my_queue = queue.PriorityQueue()
my_queue.put(3)
my_queue.put(1)
my_queue.put(2)
highest_priority_element = my_queue.get()
print(highest_priority_element)
# This code is contributed by Akash Jha
class PriorityQueue {
constructor(compareFn) {
this.compareFn = compareFn || ((a, b) => a - b);
this.items = [];
}
push(item) {
this.items.push(item);
this.items.sort(this.compareFn);
}
pop() {
return this.items.shift();
}
top() {
return this.items[0];
}
size() {
return this.items.length;
}
empty() {
return this.items.length === 0;
}
}
// Example usage
const myPriorityQueue = new PriorityQueue((a, b) => b - a);
myPriorityQueue.push(3);
myPriorityQueue.push(1);
myPriorityQueue.push(2);
const highestPriorityElement = myPriorityQueue.top();
console.log(highestPriorityElement);
// This code is contributed by Akash Jha
Time Complexity: O(logN), Where N is the number of elements to be pushed.
Auxiliary Space: O(1)
If we then call the "pop" member function to remove the highest-priority element from the queue, the next element with the highest priority (which is 2) becomes the new top element, and we can access it using the "top" member function again:
C++
#include <bits/stdc++.h>
using namespace std;
int main()
{
priority_queue<int> myPriorityQueue;
myPriorityQueue.push(3);
myPriorityQueue.push(1);
myPriorityQueue.push(2);
myPriorityQueue.pop();
int newHighestPriorityElement = myPriorityQueue.top();
cout << newHighestPriorityElement << endl;
return 0;
}
import java.util.PriorityQueue;
public class Main {
public static void main(String[] args) {
PriorityQueue<Integer> myPriorityQueue = new PriorityQueue<Integer>();
myPriorityQueue.add(3);
myPriorityQueue.add(1);
myPriorityQueue.add(2);
myPriorityQueue.poll();
int newHighestPriorityElement = myPriorityQueue.peek();
System.out.println(newHighestPriorityElement);
}
}
// This code is contributed by Akash Jha
import queue
myQueue = queue.PriorityQueue()
myQueue.put(3)
myQueue.put(1)
myQueue.put(2)
myQueue.get()
newHighestPriorityElement = myQueue.queue[0]
print(newHighestPriorityElement)
# This code is contributed by Akash Jha
using System;
using System.Collections.Generic;
class MainClass {
public static void Main (string[] args) {
var myPriorityQueue = new PriorityQueue<int>();
myPriorityQueue.Push(3);
myPriorityQueue.Push(1);
myPriorityQueue.Push(2);
myPriorityQueue.Pop();
int newHighestPriorityElement = myPriorityQueue.Top();
Console.WriteLine(newHighestPriorityElement);
}
}
class PriorityQueue<T> {
private List<T> data;
private Comparison<T> comparison;
public PriorityQueue() : this(Comparer<T>.Default) {}
public PriorityQueue(IComparer<T> comparer) : this(comparer.Compare) {}
public PriorityQueue(Comparison<T> comparison) {
this.data = new List<T>();
this.comparison = comparison;
}
public void Push(T item) {
int i = data.Count;
data.Add(item);
while (i > 0) {
int p = (i - 1) / 2;
if (comparison(data[p], item) <= 0)
break;
data[i] = data[p];
i = p;
}
data[i] = item;
}
public T Pop() {
T ret = data[0];
T last = data[data.Count - 1];
data.RemoveAt(data.Count - 1);
if (data.Count > 0) {
int i = 0;
while (i * 2 + 1 < data.Count) {
int a = i * 2 + 1, b = i * 2 + 2;
if (b < data.Count && comparison(data[b], data[a]) < 0) {
a = b;
}
if (comparison(data[a], last) >= 0) {
break;
}
data[i] = data[a];
i = a;
}
data[i] = last;
}
return ret;
}
public T Top() {
if (data.Count == 0)
throw new System.InvalidOperationException("Priority queue is empty.");
return data[0];
}
public int Count {
get { return data.Count; }
}
}
// This code is contributed by Akash Jha
let myPriorityQueue = [];
myPriorityQueue.push(3);
myPriorityQueue.push(1);
myPriorityQueue.push(2);
myPriorityQueue.sort((a, b) => b - a);
let highestPriorityElement = myPriorityQueue[0];
console.log(highestPriorityElement);
// This code is contributed by Akash Jha
Time Complexity: O(logN), Where N is the number of elements to be pushed or poped.
Auxiliary Space: O(1)
Similar Reads
Why can't a Priority Queue wrap around like an ordinary Queue?
Priority Queue: A priority queue is a special type of queue in which each element is assigned a priority value. And elements are served based on their priority. This means that elements with higher priority are served first. However, if elements with the same priority occur, they will be served in t
3 min read
What is Priority Queue | Introduction to Priority Queue
A priority queue is a type of queue that arranges elements based on their priority values. Each element has a priority associated. When we add an item, it is inserted in a position based on its priority.Elements with higher priority are typically retrieved or removed before elements with lower prior
6 min read
Turn a Queue into a Priority Queue
What is Queue?Queue is an abstract data type that is open at both ends. One end is always used to insert data (enqueue) which is basically the rear/back/tail end and the other which is the front end is used to remove data (dequeue). Queue follows First-In-First-Out (FIFO) methodology, i.e., "the dat
9 min read
Why is Binary Heap Preferred over BST for Priority Queue?
A typical Priority Queue requires following operations to be efficient.Get Top Priority Element (Get minimum or maximum)Insert an elementRemove top priority elementDecrease KeyA Binary Heap supports above operations with following time complexities:O(1)O(Logn)O(Logn)O(Logn) A Self Balancing Binary S
2 min read
Efficient way to initialize a priority queue
STL Priority Queue is the implementation of Heap Data Structure. By default, it's a max heap, and can be easily for primitive data types. There are some important applications of it which can be found in this article. Priority queue can be initialized in two ways either by pushing all elements one b
7 min read
Can we use Simple Queue instead of Priority queue to implement Dijkstra's Algorithm?
What is Dijkstra's Algorithm? Dijkstra's Algorithm is used for finding the shortest path between any two vertices of a graph. It uses a priority queue for finding the shortest path. For more detail, about Dijkstra's Algorithm, you can refer to this article. Why Dijkstra's Algorithm uses a Priority Q
2 min read
priority_queue::swap() in C++ STL
Priority queues are a type of container adaptors, specifically designed such that the first element of the queue is either the greatest or the smallest of all elements in the queue. However, in C++ STL (by default) the largest element is at the top. We can also create a priority queue having the sma
3 min read
Should we declare as Queue or Priority Queue while using Priority Queue in Java?
Queue: Queue is an Interface that extends the collection Interface in Java and this interface belongs to java.util package. A queue is a type of data structure that follows the FIFO (first-in-first-out ) order. The queue contains ordered elements where insertion and deletion of elements are done at
3 min read
Why Doesn't std::queue::pop Return Value?
In C++, we use std::queue which is a container adapter in the standard template library (STL) and is used for managing a collection of elements in a FIFO (first-in, first-out) order. One common question that arises in our mind is why the pop function in std::queue does not return the value it remove
3 min read
Java.util.PriorityQueue class in Java
It is a priority queue based on priority heap. Elements in this class are in natural order or depends on the Constructor we used at this the time of construction. It doesn't permit null pointers. It doesn't allow inserting a non-comparable object, if it relies on natural ordering. Constructors: Prio
6 min read