# Efficiently merging two sorted arrays with O(1) extra space

Given two sorted arrays, we need to merge them in O((n+m)*log(n+m)) time 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: ar1[] = {10};
ar2[] = {2, 3};
Output: ar1[] = {2}
ar2[] = {3, 10}

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

We have discussed a quadratic time solution in the below post.

In this post, a better solution is discussed.

The idea: We start comparing elements that are far from each other rather than adjacent.
For every pass, we calculate the gap and compare the elements towards the right of the gap. Every pass, the gap reduces to the ceiling value of dividing by 2.

Examples:

```First example:
a1[] = {3 27 38 43},
a2[] = {9 10 82}
gap =  ceiling of n/2 = 4
[This gap is for whole merged array]
3 27 38 43   9 10 82
3 27 38 43   9 10 82
3 10 38 43   9 27 82

gap = 2:
3 10 38 43   9 27 82
3 10 38 43   9 27 82
3 10 38 43   9 27 82
3 10 9 43   38 27 82
3 10 9 27   38 43 82

gap = 1:
3 10 9 27   38 43 82
3 10 9 27   38 43 82
3 9 10 27   38 43 82
3 9 10 27   38 43 82
3 9 10 27   38 43 82
3 9 10 27   38 43 82
Output : 3 9 10 27 38 43 82

Second Example:
a1[] = {10 27 38 43 82},
a2[] = {3 9}
10 27 38 43 82   3 9
10 27 38 43 82   3 9
10 3 38 43 82   27 9
10 3 9 43 82   27 38

gap = 2:
10 3 9 43 82   27 38
9 3 10 43 82   27 38
9 3 10 43 82   27 38
9 3 10 43 82   27 38
9 3 10 27 82   43 38
9 3 10 27 38   43 82

gap = 1
9 3 10 27 38   43 82
3 9 10 27 38   43 82
3 9 10 27 38   43 82
3 9 10 27 38   43 82
3 9 10 27 38   43 82
3 9 10 27 38   43 82

Output : 3 9 10 27 38   43 82
```

Below is the implementation of the above idea:

## C++

 `// Merging two sorted arrays with O(1)` `// extra space` `#include ` `using` `namespace` `std;`   `// Function to find next gap.` `int` `nextGap(``int` `gap)` `{` `    ``if` `(gap <= 1)` `        ``return` `0;` `    ``return` `(gap / 2) + (gap % 2);` `}`   `void` `merge(``int``* arr1, ``int``* arr2, ``int` `n, ``int` `m)` `{` `    ``int` `i, j, gap = n + m;` `    ``for` `(gap = nextGap(gap); gap > 0; gap = nextGap(gap)) {` `        ``// comparing elements in the first array.` `        ``for` `(i = 0; i + gap < n; i++)` `            ``if` `(arr1[i] > arr1[i + gap])` `                ``swap(arr1[i], arr1[i + gap]);`   `        ``// comparing elements in both arrays.` `        ``for` `(j = gap > n ? gap - n : 0; i < n && j < m;` `             ``i++, j++)` `            ``if` `(arr1[i] > arr2[j])` `                ``swap(arr1[i], arr2[j]);`   `        ``if` `(j < m) {` `            ``// comparing elements in the second array.` `            ``for` `(j = 0; j + gap < m; j++)` `                ``if` `(arr2[j] > arr2[j + gap])` `                    ``swap(arr2[j], arr2[j + gap]);` `        ``}` `    ``}` `}`   `// Driver code` `int` `main()` `{` `    ``int` `a1[] = { 10, 27, 38, 43, 82 };` `    ``int` `a2[] = { 3, 9 };` `    ``int` `n = ``sizeof``(a1) / ``sizeof``(``int``);` `    ``int` `m = ``sizeof``(a2) / ``sizeof``(``int``);`   `    ``// Function Call` `    ``merge(a1, a2, n, m);`   `    ``printf``(``"First Array: "``);` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``printf``(``"%d "``, a1[i]);`   `    ``printf``(``"\nSecond Array: "``);` `    ``for` `(``int` `i = 0; i < m; i++)` `        ``printf``(``"%d "``, a2[i]);` `    ``printf``(``"\n"``);` `    ``return` `0;` `}`

## Java

 `// Java program for Merging two sorted arrays` `// with O(1) extra space`   `public` `class` `MergeTwoSortedArrays {`   `    ``// Function to find next gap.` `    ``private` `static` `int` `nextGap(``int` `gap)` `    ``{` `        ``if` `(gap <= ``1``)` `            ``return` `0``;` `        ``return` `(gap / ``2``) + (gap % ``2``);` `    ``}`   `    ``private` `static` `void` `merge(``int``[] arr1, ``int``[] arr2, ``int` `n,` `                              ``int` `m)` `    ``{` `        ``int` `i, j, gap = n + m;` `        ``for` `(gap = nextGap(gap); gap > ``0``;` `             ``gap = nextGap(gap)) {` `            ``// comparing elements in the first` `            ``// array.` `            ``for` `(i = ``0``; i + gap < n; i++)` `                ``if` `(arr1[i] > arr1[i + gap]) {` `                    ``int` `temp = arr1[i];` `                    ``arr1[i] = arr1[i + gap];` `                    ``arr1[i + gap] = temp;` `                ``}`   `            ``// comparing elements in both arrays.` `            ``for` `(j = gap > n ? gap - n : ``0``; i < n && j < m;` `                 ``i++, j++)` `                ``if` `(arr1[i] > arr2[j]) {` `                    ``int` `temp = arr1[i];` `                    ``arr1[i] = arr2[j];` `                    ``arr2[j] = temp;` `                ``}`   `            ``if` `(j < m) {` `                ``// comparing elements in the` `                ``// second array.` `                ``for` `(j = ``0``; j + gap < m; j++)` `                    ``if` `(arr2[j] > arr2[j + gap]) {` `                        ``int` `temp = arr2[j];` `                        ``arr2[j] = arr2[j + gap];` `                        ``arr2[j + gap] = temp;` `                    ``}` `            ``}` `        ``}` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int``[] a1 = { ``10``, ``27``, ``38``, ``43``, ``82` `};` `        ``int``[] a2 = { ``3``, ``9` `};`   `        ``// Function Call` `        ``merge(a1, a2, a1.length, a2.length);`   `        ``System.out.print(``"First Array: "``);` `        ``for` `(``int` `i = ``0``; i < a1.length; i++) {` `            ``System.out.print(a1[i] + ``" "``);` `        ``}`   `        ``System.out.println();`   `        ``System.out.print(``"Second Array: "``);` `        ``for` `(``int` `i = ``0``; i < a2.length; i++) {` `            ``System.out.print(a2[i] + ``" "``);` `        ``}` `    ``}` `}`   `// This code is contributed by Vinisha Shah`

## Python 3

 `# Merging two sorted arrays with O(1)` `# extra space`   `# Function to find next gap.`     `def` `nextGap(gap):`   `    ``if` `(gap <``=` `1``):` `        ``return` `0` `    ``return` `(gap ``/``/` `2``) ``+` `(gap ``%` `2``)`     `def` `merge(arr1, arr2, n, m):`   `    ``gap ``=` `n ``+` `m` `    ``gap ``=` `nextGap(gap)` `    ``while` `gap > ``0``:`   `        ``# comparing elements in` `        ``# the first array.` `        ``i ``=` `0` `        ``while` `i ``+` `gap < n:` `            ``if` `(arr1[i] > arr1[i ``+` `gap]):` `                ``arr1[i], arr1[i ``+` `gap] ``=` `arr1[i ``+` `gap], arr1[i]`   `            ``i ``+``=` `1`   `        ``# comparing elements in both arrays.` `        ``j ``=` `gap ``-` `n ``if` `gap > n ``else` `0` `        ``while` `i < n ``and` `j < m:` `            ``if` `(arr1[i] > arr2[j]):` `                ``arr1[i], arr2[j] ``=` `arr2[j], arr1[i]`   `            ``i ``+``=` `1` `            ``j ``+``=` `1`   `        ``if` `(j < m):`   `            ``# comparing elements in the` `            ``# second array.` `            ``j ``=` `0` `            ``while` `j ``+` `gap < m:` `                ``if` `(arr2[j] > arr2[j ``+` `gap]):` `                    ``arr2[j], arr2[j ``+` `gap] ``=` `arr2[j ``+` `gap], arr2[j]`   `                ``j ``+``=` `1`   `        ``gap ``=` `nextGap(gap)`     `# Driver code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``a1 ``=` `[``10``, ``27``, ``38``, ``43``, ``82``]` `    ``a2 ``=` `[``3``, ``9``]` `    ``n ``=` `len``(a1)` `    ``m ``=` `len``(a2)`   `    ``# Function Call` `    ``merge(a1, a2, n, m)`   `    ``print``(``"First Array: "``, end``=``"")` `    ``for` `i ``in` `range``(n):` `        ``print``(a1[i], end``=``" "``)` `    ``print``()`   `    ``print``(``"Second Array: "``, end``=``"")` `    ``for` `i ``in` `range``(m):` `        ``print``(a2[i], end``=``" "``)` `    ``print``()`   `# This code is contributed` `# by ChitraNayal`

