Skip to content
Related Articles

Related Articles

Improve Article

Merge two sorted arrays using Priority queue

  • Difficulty Level : Medium
  • Last Updated : 05 Aug, 2021

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: 

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


Output

4 5 6 7 8 8 

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

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :