# Merge two binary Max Heaps

Last Updated : 31 Oct, 2023

Given two binary max heaps as arrays, the task is to merge the given heaps.

Examples :

Input: a = {10, 5, 6, 2}, b = {12, 7, 9}
Output: {12, 10, 9, 2, 5, 7, 6}

Input: a = {2, 5, 1, 9, 12}, b = {3, 7, 4, 10}
Output: {12, 10, 7, 9, 5, 3, 1, 4, 2}

Recommended Practice

Approach:To solve the problem follow the below idea:

Create an array to store the result. Copy both given arrays one by one into result. Once all the elements have been copied, then call standard build heap to construct full merged max heap.

Follow the given steps to solve the problem:

• Create an array merged of size N+M
• Copy elements of both the arrays in the array merged
• Build Max-Heap of this array
• Print elements of the Max-Heap

Below is the implementation of the above approach:

## C++

 `// C++ program to merge two max heaps.` `#include ` `using` `namespace` `std;`   `// Standard heapify function to heapify a` `// subtree rooted under idx. It assumes` `// that subtrees of node are already heapified.` `void` `maxHeapify(``int` `arr[], ``int` `N, ``int` `idx)` `{` `    ``// Find largest of node and its children` `    ``if` `(idx >= N)` `        ``return``;`   `    ``int` `l = 2 * idx + 1;` `    ``int` `r = 2 * idx + 2;` `    ``int` `max = idx;` `    ``if` `(l < N && arr[l] > arr[idx])` `        ``max = l;` `    ``if` `(r < N && arr[r] > arr[max])` `        ``max = r;`   `    ``// Put maximum value at root and` `    ``// recur for the child with the` `    ``// maximum value` `    ``if` `(max != idx) {` `        ``swap(arr[max], arr[idx]);` `        ``maxHeapify(arr, N, max);` `    ``}` `}`   `// Builds a max heap of given arr[0..n-1]` `void` `buildMaxHeap(``int` `arr[], ``int` `N)` `{` `    ``// building the heap from first non-leaf` `    ``// node by calling max heapify function` `    ``for` `(``int` `i = N / 2 - 1; i >= 0; i--)` `        ``maxHeapify(arr, N, i);` `}`   `// Merges max heaps a[] and b[] into merged[]` `void` `mergeHeaps(``int` `merged[], ``int` `a[], ``int` `b[], ``int` `N,` `                ``int` `M)` `{` `    ``// Copy elements of a[] and b[] one by one` `    ``// to merged[]` `    ``for` `(``int` `i = 0; i < N; i++)` `        ``merged[i] = a[i];` `    ``for` `(``int` `i = 0; i < M; i++)` `        ``merged[N + i] = b[i];`   `    ``// build heap for the modified array of` `    ``// size n+m` `    ``buildMaxHeap(merged, N + M);` `}`   `// Driver's code` `int` `main()` `{` `    ``int` `a[] = { 10, 5, 6, 2 };` `    ``int` `b[] = { 12, 7, 9 };`   `    ``int` `N = ``sizeof``(a) / ``sizeof``(a[0]);` `    ``int` `M = ``sizeof``(b) / ``sizeof``(b[0]);`   `    ``int` `merged[N + M];`   `    ``// Function call` `    ``mergeHeaps(merged, a, b, N, M);`   `    ``for` `(``int` `i = 0; i < N + M; i++)` `        ``cout << merged[i] << ``" "``;`   `    ``return` `0;` `}`

