Given two sorted arrays, we need to merge them with O(1) extra space into a sorted array, when N is the size of the first array, and M is the size of the second array.

**Example**:

Input: arr1[] = {10}; arr2[] = {2, 3};Output: arr1[] = {2} arr2[] = {3, 10}Input: arr1[] = {1, 5, 9, 10, 15, 20}; arr2[] = {2, 3, 8, 13};Output: arr1[] = {1, 2, 3, 5, 8, 9} arr2[] = {10, 13, 15, 20}

We had already discussed two more approaches to solve the above problem in constant space:

- Merge two sorted arrays with O(1) extra space.
- Efficiently merging two sorted arrays with O(1) extra space.

In this article, one more approach using the concept of the heap data structure is discussed without taking any extra space to merge the two sorted arrays.

Below is the detailed approach in steps:

- The idea is to convert the second array into a min-heap first. This can be done in O(M) time complexity.
- After converting the second array to min-heap:
- Start traversing the first array and compare the current element for the first array to top of the created min_heap.
- If the current element in the first array is greater than heap top, swap the current element of the first array with the root of the heap, and heapify the root of the min_heap.
- After performing the above operation for every element of the first array, the first array will now contain first N elements of the sorted merged array.

- Now, the elements remained in the min_heap or the second array are the last M elements of the sorted merged array.
- To arrange them in sorted order, apply in-place heapsort on the second array.

**Note**: We have used built-in STL functions available in C++ to convert array to min_heap, sorting the heap etc. It is recommended to read – Heap in C++ STL | make_heap(), push_heap(), pop_heap(), sort_heap() before moving on to the program.

Below is the implementation of the above approach:

`// C++ program to merge two sorted arrays in ` `// constant space ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to merge two sorted arrays in ` `// constant space ` `void` `mergeArrays(` `int` `* a, ` `int` `n, ` `int` `* b, ` `int` `m) ` `{ ` ` ` ` ` `// Convert second array into a min_heap ` ` ` `// using make_heap() STL function [takes O(m)] ` ` ` `make_heap(b, b + m, greater<` `int` `>()); ` ` ` ` ` `// Start traversing the first array ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` ` ` `// If current element is greater than root ` ` ` `// of min_heap ` ` ` `if` `(a[i] > b[0]) { ` ` ` ` ` `// Pop minimum element from min_heap using ` ` ` `// pop_heap() STL function ` ` ` `// The pop_heap() function removes the minimum element from ` ` ` `// heap and moves it to the end of the container ` ` ` `// converted to heap and reduces heap size by 1 ` ` ` `pop_heap(b, b + m, greater<` `int` `>()); ` ` ` ` ` `// Swapping the elements ` ` ` `int` `tmp = a[i]; ` ` ` `a[i] = b[m - 1]; ` ` ` `b[m - 1] = tmp; ` ` ` ` ` `// Apply push_heap() function on the container ` ` ` `// or array to again reorder it in the ` ` ` `// form of min_heap ` ` ` `push_heap(b, b + m, greater<` `int` `>()); ` ` ` `} ` ` ` `} ` ` ` ` ` `// Convert the second array again into max_heap ` ` ` `// because sort_heap() on min heap sorts the array ` ` ` `// in decreasing order ` ` ` `// This step is [O(m)] ` ` ` `make_heap(b, b + m); ` `// It's a max_heap ` ` ` ` ` `// Sort the second array using sort_heap() function ` ` ` `sort_heap(b, b + m); ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` ` ` `int` `ar1[] = { 1, 5, 9, 10, 15, 20 }; ` ` ` `int` `ar2[] = { 2, 3, 8, 13 }; ` ` ` `int` `m = ` `sizeof` `(ar1) / ` `sizeof` `(ar1[0]); ` ` ` `int` `n = ` `sizeof` `(ar2) / ` `sizeof` `(ar2[0]); ` ` ` `mergeArrays(ar1, m, ar2, n); ` ` ` ` ` `cout << ` `"After Merging :- \nFirst Array: "` `; ` ` ` `for` `(` `int` `i = 0; i < m; i++) ` ` ` `cout << ar1[i] << ` `" "` `; ` ` ` `cout << ` `"\nSecond Array: "` `; ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `cout << ar2[i] << ` `" "` `; ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

After Merging :- First Array: 1 2 3 5 8 9 Second Array: 10 13 15 20

**Time Complexity**: O(N*logM + M*logN)

**Auxiliary Space**: O(1)

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.

## Recommended Posts:

- Merge k sorted linked lists | Set 2 (Using Min Heap)
- Merge two BSTs with constant extra space
- Heap Sort for decreasing order using min heap
- Merge two sorted arrays with O(1) extra space
- Convert min Heap to max Heap
- Sorted subsequence of size 3 in linear time using constant space
- Merge Sort with O(1) extra space merge and O(n lg n) time
- Generate all possible sorted arrays from alternate elements of two given sorted arrays
- Merge two sorted arrays in Python using heapq
- Merge k sorted arrays | Set 2 (Different Sized Arrays)
- Merge two sorted arrays
- Median of two sorted arrays with different sizes in O(log(min(n, m)))
- Sort an array according to absolute difference with a given value "using constant extra space"
- Kth smallest element in the array using constant space when array can't be modified
- Efficiently merging two sorted arrays with O(1) extra space
- Efficiently merging two sorted arrays with O(1) extra space and O(NlogN + MlogM)
- Merge K sorted arrays | Set 3 ( Using Divide and Conquer Approach )
- Maximise the number of toys that can be purchased with amount K using min Heap
- Merge K sorted Doubly Linked List in Sorted Order
- Rearrange positive and negative numbers with constant extra space

This article is contributed by **Harsh Agrawal**. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.