## C#

 `// C# program for Merging two sorted arrays` `// with O(1) extra space` `using` `System;`   `class` `GFG {`   `    ``// Function to find next gap.` `    ``static` `int` `nextGap(``int` `gap)` `    ``{` `        ``if` `(gap <= 1)` `            ``return` `0;` `        ``return` `(gap / 2) + (gap % 2);` `    ``}`   `    ``private` `static` `void` `merge(``int``[] arr1, ``int``[] arr2, ``int` `n,` `                              ``int` `m)` `    ``{` `        ``int` `i, j, gap = n + m;` `        ``for` `(gap = nextGap(gap); gap > 0;` `             ``gap = nextGap(gap)) {` `            ``// comparing elements in the first` `            ``// array.` `            ``for` `(i = 0; i + gap < n; i++)` `                ``if` `(arr1[i] > arr1[i + gap]) {` `                    ``int` `temp = arr1[i];` `                    ``arr1[i] = arr1[i + gap];` `                    ``arr1[i + gap] = temp;` `                ``}`   `            ``// comparing elements in both arrays.` `            ``for` `(j = gap > n ? gap - n : 0; i < n && j < m;` `                 ``i++, j++)` `                ``if` `(arr1[i] > arr2[j]) {` `                    ``int` `temp = arr1[i];` `                    ``arr1[i] = arr2[j];` `                    ``arr2[j] = temp;` `                ``}`   `            ``if` `(j < m) {` `                ``// comparing elements in the` `                ``// second array.` `                ``for` `(j = 0; j + gap < m; j++)` `                    ``if` `(arr2[j] > arr2[j + gap]) {` `                        ``int` `temp = arr2[j];` `                        ``arr2[j] = arr2[j + gap];` `                        ``arr2[j + gap] = temp;` `                    ``}` `            ``}` `        ``}` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[] a1 = { 10, 27, 38, 43, 82 };` `        ``int``[] a2 = { 3, 9 };`   `        ``// Function Call` `        ``merge(a1, a2, a1.Length, a2.Length);`   `        ``Console.Write(``"First Array: "``);` `        ``for` `(``int` `i = 0; i < a1.Length; i++) {` `            ``Console.Write(a1[i] + ``" "``);` `        ``}`   `        ``Console.WriteLine();`   `        ``Console.Write(``"Second Array: "``);` `        ``for` `(``int` `i = 0; i < a2.Length; i++) {` `            ``Console.Write(a2[i] + ``" "``);` `        ``}` `    ``}` `}`   `// This code is contributed by Sam007.`

## PHP

 ` 0; ``\$gap` `= nextGap(``\$gap``))` `    ``{` `        ``// comparing elements ` `        ``// in the first array.` `        ``for` `(``\$i` `= 0; ``\$i` `+ ``\$gap` `< ``\$n``; ``\$i``++)` `            ``if` `(``\$arr1``[``\$i``] > ``\$arr1``[``\$i` `+ ``\$gap``])` `            ``{` `                ``\$tmp` `= ``\$arr1``[``\$i``];` `                ``\$arr1``[``\$i``] = ``\$arr1``[``\$i` `+ ``\$gap``];` `                ``\$arr1``[``\$i` `+ ``\$gap``] = ``\$tmp``;` `            ``}`   `        ``// comparing elements ` `        ``// in both arrays.` `        ``for` `(``\$j` `= ``\$gap` `> ``\$n` `? ``\$gap` `- ``\$n` `: 0 ; ` `             ``\$i` `< ``\$n` `&& ``\$j` `< ``\$m``; ``\$i``++, ``\$j``++)` `            ``if` `(``\$arr1``[``\$i``] > ``\$arr2``[``\$j``])` `            ``{` `                ``\$tmp` `= ``\$arr1``[``\$i``];` `                ``\$arr1``[``\$i``] = ``\$arr2``[``\$j``];` `                ``\$arr2``[``\$j``] = ``\$tmp``;` `            ``}`   `        ``if` `(``\$j` `< ``\$m``)` `        ``{` `            ``// comparing elements in` `            ``// the second array.` `            ``for` `(``\$j` `= 0; ``\$j` `+ ``\$gap` `< ``\$m``; ``\$j``++)` `                ``if` `(``\$arr2``[``\$j``] > ``\$arr2``[``\$j` `+ ``\$gap``])` `                ``{` `                    ``\$tmp` `= ``\$arr2``[``\$j``];` `                    ``\$arr2``[``\$j``] = ``\$arr2``[``\$j` `+ ``\$gap``];` `                    ``\$arr2``[``\$j` `+ ``\$gap``] = ``\$tmp``;` `                ``}` `        ``}` `    ``}` `    `  `    ``echo` `"First Array: "``;` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++)` `        ``echo` `\$arr1``[``\$i``].``" "``;`   `    ``echo` `"\nSecond Array: "``;` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$m``; ``\$i``++)` `        ``echo` `\$arr2``[``\$i``] . ``" "``;` `    ``echo``"\n"``;`   `}`   `// Driver code` `\$a1` `= ``array``(10, 27, 38, 43 ,82);` `\$a2` `= ``array``(3,9);` `\$n` `= sizeof(``\$a1``);` `\$m` `= sizeof(``\$a2``);`   `// Function Call` `merge(``\$a1``, ``\$a2``, ``\$n``, ``\$m``);`   `// This code is contributed ` `// by mits.` `?>`