## C

 `// C program to merge two max heaps.` `#include `   `void` `swap(``int``* a, ``int``* b)` `{` `    ``int` `tmp = *a;` `    ``*a = *b;` `    ``*b = tmp;` `}`   `// Standard heapify function to heapify a` `// subtree rooted under idx. It assumes` `// that subtrees of node are already heapified.` `void` `maxHeapify(``int` `arr[], ``int` `N, ``int` `idx)` `{` `    ``// Find largest of node and its children` `    ``if` `(idx >= N)` `        ``return``;`   `    ``int` `l = 2 * idx + 1;` `    ``int` `r = 2 * idx + 2;` `    ``int` `max = idx;` `    ``if` `(l < N && arr[l] > arr[idx])` `        ``max = l;` `    ``if` `(r < N && arr[r] > arr[max])` `        ``max = r;`   `    ``// Put maximum value at root and` `    ``// recur for the child with the` `    ``// maximum value` `    ``if` `(max != idx) {` `        ``swap(&arr[max], &arr[idx]);` `        ``maxHeapify(arr, N, max);` `    ``}` `}`   `// Builds a max heap of given arr[0..n-1]` `void` `buildMaxHeap(``int` `arr[], ``int` `N)` `{` `    ``// building the heap from first non-leaf` `    ``// node by calling max heapify function` `    ``for` `(``int` `i = N / 2 - 1; i >= 0; i--)` `        ``maxHeapify(arr, N, i);` `}`   `// Merges max heaps a[] and b[] into merged[]` `void` `mergeHeaps(``int` `merged[], ``int` `a[], ``int` `b[], ``int` `N,` `                ``int` `M)` `{` `    ``// Copy elements of a[] and b[] one by one` `    ``// to merged[]` `    ``for` `(``int` `i = 0; i < N; i++)` `        ``merged[i] = a[i];` `    ``for` `(``int` `i = 0; i < M; i++)` `        ``merged[N + i] = b[i];`   `    ``// build heap for the modified array of` `    ``// size n+m` `    ``buildMaxHeap(merged, N + M);` `}`   `// Driver's code` `int` `main()` `{` `    ``int` `a[] = { 10, 5, 6, 2 };` `    ``int` `b[] = { 12, 7, 9 };`   `    ``int` `N = ``sizeof``(a) / ``sizeof``(a[0]);` `    ``int` `M = ``sizeof``(b) / ``sizeof``(b[0]);`   `    ``int` `merged[N + M];`   `    ``// Function call` `    ``mergeHeaps(merged, a, b, N, M);`   `    ``for` `(``int` `i = 0; i < N + M; i++)` `        ``printf``(``"%d "``, merged[i]);`   `    ``return` `0;` `}`

## Java

 `// Java program to merge two max heaps.`   `class` `GfG {`   `    ``// Standard heapify function to heapify a` `    ``// subtree rooted under idx. It assumes` `    ``// that subtrees of node are already heapified.` `    ``public` `static` `void` `maxHeapify(``int``[] arr, ``int` `N, ``int` `i)` `    ``{` `        ``// Find largest of node and its children` `        ``if` `(i >= N) {` `            ``return``;` `        ``}` `        ``int` `l = i * ``2` `+ ``1``;` `        ``int` `r = i * ``2` `+ ``2``;` `        ``int` `max;` `        ``if` `(l < N && arr[l] > arr[i]) {` `            ``max = l;` `        ``}` `        ``else` `            ``max = i;` `        ``if` `(r < N && arr[r] > arr[max]) {` `            ``max = r;` `        ``}`   `        ``// Put maximum value at root and` `        ``// recur for the child with the` `        ``// maximum value` `        ``if` `(max != i) {` `            ``int` `temp = arr[max];` `            ``arr[max] = arr[i];` `            ``arr[i] = temp;` `            ``maxHeapify(arr, N, max);` `        ``}` `    ``}`   `    ``// Merges max heaps a[] and b[] into merged[]` `    ``public` `static` `void` `mergeHeaps(``int``[] arr, ``int``[] a,` `                                  ``int``[] b, ``int` `N, ``int` `M)` `    ``{` `        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``arr[i] = a[i];` `        ``}` `        ``for` `(``int` `i = ``0``; i < M; i++) {` `            ``arr[N + i] = b[i];` `        ``}` `        ``N = N + M;`   `        ``// Builds a max heap of given arr[0..n-1]` `        ``for` `(``int` `i = N / ``2` `- ``1``; i >= ``0``; i--) {` `            ``maxHeapify(arr, N, i);` `        ``}` `    ``}`   `    ``// Driver's Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int``[] a = { ``10``, ``5``, ``6``, ``2` `};` `        ``int``[] b = { ``12``, ``7``, ``9` `};` `        ``int` `N = a.length;` `        ``int` `M = b.length;`   `        ``int``[] merged = ``new` `int``[M + N];`   `        ``// Function call` `        ``mergeHeaps(merged, a, b, N, M);`   `        ``for` `(``int` `i = ``0``; i < M + N; i++)` `            ``System.out.print(merged[i] + ``" "``);` `        ``System.out.println();` `    ``}` `}`

