Merge two sorted arrays using Priority queue

Last Updated : 18 Oct, 2022

Given two sorted arrays A[] and B[] of sizes N and M respectively, the task is to merge them in a sorted manner.

Examples:

Input: A[] = { 5, 6, 8 }, B[] = { 4, 7, 8 }
Output: 4 5 6 7 8 8

Input: A[] = {1, 3, 4, 5}, B] = {2, 4, 6, 8}
Output: 1 2 3 4 4 5 6 8

Input: A[] = {5, 8, 9}, B[] = {4, 7, 8}
Output: 4 5 7 8 8 9

Approach: The given problem, merging two sorted arrays using minheap already exists. But here the idea is to use a priority_queue to implement min-heap provided by STL. Follow the steps below to solve the problem:

Initialize a min priority queue say PQ to implement the Min Heap.
Traverse the array A[], and push all the elements of the array into the PQ.
Traverse the array B[], and push all the elements of the array into the PQ.
Now put all the elements of the PQ into an array, say res[] popping the top element of the PQ one by one.
Finally, print the sorted array res[] as the answer.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to merge two arrays
void merge(int A[], int B[], int N, int M)
{
    // Stores the merged array
    int res[N + M];
 
    // Create a min priority_queue
    priority_queue<int, vector<int>, greater<int> > pq;
 
    // Traverse the array A[]
    for (int i = 0; i < N; i++)
        pq.push(A[i]);
 
    // Traverse the array B[]
    for (int i = 0; i < M; i++)
        pq.push(B[i]);
 
    int j = 0;
 
    // Iterate until the
    // pq is not empty
    while (!pq.empty()) {
 
        // Stores the top element
        // of pq into res[j]
        res[j++] = pq.top();
 
        // Removes the top element
        pq.pop();
    }
 
    // Print the merged array
    for (int i = 0; i < N + M; i++)
        cout << res[i] << ' ';
}
 
// Driver Code
int main()
{
 
    // Input
    int A[] = { 5, 6, 8 };
    int B[] = { 4, 7, 8 };
 
    int N = sizeof(A) / sizeof(A[0]);
    int M = sizeof(B) / sizeof(B[0]);
 
    // Function call
    merge(A, B, N, M);
 
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to merge two arrays
static void merge(int A[], int B[], int N, int M)
{
     
    // Stores the merged array
    int []res = new int[N + M];
     
    // Create a min priority_queue
    Queue<Integer> pq = new PriorityQueue<>();
     
    // Traverse the array A[]
    for(int i = 0; i < N; i++)
        pq.add(A[i]);
     
    // Traverse the array B[]
    for(int i = 0; i < M; i++)
        pq.add(B[i]);
     
    int j = 0;
     
    // Iterate until the
    // pq is not empty
    while (!pq.isEmpty()) 
    {
         
        // Stores the top element
        // of pq into res[j]
        res[j++] = pq.peek();
     
        // Removes the top element
        pq.remove();
    }
     
    // Print the merged array
    for(int i = 0; i < N + M; i++)
        System.out.print(res[i] + " ");
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Input
    int A[] = { 5, 6, 8 };
    int B[] = { 4, 7, 8 };
 
    int N = A.length;
    int M = B.length;
 
    // Function call
    merge(A, B, N, M);
}
}
 
// This code is contributed by todaysgaurav

Python3

# Python3 program for the above approach
from queue import PriorityQueue
 
# Function to merge two arrays
def merge(A, B, N, M):
 
    # Stores the merged array
    res = [0 for i in range(N + M)]
     
    # Create a min priority_queue
    pq = PriorityQueue()
     
    # Traverse the array A[]
    for i in range(N):
        pq.put(A[i])
         
    # Traverse the array B[]
    for i in range(M):
        pq.put(B[i])
 
    j = 0
     
    # Iterate until the
    # pq is not empty
    while not pq.empty():
       
        # Removes the top element and
        # stores it into res[j]
        res[j] = pq.get()
        j += 1
         
    # Print the merged array
    for i in range(N + M):
        print(res[i], end = " ")
         
    # return back to main
    return
 
# Driver code
if __name__ == '__main__':
   
    # Input
    A = [ 5, 6, 8 ]
    B = [ 4, 7, 8 ]
 
    N = len(A)
    M = len(B)
     
    # Function call
    merge(A, B, N, M)
     
# This code is contributed by MuskanKalra1

C#

// C# program for the above approach.
using System;
using System.Collections.Generic;
 
public class GFG {
  public static int cmp(int a, int b) { return a - b; }
 
  // Function to merge two arrays
  static void merge(int[] A, int[] B, int N, int M)
  {
    // Stores the merged array
    int[] res = new int[N + M];
 
    // Create a min priority_queue using List and cmp
    // comparator
    List<int> pq = new List<int>();
 
    // Traverse the array A[]
    for (int i = 0; i < N; i++)
      pq.Add(A[i]);
 
    // Traverse the array B[]
    for (int i = 0; i < M; i++)
      pq.Add(B[i]);
 
    int j = 0;
 
    pq.Sort(cmp);
 
    // Iterate until the
    // pq is not empty
    int index = 0;
    while (index < pq.Count) {
 
      // Stores the top element
      // of pq into res[j]
      res[j++] = pq[index];
 
      // Removes the top element
      index++;
    }
 
    // Print the merged array
    for (int i = 0; i < N + M; i++)
      Console.Write(res[i] + " ");
  }
 
  public static void Main(string[] args)
  {
    // Input
    int[] A = { 5, 6, 8 };
    int[] B = { 4, 7, 8 };
 
    int N = A.Length;
    int M = B.Length;
 
    // Function call
    merge(A, B, N, M);
  }
}
 
// This code is contributed by adityamaharshi21.

Javascript

<script>
 
// Javascript program for the above approach
 
// Function to merge two arrays
function merge(A, B, N, M)
{
 
    // Stores the merged array
    var res = Array(N+M).fill(0);
 
    // Create a min priority_queue
    var pq = [];
 
    // Traverse the array A[]
    for (var i = 0; i < N; i++)
        pq.push(A[i]);
 
    // Traverse the array B[]
    for (var i = 0; i < M; i++)
        pq.push(B[i]);
 
    var j = 0;
    pq.sort((a,b)=>b-a);
 
    // Iterate until the
    // pq is not empty
    while (pq.length!=0) {
 
        // Stores the top element
        // of pq into res[j]
        res[j++] = pq[pq.length-1];
 
        // Removes the top element
        pq.pop();
        pq.sort((a,b)=>b-a);
    }
 
    // Print the merged array
    for (var i = 0; i < N + M; i++)
        document.write(res[i] + ' ');
}
 
// Driver Code
// Input
var A = [5, 6, 8];
var B = [4, 7, 8];
var N = A.length;
var M = B.length;
 
// Function call
merge(A, B, N, M);
 
// This code is contributed by rrrtnx.
</script>