Merge Two Binary Max Heaps

Given two binary max heaps, the task is to merge the given heaps to form a new max heap.

Examples :

Input: a[] = {10, 5, 6, 2}, b[] = {12, 7, 9}
Output: {12, 10, 9, 2, 5, 7, 6}
Merge Two Binary Max Heaps
Input: a[] = {2, 5, 1, 9, 12}, b[] = {3, 7, 4, 10}
Output: {12, 10, 7, 9, 5, 3, 1, 4, 2}

Table of Content

[Naive Approach] Using Max Heap - O((N + M)*log(N + M)) Time and O(N + M) Space:
[Expected Approach] Merge and Build Heap- O(N + M) Time and O(N + M) Space:

[Naive Approach] Merge using extra Max Heap - O((N + M)*log(N + M)) Time and O(N + M) Space:

The property of Max Heap is that the top of any Max Heap is always the largest element. We will use this property to merge the given binary Max Heaps.

To do this:

Create another Max Heap, and insert the elements of given binary max heaps into this one by one.
- Now repeat above step until all the elements from both given Max Heaps are merged into the third one, ensuring the property of largest element on top (max heapify).
The third Max Heap will be the required merged Binary Max Heap.

Below is the implementation of the above approach:

C++

// C++ Program to merge two binary max heaps

#include <bits/stdc++.h>
using namespace std;

// function to merge max heaps
vector<int> mergeHeaps(vector<int>& a, vector<int>& b,
                       int n, int m)
{
    // Max Heap to store all the elements
    priority_queue<int> maxHeap;

    // Insert all the elements of first array
    for (int i = 0; i < n; i++) {
        maxHeap.push(a[i]);
    }

    // Insert all the elements of second array
    for (int i = 0; i < m; i++) {
        maxHeap.push(b[i]);
    }

    vector<int> merged;
    // Push all the elements from the max heap
    while (!maxHeap.empty()) {
        merged.push_back(maxHeap.top());
        maxHeap.pop();
    }
    return merged;
}

int main()
{
    // Sample Input
    vector<int> a = { 10, 5, 6, 2 };
    vector<int> b = { 12, 7, 9 };
    int n = a.size(), m = b.size();

    vector<int> merged = mergeHeaps(a, b, n, m);

    for (int i = 0; i < n + m; i++)
        cout << merged[i] << " ";
    return 0;
}

Java

import java.util.*;
public class GFG {

    // Function to merge max heaps
    public static int[] mergeHeaps(int[] a, int[] b, int n, int m) {
        // Max Heap to store all the elements
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>((x, y) -> y - x);

        // Insert all the elements for first array
        for (int i = 0; i < n; i++) {
            maxHeap.add(a[i]);
        }

        // Insert all the elements for second array
        for (int i = 0; i < m; i++) {
            maxHeap.add(b[i]);
        }

        int[] merged = new int[n + m];
        int index = 0;
        // Push all the elements from the max heap
        while (!maxHeap.isEmpty()) {
            merged[index++] = maxHeap.poll();
        }
        return merged;
    }

    public static void main(String[] args) {
        // Sample Input
        int[] a = { 10, 5, 6, 2 };
        int[] b = { 12, 7, 9 };
        int n = a.length;
        int m = b.length;

        int[] merged = mergeHeaps(a, b, n, m);

        for (int i = 0; i < n + m; i++) {
            System.out.print(merged[i] + " ");
        }
    }
}

Python

import heapq

def merge_heaps(a, b):
    # Create a max heap by negating the elements
    max_heap = []
    
    # Insert all elements of first list into the max heap
    for num in a:
        heapq.heappush(max_heap, -num)
    
    # Insert all elements of second list into the max heap
    for num in b:
        heapq.heappush(max_heap, -num)
    
    merged = []
    # Extract elements from the max heap
    while max_heap:
        merged.append(-heapq.heappop(max_heap))
    
    return merged

# Sample Input
a = [10, 5, 6, 2]
b = [12, 7, 9]

merged = merge_heaps(a, b)

for num in merged:
    print(num, end=' ')

JavaScript

function mergeHeaps(a, b) {
    // Max Heap to store all the elements
    let maxHeap = [];

    // Insert all the elements of the first array
    for (let num of a) {
        maxHeap.push(num);
    }

    // Insert all the elements of the second array
    for (let num of b) {
        maxHeap.push(num);
    }

    // Convert array into a max heap
    maxHeap.sort((x, y) => y - x);

    return maxHeap;
}

// Sample Input
let a = [10, 5, 6, 2];
let b = [12, 7, 9];

let merged = mergeHeaps(a, b);

console.log(merged.join(' '));

Output

12 10 9 7 6 5 2

Time Complexity: O((N + M)*log(N + M)), where N is the size of a[] and M is the size of b[].

Since we are fetching one element after the other from given max heaps, the time for this will be O(N + M)
Now for each element, we are doing max heapify on the third heap. This heapify operation for element of the heap will take O(log N+M) each time
Therefore the resultant complexity will be O(N+M)*(log (N+M))

Auxiliary Space: O(N + M), which is the size of the resultant merged binary max heap

[Expected Approach] Merge and then Build Heap - O(N + M) Time and O(N + M) Space:

Another approach is that instead of creating a max heap from the start, flatten the given max heap into arrays and merge them. Then max heapify this merged array.
The benefit of doing so, is that, instead of taking O(log N+M) time everytime to apply heapify operation as shown in above approach, this approach will take only O(N+M) time once to build the final heap.