## Python3

 `# Python3 program to merge two Max heaps.`   `# Standard heapify function to heapify a` `# subtree rooted under idx. It assumes that` `# subtrees of node are already heapified.`     `def` `MaxHeapify(arr, N, idx):`   `    ``# Find largest of node and` `    ``# its children` `    ``if` `idx >``=` `N:` `        ``return` `    ``l ``=` `2` `*` `idx ``+` `1` `    ``r ``=` `2` `*` `idx ``+` `2` `    ``Max` `=` `0` `    ``if` `l < N ``and` `arr[l] > arr[idx]:` `        ``Max` `=` `l` `    ``else``:` `        ``Max` `=` `idx` `    ``if` `r < N ``and` `arr[r] > arr[``Max``]:` `        ``Max` `=` `r`   `    ``# Put Maximum value at root and` `    ``# recur for the child with the` `    ``# Maximum value` `    ``if` `Max` `!``=` `idx:` `        ``arr[``Max``], arr[idx] ``=` `arr[idx], arr[``Max``]` `        ``MaxHeapify(arr, N, ``Max``)`   `# Builds a Max heap of given arr[0..n-1]`     `def` `buildMaxHeap(arr, N):`   `    ``# building the heap from first non-leaf` `    ``# node by calling Max heapify function` `    ``for` `i ``in` `range``(``int``(N ``/` `2``) ``-` `1``, ``-``1``, ``-``1``):` `        ``MaxHeapify(arr, N, i)`   `# Merges Max heaps a[] and b[] into merged[]`     `def` `mergeHeaps(merged, a, b, N, M):`   `    ``# Copy elements of a[] and b[] one` `    ``# by one to merged[]` `    ``for` `i ``in` `range``(N):` `        ``merged[i] ``=` `a[i]` `    ``for` `i ``in` `range``(M):` `        ``merged[N ``+` `i] ``=` `b[i]`   `    ``# build heap for the modified` `    ``# array of size n+m` `    ``buildMaxHeap(merged, N ``+` `M)`     `# Driver's code` `if` `__name__ ``=``=` `'__main__'``:` `    ``a ``=` `[``10``, ``5``, ``6``, ``2``]` `    ``b ``=` `[``12``, ``7``, ``9``]`   `    ``N ``=` `len``(a)` `    ``M ``=` `len``(b)`   `    ``merged ``=` `[``0``] ``*` `(M ``+` `N)`   `    ``# Function call` `    ``mergeHeaps(merged, a, b, N, M)`   `    ``for` `i ``in` `range``(N ``+` `M):` `        ``print``(merged[i], end``=``" "``)`   `# This code is contributed by PranchalK`

## C#

 `// C# program to merge two max heaps.` `using` `System;`   `class` `GfG {`   `    ``// Standard heapify function to heapify a` `    ``// subtree rooted under idx. It assumes` `    ``// that subtrees of node are already heapified.` `    ``public` `static` `void` `maxHeapify(``int``[] arr, ``int` `N, ``int` `i)` `    ``{` `        ``// Find largest of node` `        ``// and its children` `        ``if` `(i >= N) {` `            ``return``;` `        ``}` `        ``int` `l = i * 2 + 1;` `        ``int` `r = i * 2 + 2;` `        ``int` `max;` `        ``if` `(l < N && arr[l] > arr[i]) {` `            ``max = l;` `        ``}` `        ``else` `            ``max = i;` `        ``if` `(r < N && arr[r] > arr[max]) {` `            ``max = r;` `        ``}`   `        ``// Put maximum value at root and` `        ``// recur for the child with the` `        ``// maximum value` `        ``if` `(max != i) {` `            ``int` `temp = arr[max];` `            ``arr[max] = arr[i];` `            ``arr[i] = temp;` `            ``maxHeapify(arr, N, max);` `        ``}` `    ``}`   `    ``// Merges max heaps a[] and b[] into merged[]` `    ``public` `static` `void` `mergeHeaps(``int``[] arr, ``int``[] a,` `                                  ``int``[] b, ``int` `N, ``int` `M)` `    ``{` `        ``for` `(``int` `i = 0; i < N; i++) {` `            ``arr[i] = a[i];` `        ``}` `        ``for` `(``int` `i = 0; i < M; i++) {` `            ``arr[n + i] = b[i];` `        ``}` `        ``N = N + M;`   `        ``// Builds a max heap of given arr[0..n-1]` `        ``for` `(``int` `i = N / 2 - 1; i >= 0; i--) {` `            ``maxHeapify(arr, N, i);` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[] a = { 10, 5, 6, 2 };` `        ``int``[] b = { 12, 7, 9 };` `        ``int` `N = a.Length;` `        ``int` `M = b.Length;`   `        ``int``[] merged = ``new` `int``[M + N];`   `        ``mergeHeaps(merged, a, b, N, M);`   `        ``for` `(``int` `i = 0; i < M + N; i++)` `            ``Console.Write(merged[i] + ``" "``);` `        ``Console.WriteLine();` `    ``}` `}` `// This code is contributed by nitin mittal`