Output

```First Array: 3 9 10 27 38
Second Array: 43 82
```

#### Another method in O(m+n) time complexity:

Here we use the below technique:

```Suppose we have a number A and we want to convert it to a number B and there is also a
constrain that we can recover number A any time without using other variable.To achieve
this we chose a number N which is greater than both numbers and add B*N int A.
so A --> A+B*N

To get number B out of (A+B*N) we devide (A+B*N) by N (A+B*N)/N = B.

To get number A out of (A+B*N) we take modulo with N (A+B*N)%N = A.

-> In short by taking modulo we get old number back and taking divide we new number.
```

We first find the maximum element of both array and increment it one-two avoid collision of 0 and maximum element during modulo operation. The idea is to we traverse both arrays from starting simultaneously. Let’s say an element in a is a[i] and in b is b[j] and k is the position at where the next minimum number will come. Now update value a[k] if k<n else b[k-n] by adding min(a[i],b[j])*maximum_element. After updating all the element divide all the elements by maximum_element so we get updated array back.

Below is the implementation of the above idea:

## C++

 `#include ` `using` `namespace` `std;`   `void` `mergeArray(``int` `a[], ``int` `b[], ``int` `n, ``int` `m)` `{` `    ``int` `mx = 0;` `    `  `    ``// Find maximum element of both array` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``mx = max(mx, a[i]);` `    ``}` `    ``for` `(``int` `i = 0; i < m; i++) {` `        ``mx = max(mx, b[i]);` `    ``}` `    `  `    ``// increment one two avoid collision of 0 and maximum` `    ``// element of array in modulo operation` `    ``mx++;` `    ``int` `i = 0, j = 0, k = 0;` `    ``while` `(i < n && j < m && k < (n + m)) {` `        `  `        ``// recover back original element to compare` `        ``int` `e1 = a[i] % mx;` `        ``int` `e2 = b[j] % mx;` `        ``if` `(e1 <= e2) {` `            `  `            ``// update element by adding multiplication` `            ``// with new number` `            ``if` `(k < n)` `                ``a[k] += (e1 * mx);` `            ``else` `                ``b[k - n] += (e1 * mx);` `            ``i++;` `            ``k++;` `        ``}` `        ``else` `{` `            `  `            ``// update element by adding multiplication` `            ``// with new number` `            ``if` `(k < n)` `                ``a[k] += (e2 * mx);` `            ``else` `                ``b[k - n] += (e2 * mx);` `            ``j++;` `            ``k++;` `        ``}` `    ``}` `    `  `    ``// process those elements which are left in array a` `    ``while` `(i < n) {` `        ``int` `el = a[i] % mx;` `        ``if` `(k < n)` `            ``a[k] += (el * mx);` `        ``else` `            ``b[k - n] += (el * mx);` `        ``i++;` `        ``k++;` `    ``}` `    `  `    ``// process those elements which are left in array a` `    ``while` `(j < m) {` `        ``int` `el = b[j] % mx;` `        ``if` `(k < n)` `            ``b[k] += (el * mx);` `        ``else` `            ``b[k - n] += (el * mx);` `        ``j++;` `        ``k++;` `    ``}` `    `  `    ``// finally update elements by dividing` `    ``// with maximum element` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``a[i] = a[i] / mx;`   `    ``// finally update elements by dividing` `    ``// with maximum element` `    ``for` `(``int` `i = 0; i < m; i++)` `        ``b[i] = b[i] / mx;`   `    ``return``;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `a[] = { 3, 5, 6, 8, 12 };` `    ``int` `b[] = { 1, 4, 9, 13 };` `    ``int` `n = ``sizeof``(a) / ``sizeof``(``int``); ``// Length of a` `    ``int` `m = ``sizeof``(b) / ``sizeof``(``int``); ``// length of b`   `    ``// Function Call` `    ``mergeArray(a, b, n, m);`   `    ``cout << ``"First array : "``;` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``cout << a[i] << ``" "``;` `    ``cout << endl;`   `    ``cout << ``"Second array : "``;` `    ``for` `(``int` `i = 0; i < m; i++)` `        ``cout << b[i] << ``" "``;` `    ``cout << endl;`   `    ``return` `0;` `}`

Output

```First array : 1 3 4 5 6
Second array : 8 9 12 13
```

Time Complexity: O(m+n)

This article is contributed by Shlomi Elhaiani. 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.

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.

My Personal Notes arrow_drop_up

Article Tags :

82

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.