Related Articles
Efficient way to initialize a priority queue
• Last Updated : 11 May, 2021

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 by one or by initializing using their constructor. In this article, we will discuss both methods and examine their time complexities.

Method 1: The simplest approach is to traverse the given array and push each element one by one in the priority queue. In this method, the push method in the priority queue takes O(log N) time. Where N is the number of elements in the array.

Below is the implementation of the above approach:

## C++

 `// C++ program to initialize the``// priority queue``#include ``using` `namespace` `std;` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 15, 25, 6, 54, 45, 26, 12 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// Initialize priority_queue``    ``priority_queue<``int``> pq;` `    ``// Traverse the array arr[]``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Push the element arr[i]``        ``pq.push(arr[i]);``    ``}` `    ``cout << ``"The elements in priority"``         ``<< ``" Queue are: "``;` `    ``// Traverse until pq is non-empty``    ``while` `(!pq.empty()) {` `        ``// Print the element in pq``        ``cout << pq.top() << ``" "``;` `        ``// Pop the top element``        ``pq.pop();``    ``}` `    ``return` `0;``}`

## Java

 `// Java program to initialize the``// priority queue``import` `java.util.*;``public` `class` `GFG``{``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] arr = { ``15``, ``25``, ``6``, ``54``, ``45``, ``26``, ``12` `};``        ``int` `N = arr.length;``     ` `        ``// Initialize priority_queue``        ``Vector pq = ``new` `Vector();``     ` `        ``// Traverse the array arr[]``        ``for` `(``int` `i = ``0``; i < N; i++)``        ``{``     ` `          ``// Push the element arr[i]``          ``pq.add(arr[i]);``        ``}``        ``Collections.sort(pq);``        ``Collections.reverse(pq);``        ``System.out.print(``"The elements in priority"` `+ ``" Queue are: "``);``     ` `        ``// Traverse until pq is non-empty``        ``while` `(pq.size() > ``0``)``        ``{``     ` `          ``// Print the element in pq``          ``System.out.print(pq.get(``0``) + ``" "``);``     ` `          ``// Pop the top element``          ``pq.remove(``0``);``        ``}``    ``}``}` `// This code is contributed by divyesh072019.`

## Python3

 `# Python3 program to initialize the``# priority queue` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``15``, ``25``, ``6``, ``54``, ``45``, ``26``, ``12``]``    ``N ``=` `len``(arr)` `    ``# Initialize priority_queue``    ``pq ``=` `[]` `    ``# Traverse the array arr[]``    ``for` `i ``in` `range``(N):``      ` `        ``# Push the element arr[i]``        ``pq.append(arr[i])``    ``print``(``"The elements in priority Queue are: "``, end ``=` `"")``    ``pq ``=` `sorted``(pq)` `    ``# Traverse until pq is non-empty``    ``while` `(``len``(pq) > ``0``):` `        ``# Print the element in pq``        ``print``(pq[``-``1``], end ``=` `" "``)` `        ``# Pop the top element``        ``del` `pq[``-``1``]` `        ``# This code is contributed by mohit kumar 29.`

## C#

 `// C# program to initialize the``// priority queue``using` `System;``using` `System.Collections.Generic;``class` `GfG``{``  ``public` `static` `void` `Main()``  ``{``    ``int``[] arr = { 15, 25, 6, 54, 45, 26, 12 };``    ``int` `N = arr.Length;` `    ``// Initialize priority_queue``    ``List<``int``> pq = ``new` `List<``int``>();` `    ``// Traverse the array arr[]``    ``for` `(``int` `i = 0; i < N; i++) {` `      ``// Push the element arr[i]``      ``pq.Add(arr[i]);``    ``}` `    ``pq.Sort();``    ``pq.Reverse();` `    ``Console.Write(``"The elements in priority"` `+ ``" Queue are: "``);` `    ``// Traverse until pq is non-empty``    ``while` `(pq.Count > 0) {` `      ``// Print the element in pq``      ``Console.Write(pq[0] + ``" "``);` `      ``// Pop the top element``      ``pq.RemoveAt(0);``    ``}``  ``}``}` `// This code is contributed by divyeshrabadiya07.`

## Javascript

 ``
Output:

`The elements in priority Queue are: 54 45 26 25 15 12 6`

Time Complexity: O(N*log N)
Auxiliary Space: O(N)

Method 2: In this method, copy all the array elements into the priority queue while initializing it (this copying will be happened using the copy constructor of priority_queue). In this method, the priority_queue will use the build heap method internally. So the build heap method is taking O(N) time.

Syntax:

priority_queue<int> pq(address of the first element, address of the next of the last element);

Syntax for the array:

priority_queue<int> pq (arr, arr + N)
where arr is the array and N is the size of the array.

Syntax for the vector:

priority_queue<int> pq(v.begin(), v.end());
where v is the vector.

Below is the implementation of the above approach:

## C++

 `// C++ program to initialize the``// priority queue``#include ``#include ``using` `namespace` `std;` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 15, 25, 6, 54, 45, 26, 12 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// By this type of initialization``    ``// the priority_queue is using``    ``// build heap to make the max heap``    ``cout << ``"The elements in priority"``         ``<< ``" Queue are: "``;` `    ``// Initialize priority_queue``    ``priority_queue<``int``> pq(arr, arr + N);` `    ``// Iterate until pq is non empty``    ``while` `(!pq.empty()) {` `        ``// Print the element``        ``cout << pq.top() << ``" "``;``        ``pq.pop();``    ``}` `    ``return` `0;``}`

## Python3

 `# Python3 program to initialize the``# priority queue` `# Driver Code``if` `__name__``=``=``'__main__'``:``    ` `    ``arr ``=` `[ ``15``, ``25``, ``6``, ``54``, ``45``, ``26``, ``12` `]``    ``N ``=` `len``(arr)``    ` `    ``# By this type of initialization``    ``# the priority_queue is using``    ``# build heap to make the max heap``    ``print``(``"The elements in priority Queue are: "``, end ``=` `'')``    ` `    ``# Initialize priority_queue``    ``pq ``=` `arr``    ``pq.sort()` `    ``# Iterate until pq is non empty``    ``while` `(``len``(pq) !``=` `0``):``      ` `        ``# Print the element``        ``print``(pq[``-``1``], end ``=` `' '``)``        ``pq.pop()``    ` `    ``# This code is contributed by rutvik_56.`
Output:
`The elements in priority Queue are: 54 45 26 25 15 12 6`

Time Complexity: O(N)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

My Personal Notes arrow_drop_up