## Javascript

 `// javascript program to merge two max heaps.`     `    ``// Standard heapify function to heapify a` `    ``// subtree rooted under idx. It assumes` `    ``// that subtrees of node are already heapified.` `    ``function` `maxHeapify(arr , n , i)` `    ``{` `    `  `        ``// Find largest of node and its children` `        ``if` `(i >= n) {` `            ``return``;` `        ``}` `        ``var` `l = i * 2 + 1;` `        ``var` `r = i * 2 + 2;` `        ``var` `max;` `        ``if` `(l < n && arr[l] > arr[i]) {` `            ``max = l;` `        ``} ``else` `            ``max = i;` `        ``if` `(r < n && arr[r] > arr[max]) {` `            ``max = r;` `        ``}`   `        ``// Put maximum value at root and` `        ``// recur for the child with the` `        ``// maximum value` `        ``if` `(max != i) {` `            ``var` `temp = arr[max];` `            ``arr[max] = arr[i];` `            ``arr[i] = temp;` `            ``maxHeapify(arr, n, max);` `        ``}` `    ``}`   `    ``// Merges max heaps a and b into merged` `    ``function` `mergeHeaps(arr,  a,  b , n , m) {` `        ``for` `(``var` `i = 0; i < n; i++) {` `            ``arr[i] = a[i];` `        ``}` `        ``for` `(``var` `i = 0; i < m; i++) {` `            ``arr[n + i] = b[i];` `        ``}` `        ``n = n + m;`   `        ``// Builds a max heap of given arr[0..n-1]` `        ``for` `(``var` `i = parseInt(n / 2 - 1); i >= 0; i--) {` `            ``maxHeapify(arr, n, i);` `        ``}` `    ``}`   `    ``// Driver Code` `        ``var` `a = [ 10, 5, 6, 2 ];` `        ``var` `b = [ 12, 7, 9 ];` `        ``var` `n = a.length;` `        ``var` `m = b.length;`   `        ``var` `merged = Array(m + n).fill(0);`   `        ``mergeHeaps(merged, a, b, n, m);`   `        ``for` `(``var` `i = 0; i < m + n; i++)` `            ``document.write(merged[i] + ``" "``);`   `// This code is contributed by umadevi9616`

## PHP

 ` ``\$arr``[``\$largest``])` `        ``\$largest` `= ``\$l``;` ` `  `    ``// If right child is larger than largest so far` `    ``if` `(``\$r` `< ``\$N` `&& ``\$arr``[``\$r``] > ``\$arr``[``\$largest``])` `        ``\$largest` `= ``\$r``;` ` `  `    ``// If largest is not root` `    ``if` `(``\$largest` `!= ``\$i``)` `    ``{` `        ``\$swap` `= ``\$arr``[``\$i``];` `        ``\$arr``[``\$i``] = ``\$arr``[``\$largest``];` `        ``\$arr``[``\$largest``] = ``\$swap``;` ` `  `        ``// Recursively heapify the affected sub-tree` `        ``maxHeapify(``\$arr``, ``\$N``, ``\$largest``);` `    ``}` `}`   `function` `BuildMaxHeap(&``\$arr``, ``\$N``)` `{` `      ``for` `(``\$i` `= (``\$N` `/ 2) - 1; ``\$i` `>= 0; ``\$i``--)` `        ``maxHeapify(``\$arr``, ``\$N``, ``\$i``);` `}` `    `  `    ``// Driver's code` `    ``\$arrA` `= ``array``(10, 5, 6, 2);` `    ``\$arrB` `= ``array``(12, 7, 9);` `      ``\$N` `= sizeof(``\$arrA``)/sizeof(``\$arrA``[0]);` `    ``\$M` `= sizeof(``\$arrB``)/sizeof(``\$arrB``[0]);` `     `  `    ``\$mergedArray` `= ``array``();` `    `  `    ``// Push all the elements of array ` `    ``// arrA and arrB in mergedArray` `    ``for``(``\$i` `= 0; ``\$i` `< ``\$N``; ``\$i``++)` `    ``array_push``(``\$mergedArray``, ``\$arrA``[``\$i``]);` `      `  `      ``for``(``\$i` `= 0; ``\$i` `< ``\$M``; ``\$i``++)` `    ``array_push``(``\$mergedArray``, ``\$arrB``[``\$i``]);` `   `  `    ``// Function call` `      ``BuildMaxHeap(``\$mergedArray``, ``\$N` `+ ``\$M``);` `    `  `      ``for` `(``\$i` `= 0; ``\$i` `< ``\$N` `+ ``\$M``; ++``\$i``)` `           ``echo` `(``\$mergedArray``[``\$i``].``" "``);` `?>`

Output

```12 10 9 2 5 7 6

```

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

Another Optimised Approach- Time Complexity: O(N + M) & Auxiliary Space: O(1)

Approach:

1. Initialize two indices, `i` and `j`, to track the current elements of arrays `a` and `b` respectively.

2. Use two boolean variables, `vis_next1` and `vis_next2`, to keep track of whether the next element of array `a` or `b` has been visited or not.

3. Iterate until either array `a` or array `b` is exhausted.

4. Compare current and the next elements of arrays `a` and `b` and select the maximum element among them.

5. Print the maximum element and update the indices and boolean variables accordingly.

6. If all elements of array `a` are processed, print the remaining elements of array `b`, and vice versa.

Below is the implementation of the above approach:

## C++

 `#include ` `using` `namespace` `std;`   `void` `mergeHeaps(``int` `a[], ``int` `b[], ``int` `n, ``int` `m) {` `    ``// vis_next1 & vis_next2 tells us next element of array "a" ` `  ``// and array "b" is visited or not respectively.` `    ``bool` `vis_next1 = ``false``, vis_next2 = ``false``;` `    ``// i & j is current index of array "a" and "b" respectively.` `    ``int` `i = 0, j = 0;`   `    ``// Loop until end of array "a" or "b"` `    ``while` `(i != n && j != m) {` `        ``int` `max1 = i, max2 = j;`   `        ``// Check if next element of array "a" is greater than ` `      ``// current element` `        ``if` `(i + 1 != n && !vis_next1 && a[i + 1] > a[i])` `            ``max1 = i + 1;`   `        ``// Check if next element of array "b" is greater than ` `      ``// current element` `        ``if` `(j + 1 != m && !vis_next2 && b[j + 1] > b[j])` `            ``max2 = j + 1;`   `        ``// Compare the maximum elements from both arrays` `        ``if` `(a[max1] > b[max2]) {` `            ``cout << a[max1] << ``" "``;`   `            ``// Update index and vis_next1 for array "a"` `            ``if` `(max1 == i + 1)` `                ``vis_next1 = ``true``;` `            ``else` `{` `                ``if` `(vis_next1) {` `                    ``i += 2;` `                    ``vis_next1 = ``false``;` `                ``}` `                ``else` `                    ``i++;` `            ``}` `        ``}` `        ``else` `{` `            ``cout << b[max2] << ``" "``;`   `            ``// Update index and vis_next2 for array "b"` `            ``if` `(max2 == j + 1)` `                ``vis_next2 = ``true``;` `            ``else` `{` `                ``if` `(vis_next2) {` `                    ``j += 2;` `                    ``vis_next2 = ``false``;` `                ``}` `                ``else` `                    ``j++;` `            ``}` `        ``}` `    ``}`   `    ``// Print remaining elements of array "b" if array "a" is` `  ``// exhausted` `    ``if` `(i == n) {` `        ``while` `(j != m) {` `            ``cout << b[j] << ``" "``;` `            ``j++;` `            ``if` `(vis_next2) {` `                ``vis_next2 = ``false``;` `                ``j++;` `            ``}` `        ``}` `    ``}` `    ``// Print remaining elements of array "a" if array "b" is` `  ``// exhausted` `    ``else` `{` `        ``while` `(i != n) {` `            ``cout << a[i] << ``" "``;` `            ``i++;` `            ``if` `(vis_next1) {` `                ``vis_next1 = ``false``;` `                ``i++;` `            ``}` `        ``}` `    ``}` `    ``return``;` `}`   `// Driver's code` `int` `main() {` `    ``int` `a[] = { 10, 5, 6, 2 };` `    ``int` `b[] = { 12, 7, 9 };`   `    ``int` `N = ``sizeof``(a) / ``sizeof``(a[0]);` `    ``int` `M = ``sizeof``(b) / ``sizeof``(b[0]);`   `    ``// Function call` `    ``mergeHeaps(a, b, N, M);`   `    ``return` `0;` `}`

## Java

 `import` `java.io.*;`   `class` `GFG {` `  ``static` `void` `mergeHeaps(``int` `a[], ``int` `b[], ``int` `n, ``int` `m) {` `    ``// vis_next1 & vis_next2 tells us next element of array "a" ` `    ``// and array "b" is visited or not respectively.` `    ``boolean` `vis_next1 = ``false``, vis_next2 = ``false``;` `    ``// i & j is current index of array "a" and "b" respectively.` `    ``int` `i = ``0``, j = ``0``;`   `    ``// Loop until end of array "a" or "b"` `    ``while` `(i != n && j != m) {` `        ``int` `max1 = i, max2 = j;`   `        ``// Check if next element of array "a" is greater than ` `      ``// current element` `        ``if` `(i + ``1` `!= n && !vis_next1 && a[i + ``1``] > a[i])` `            ``max1 = i + ``1``;`   `        ``// Check if next element of array "b" is greater than ` `      ``// current element` `        ``if` `(j + ``1` `!= m && !vis_next2 && b[j + ``1``] > b[j])` `            ``max2 = j + ``1``;`   `        ``// Compare the maximum elements from both arrays` `        ``if` `(a[max1] > b[max2]) {` `            ``System.out.print(a[max1]+``" "``);`   `            ``// Update index and vis_next1 for array "a"` `            ``if` `(max1 == i + ``1``)` `                ``vis_next1 = ``true``;` `            ``else` `{` `                ``if` `(vis_next1) {` `                    ``i += ``2``;` `                    ``vis_next1 = ``false``;` `                ``}` `                ``else` `                    ``i++;` `            ``}` `        ``}` `        ``else` `{` `            ``System.out.print(b[max2]+``" "``);`   `            ``// Update index and vis_next2 for array "b"` `            ``if` `(max2 == j + ``1``)` `                ``vis_next2 = ``true``;` `            ``else` `{` `                ``if` `(vis_next2) {` `                    ``j += ``2``;` `                    ``vis_next2 = ``false``;` `                ``}` `                ``else` `                    ``j++;` `            ``}` `        ``}` `    ``}`   `    ``// Print remaining elements of array "b" if array "a" is exhausted` `    ``if` `(i == n) {` `        ``while` `(j != m) {` `            ``System.out.print(b[j]+``" "``);` `            ``j++;` `            ``if` `(vis_next2) {` `                ``vis_next2 = ``false``;` `                ``j++;` `            ``}` `        ``}` `    ``}` `    ``// Print remaining elements of array "a" if array "b" ` `    ``// is exhausted` `    ``else` `{` `        ``while` `(i != n) {` `            ``System.out.print(a[i]+``" "``);` `            ``i++;` `            ``if` `(vis_next1) {` `                ``vis_next1 = ``false``;` `                ``i++;` `            ``}` `        ``}` `    ``}` `    ``return``;` `}` `public` `static` `void` `main (String[] args) {` `    ``int` `a[] = { ``10``, ``5``, ``6``, ``2` `};` `    ``int` `b[] = { ``12``, ``7``, ``9` `};`   `    ``int` `N = a.length;` `    ``int` `M = b.length;`   `    ``// Function call` `    ``mergeHeaps(a, b, N, M);`   `   ``}` `}` `//this code contributed by shubhamrajput6156`

## Python3

 `def` `mergeHeaps(a, b, n, m):` `    ``# vis_next1 & vis_next2 tells us if the next element of array "a" ` `    ``# and array "b" is visited or not, respectively.` `    ``vis_next1 ``=` `False` `    ``vis_next2 ``=` `False` `    ``# i & j are the current indices of arrays "a" and "b", respectively.` `    ``i ``=` `0` `    ``j ``=` `0`   `    ``# Loop until the end of array "a" or "b"` `    ``while` `i !``=` `n ``and` `j !``=` `m:` `        ``max1 ``=` `i` `        ``max2 ``=` `j`   `        ``# Check if the next element of array "a" is greater than ` `        ``# the current element` `        ``if` `i ``+` `1` `!``=` `n ``and` `not` `vis_next1 ``and` `a[i ``+` `1``] > a[i]:` `            ``max1 ``=` `i ``+` `1`   `        ``# Check if the next element of array "b" is greater than ` `        ``# the current element` `        ``if` `j ``+` `1` `!``=` `m ``and` `not` `vis_next2 ``and` `b[j ``+` `1``] > b[j]:` `            ``max2 ``=` `j ``+` `1`   `        ``# Compare the maximum elements from both arrays` `        ``if` `a[max1] > b[max2]:` `            ``print``(a[max1], end``=``" "``)`   `            ``# Update index and vis_next1 for array "a"` `            ``if` `max1 ``=``=` `i ``+` `1``:` `                ``vis_next1 ``=` `True` `            ``else``:` `                ``if` `vis_next1:` `                    ``i ``+``=` `2` `                    ``vis_next1 ``=` `False` `                ``else``:` `                    ``i ``+``=` `1` `        ``else``:` `            ``print``(b[max2], end``=``" "``)`   `            ``# Update index and vis_next2 for array "b"` `            ``if` `max2 ``=``=` `j ``+` `1``:` `                ``vis_next2 ``=` `True` `            ``else``:` `                ``if` `vis_next2:` `                    ``j ``+``=` `2` `                    ``vis_next2 ``=` `False` `                ``else``:` `                    ``j ``+``=` `1`   `    ``# Print remaining elements of array "b" if array "a" is exhausted` `    ``if` `i ``=``=` `n:` `        ``while` `j !``=` `m:` `            ``print``(b[j], end``=``" "``)` `            ``j ``+``=` `1` `            ``if` `vis_next2:` `                ``vis_next2 ``=` `False` `                ``j ``+``=` `1` `    ``# Print remaining elements of array "a" if array "b" is exhausted` `    ``else``:` `        ``while` `i !``=` `n:` `            ``print``(a[i], end``=``" "``)` `            ``i ``+``=` `1` `            ``if` `vis_next1:` `                ``vis_next1 ``=` `False` `                ``i ``+``=` `1`   `# Driver's code` `if` `__name__ ``=``=` `"__main__"``:` `    ``a ``=` `[``10``, ``5``, ``6``, ``2``]` `    ``b ``=` `[``12``, ``7``, ``9``]` `    ``N ``=` `len``(a)` `    ``M ``=` `len``(b)`   `    ``# Function call` `    ``mergeHeaps(a, b, N, M)` `    `  `# This code is contributed by shivamgupta310570`

## C#

 `using` `System;`   `class` `Program` `{` `    ``static` `void` `MergeHeaps(``int``[] a, ``int``[] b, ``int` `n, ``int` `m)` `    ``{` `        ``bool` `visNext1 = ``false``; ``// Tracks if the next element of array "a" is visited` `        ``bool` `visNext2 = ``false``; ``// Tracks if the next element of array "b" is visited` `        ``int` `i = 0; ``// Current index for array "a"` `        ``int` `j = 0; ``// Current index for array "b"`   `        ``while` `(i != n && j != m)` `        ``{` `            ``int` `max1 = i;` `            ``int` `max2 = j;`   `            ``// Check if the next element of array "a" is greater than the current element` `            ``if` `(i + 1 != n && !visNext1 && a[i + 1] > a[i])` `                ``max1 = i + 1;`   `            ``// Check if the next element of array "b" is greater than the current element` `            ``if` `(j + 1 != m && !visNext2 && b[j + 1] > b[j])` `                ``max2 = j + 1;`   `            ``if` `(a[max1] > b[max2])` `            ``{` `                ``Console.Write(a[max1] + ``" "``); ``// Print the greater element from array "a"`   `                ``if` `(max1 == i + 1)` `                    ``visNext1 = ``true``;` `                ``else` `                ``{` `                    ``if` `(visNext1)` `                    ``{` `                        ``i += 2;` `                        ``visNext1 = ``false``;` `                    ``}` `                    ``else` `                        ``i++;` `                ``}` `            ``}` `            ``else` `            ``{` `                ``Console.Write(b[max2] + ``" "``); ``// Print the greater element from array "b"`   `                ``if` `(max2 == j + 1)` `                    ``visNext2 = ``true``;` `                ``else` `                ``{` `                    ``if` `(visNext2)` `                    ``{` `                        ``j += 2;` `                        ``visNext2 = ``false``;` `                    ``}` `                    ``else` `                        ``j++;` `                ``}` `            ``}` `        ``}`   `        ``if` `(i == n)` `        ``{` `            ``// Print the remaining elements of array "b" if array "a" is exhausted` `            ``while` `(j != m)` `            ``{` `                ``Console.Write(b[j] + ``" "``);` `                ``j++;` `                ``if` `(visNext2)` `                ``{` `                    ``visNext2 = ``false``;` `                    ``j++;` `                ``}` `            ``}` `        ``}` `        ``else` `        ``{` `            ``// Print the remaining elements of array "a" if array "b" is exhausted` `            ``while` `(i != n)` `            ``{` `                ``Console.Write(a[i] + ``" "``);` `                ``i++;` `                ``if` `(visNext1)` `                ``{` `                    ``visNext1 = ``false``;` `                    ``i++;` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``static` `void` `Main()` `    ``{` `        ``int``[] a = { 10, 5, 6, 2 };` `        ``int``[] b = { 12, 7, 9 };`   `        ``int` `n = a.Length;` `        ``int` `m = b.Length;`   `        ``MergeHeaps(a, b, n, m);` `    ``}` `}`

## Javascript

 `function` `mergeHeaps(a, b, n, m) {` `    ``// vis_next1 & vis_next2 tells us next element of array "a"` `    ``// and array "b" is visited or not respectively.` `    ``let vis_next1 = ``false``;` `    ``let vis_next2 = ``false``;` `    ``// i & j is current index of array "a" and "b" respectively` `    ``let i = 0;` `    ``let j = 0;` `    `  `    ``// Loop until end of array "a" or "b"` `    ``while` `(i !== n && j !== m) {` `        ``let max1 = i;` `        ``let max2 = j;`   `        ``// Check if next element of array "a" is greater than ` `        ``// current element` `        ``if` `(i + 1 !== n && !vis_next1 && a[i + 1] > a[i])` `            ``max1 = i + 1;`   `        ``// Check if next element of array "b" is greater than ` `        ``// current element` `        ``if` `(j + 1 !== m && !vis_next2 && b[j + 1] > b[j])` `            ``max2 = j + 1;`   `        ``// Compare the maximum elements from both arrays` `        ``if` `(a[max1] > b[max2]) {` `            ``console.log(a[max1] + ``" "``);`   `            ``// Update index and vis_next1 for array "a"` `            ``if` `(max1 === i + 1)` `                ``vis_next1 = ``true``;` `            ``else` `{` `                ``if` `(vis_next1) {` `                    ``i += 2;` `                    ``vis_next1 = ``false``;` `                ``}` `                ``else` `                    ``i++;` `            ``}` `        ``}` `        ``else` `{` `            ``console.log(b[max2] + ``" "``);`   `            ``// Update index and vis_next2 for array "b"` `            ``if` `(max2 === j + 1)` `                ``vis_next2 = ``true``;` `            ``else` `{` `                ``if` `(vis_next2) {` `                    ``j += 2;` `                    ``vis_next2 = ``false``;` `                ``}` `                ``else` `                    ``j++;` `            ``}` `        ``}` `    ``}`   `    ``// Print remaining elements of array "b" if array "a" is` `    ``// exhausted` `    ``if` `(i === n) {` `        ``while` `(j !== m) {` `            ``console.log(b[j] + ``" "``);` `            ``j++;` `            ``if` `(vis_next2) {` `                ``vis_next2 = ``false``;` `                ``j++;` `            ``}` `        ``}` `    ``}` `    ``// Print remaining elements of array "a" if array "b" is` `    ``// exhausted` `    ``else` `{` `        ``while` `(i !== n) {` `            ``console.log(a[i] + ``" "``);` `            ``i++;` `            ``if` `(vis_next1) {` `                ``vis_next1 = ``false``;` `                ``i++;` `            ``}` `        ``}` `    ``}` `}`   `// Driver's code` `const a = [10, 5, 6, 2];` `const b = [12, 7, 9];` `const N = a.length;` `const M = b.length;`   `// Function call` `mergeHeaps(a, b, N, M);`

Output

`12 10 9 7 5 6 2 `

Time Complexity: O(N + M)
Auxiliary Space: O(1)

Previous
Next