Related Articles

# Merge two sorted arrays with O(1) extra space

• Difficulty Level : Medium
• Last Updated : 07 Jul, 2021

We are given two sorted arrays. We need to merge these two arrays such that the initial numbers (after complete sorting) are in the first array and the remaining numbers are in the second array. Extra space allowed in O(1).

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}```

This task is simple and O(m+n) if we are allowed to use extra space. But it becomes really complicated when extra space is not allowed and doesn’t look possible in less than O(m*n) worst case time.  Though further optimizations are possible
The idea is to begin from last element of ar2[] and search it in ar1[]. If there is a greater element in ar1[], then we move last element of ar1[] to ar2[]. To keep ar1[] and ar2[] sorted, we need to place last element of ar2[] at correct place in ar1[]. We can use Insertion Sort type of insertion for this.

1. Method 1

Algorithm:

```1) Iterate through every element of ar2[] starting from last
element. Do following for every element ar2[i]
a) Store last element of ar1[i]: last = ar1[i]
b) Loop from last element of ar1[] while element ar1[j] is
greater than ar2[i].
ar1[j+1] = ar1[j] // Move element one position ahead
j--
c) If any element of ar1[] was moved or (j != m-1)
ar1[j+1] = ar2[i]
ar2[i] = last```

In above loop, elements in ar1[] and ar2[] are always kept sorted.

Below is the implementation of above algorithm.

## C++

 `// C++ program to merge two sorted``//  arrays with O(1) extra space.``#include ``using` `namespace` `std;` `// Merge ar1[] and ar2[] with O(1) extra space``void` `merge(``int` `ar1[], ``int` `ar2[], ``int` `m, ``int` `n)``{``    ``// Iterate through all elements``    ``// of ar2[] starting from the last element``    ``for` `(``int` `i = n - 1; i >= 0; i--)``    ``{``        ``/* Find the smallest element greater than ar2[i].``        ``Move all elements one position ahead till the``        ``smallest greater element is not found */``        ``int` `j, last = ar1[m - 1];``        ``for` `(j = m - 2; j >= 0``             ``&& ar1[j] > ar2[i]; j--)``            ``ar1[j + 1] = ar1[j];` `        ``// If there was a greater element``        ``if` `(j != m - 2 || last > ar2[i])``        ``{``            ``ar1[j + 1] = ar2[i];``            ``ar2[i] = last;``        ``}``    ``}``}` `// Driver program``int` `main()``{``    ``int` `ar1[] = { 1, 5, 9, 10, 15, 20 };``    ``int` `ar2[] = { 2, 3, 8, 13 };``    ``int` `m = ``sizeof``(ar1) / ``sizeof``(ar1);``    ``int` `n = ``sizeof``(ar2) / ``sizeof``(ar2);``    ``merge(ar1, ar2, m, 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;``}`

## Java

 `// Java program program to merge two``// sorted arrays with O(1) extra space.` `import` `java.util.Arrays;` `class` `Test``{``    ``static` `int` `arr1[] = ``new` `int``[]{``1``, ``5``, ``9``, ``10``, ``15``, ``20``};``    ``static` `int` `arr2[] = ``new` `int``[]{``2``, ``3``, ``8``, ``13``};``    ` `    ``static` `void` `merge(``int` `m, ``int` `n)``    ``{``        ``// Iterate through all elements of ar2[] starting from``        ``// the last element``        ``for` `(``int` `i=n-``1``; i>=``0``; i--)``        ``{``            ``/* Find the smallest element greater than ar2[i]. Move all``               ``elements one position ahead till the smallest greater``               ``element is not found */``            ``int` `j, last = arr1[m-``1``];``            ``for` `(j=m-``2``; j >= ``0` `&& arr1[j] > arr2[i]; j--)``                ``arr1[j+``1``] = arr1[j];``     ` `            ``// If there was a greater element``            ``if` `(j != m-``2` `|| last > arr2[i])``            ``{``                ``arr1[j+``1``] = arr2[i];``                ``arr2[i] = last;``            ``}``        ``}``    ``}``    ` `    ``// Driver method to test the above function``    ``public` `static` `void` `main(String[] args)``    ``{``        ``merge(arr1.length,arr2.length);``        ``System.out.print(``"After Merging nFirst Array: "``);``        ``System.out.println(Arrays.toString(arr1));``        ``System.out.print(``"Second Array:  "``);``        ``System.out.println(Arrays.toString(arr2));``    ``}``}`

## Python3

 `# Python program to merge``# two sorted arrays``# with O(1) extra space.` `# Merge ar1[] and ar2[]``# with O(1) extra space``def` `merge(ar1, ar2, m, n):` `    ``# Iterate through all``    ``# elements of ar2[] starting from``    ``# the last element``    ``for` `i ``in` `range``(n``-``1``, ``-``1``, ``-``1``):``    ` `        ``# Find the smallest element``        ``# greater than ar2[i]. Move all``        ``# elements one position ahead``        ``# till the smallest greater``        ``# element is not found``        ``last ``=` `ar1[m``-``1``]``        ``j``=``m``-``2``        ``while``(j >``=` `0` `and` `ar1[j] > ar2[i]):``            ``ar1[j``+``1``] ``=` `ar1[j]``            ``j``-``=``1`` ` `        ``# If there was a greater element``        ``if` `(j !``=` `m``-``2` `or` `last > ar2[i]):``        ` `            ``ar1[j``+``1``] ``=` `ar2[i]``            ``ar2[i] ``=` `last`` ` `# Driver program` `ar1 ``=` `[``1``, ``5``, ``9``, ``10``, ``15``, ``20``]``ar2 ``=` `[``2``, ``3``, ``8``, ``13``]``m ``=` `len``(ar1)``n ``=` `len``(ar2)` `merge(ar1, ar2, m, n)`` ` `print``(``"After Merging \nFirst Array:"``, end``=``"")``for` `i ``in` `range``(m):``    ``print``(ar1[i] , ``" "``, end``=``"")` `print``(``"\nSecond Array: "``, end``=``"")``for` `i ``in` `range``(n):``    ``print``(ar2[i] , ``" "``, end``=``"")` `# This code is contributed``# by Anant Agarwal.`

## C#

 `// C# program program to merge two``// sorted arrays with O(1) extra space.``using` `System;` `// Java program program to merge two``// sorted arrays with O(1) extra space.`  `public` `class` `Test``{``    ``static` `int` `[]arr1 = ``new` `int``[]{1, 5, 9, 10, 15, 20};``    ``static` `int` `[]arr2 = ``new` `int``[]{2, 3, 8, 13};``    ` `    ``static` `void` `merge(``int` `m, ``int` `n)``    ``{``        ``// Iterate through all elements of ar2[] starting from``        ``// the last element``        ``for` `(``int` `i=n-1; i>=0; i--)``        ``{``            ``/* Find the smallest element greater than ar2[i]. Move all``            ``elements one position ahead till the smallest greater``            ``element is not found */``            ``int` `j, last = arr1[m-1];``            ``for` `(j=m-2; j >= 0 && arr1[j] > arr2[i]; j--)``                ``arr1[j+1] = arr1[j];``    ` `            ``// If there was a greater element``            ``if` `(j != m-2 || last > arr2[i])``            ``{``                ``arr1[j+1] = arr2[i];``                ``arr2[i] = last;``            ``}``        ``}``    ``}``    ` `    ``// Driver method to test the above function``    ``public` `static` `void` `Main()``    ``{``        ``merge(arr1.Length,arr2.Length);``        ``Console.Write(``"After Merging \nFirst Array: "``);``        ``for``(``int` `i =0; i< arr1.Length;i++){``            ``Console.Write(arr1[i]+``" "``);``        ``}``        ``Console.Write(``"\nSecond Array: "``);``        ``for``(``int` `i =0; i< arr2.Length;i++){``            ``Console.Write(arr2[i]+``" "``);``        ``}``    ``}``}` `/*This code is contributed by 29AjayKumar*/`

## PHP

 `= 0; ``\$i``--)``    ``{``        ``/* Find the smallest element greater than ar2[i]. Move all``           ``elements one position ahead till the smallest greater``           ``element is not found */``        ``\$last` `= ``\$ar1``[``\$m``-1];``        ``for` `(``\$j` `= ``\$m``-2; ``\$j` `>= 0 && ``\$ar1``[``\$j``] > ``\$ar2``[``\$i``]; ``\$j``--)``            ``\$ar1``[``\$j``+1] = ``\$ar1``[``\$j``];`` ` `        ``// If there was a greater element``        ``if` `(``\$j` `!= ``\$m``-2 || ``\$last` `> ``\$ar2``[``\$i``])``        ``{``            ``\$ar1``[``\$j``+1] = ``\$ar2``[``\$i``];``            ``\$ar2``[``\$i``] = ``\$last``;``        ``}``    ``}``}`` ` `// Driver program` `\$ar1` `= ``array``(1, 5, 9, 10, 15, 20);``\$ar2` `= ``array``(2, 3, 8, 13);``\$m` `= sizeof(``\$ar1``)/sizeof(``\$ar1``);``\$n` `= sizeof(``\$ar2``)/sizeof(``\$ar2``);``merge(``\$ar1``, ``\$ar2``, ``\$m``, ``\$n``);` `echo` `"After Merging \nFirst Array: "``;``for` `(``\$i``=0; ``\$i``<``\$m``; ``\$i``++)``    ``echo` `\$ar1``[``\$i``] . ``" "``;``echo` `"\nSecond Array: "``;``for` `(``\$i``=0; ``\$i``<``\$n``; ``\$i``++)``    ``echo` `\$ar2``[``\$i``] .``" "``;``return` `0;``?>`

## Javascript

 ``

Output:

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

Time Complexity: The worst case time complexity of code/algorithm is O(m*n). The worst case occurs when all elements of ar1[] are greater than all elements of ar2[].

Illustration: <!— Initial Arrays:
ar1[] = {1, 5, 9, 10, 15, 20};
ar2[] = {2, 3, 8, 13};
After First Iteration:
ar1[] = {1, 5, 9, 10, 13, 15};
ar2[] = {2, 3, 8, 20};
// 20 is moved from ar1[] to ar2[]
// 13 from ar2[] is inserted in ar1[]
After Second Iteration:
ar1[] = {1, 5, 8, 9, 10, 13};
ar2[] = {2, 3, 15, 20};
// 15 is moved from ar1[] to ar2[]
// 8 from ar2[] is inserted in ar1[]
After Third Iteration:
ar1[] = {1, 3, 5, 8, 9, 10};
ar2[] = {2, 13, 15, 20};
// 13 is moved from ar1[] to ar2[]
// 3 from ar2[] is inserted in ar1[]
After Fourth Iteration:
ar1[] = {1, 2, 3, 5, 8, 9};
ar2[] = {10, 13, 15, 20};
// 10 is moved from ar1[] to ar2[]
// 2 from ar2[] is inserted in ar1[]
—!>

Method 2:

The solution can be further optimized by observing that while traversing the two sorted arrays parallelly, if we encounter the jth second array element is smaller than ith first array element, then jth element is to be included and replace some kth element in the first array. This observation helps us with the following algorithm

Algorithm

```1) Initialize i,j,k as 0,0,n-1 where n is size of arr1
2) Iterate through every element of arr1 and arr2 using two pointers i and j respectively
if arr1[i] is less than arr2[j]
increment i
else
swap the arr2[j] and arr1[k]
increment j and decrement k

3) Sort both arr1 and arr2 ```

Below is the implementation of above algorithm

## C++

 `// CPP program for the above approach``#include ``using` `namespace` `std;` `// Function to merge two arrays``void` `merge(``int` `arr1[], ``int` `arr2[], ``int` `n, ``int` `m)``{``    ``int` `i = 0, j = 0, k = n - 1;``  ` `    ``// Untill i less than equal to k``    ``// or j is less tha m``    ``while` `(i <= k and j < m) {``        ``if` `(arr1[i] < arr2[j])``            ``i++;``        ``else` `{``            ``swap(arr2[j++], arr1[k--]);``        ``}``    ``}``  ` `    ``// Sort first array``    ``sort(arr1, arr1 + n);``  ` `    ``// Sort second array``    ``sort(arr2, arr2 + 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);``    ``int` `n = ``sizeof``(ar2) / ``sizeof``(ar2);``    ``merge(ar1, ar2, m, 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;``}`

## Java

 `// Java program for the above approach``import` `java.util.Arrays;``import` `java.util.Collections;` `class` `GFG {``    ``static` `int` `arr1[] = ``new` `int``[] { ``1``, ``5``, ``9``, ``10``, ``15``, ``20` `};``    ``static` `int` `arr2[] = ``new` `int``[] { ``2``, ``3``, ``8``, ``13` `};` `    ``// Function to merge two arrays``    ``static` `void` `merge(``int` `m, ``int` `n)``    ``{``        ``int` `i = ``0``, j = ``0``, k = n - ``1``;``        ``while` `(i <= k and j < m) {``            ``if` `(arr1[i] < arr2[j])``                ``i++;``            ``else` `{``                ``int` `temp = arr2[j];``                ``arr2[j] = arr1[k];``                ``arr1[k] = temp;``                ``j++;``                ``k--;``            ``}``        ``}``        ``Arrays.sort(arr1);``        ``Arrays.sort(arr2);``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``merge(arr1.length, arr2.length);``        ``System.out.print(``"After Merging \nFirst Array: "``);``        ``System.out.println(Arrays.toString(arr1));``        ``System.out.print(``"Second Array:  "``);``        ``System.out.println(Arrays.toString(arr2));``    ``}``}`
Output
```After Merging
First Array: 1 2 3 5 8 9
Second Array: 10 13 15 20 ```

Complexities:

Time Complexity: The time complexity while traversing the arrays in while loop is O(n+m) in worst case and sorting is O(nlog(n) + mlog(m)). So overall time complexity of the code becomes O((n+m)log(n+m)).

Space Complexity: As the function doesn’t use any extra array for any operations, the space complexity is O(1).

Method 3:

Algorithm:

```1) Initialize i with 0
2) Iterate while loop untill last element of array 1 is greater than first element of array 2
if arr1[i] greater than first element of arr2
swap arr1[i] with arr2
sort arr2
incrementing i ```

## C++

 `#include``#include``using` `namespace` `std;` `void` `merge(``int` `arr1[], ``int` `arr2[], ``int` `n, ``int` `m) {``        ``int` `i=0;``        ``// while loop till last element of array 1(sorted) is greater than``          ``// first element of array 2(sorted)``        ``while``(arr1[n-1]>arr2)``        ``{``            ``if``(arr1[i]>arr2)``            ``{``                ``// swap arr1[i] with first element``                  ``// of arr2 and sorting the updated``                ``// arr2(arr1 is already sorted)``                ``swap(arr1[i],arr2);``                ``sort(arr2,arr2+m);``            ``}``            ``i++;``        ``}``    ``}` `int` `main()``{` `    ``int` `ar1[] = { 1, 5, 9, 10, 15, 20 };``    ``int` `ar2[] = { 2, 3, 8, 13 };``    ``int` `m = ``sizeof``(ar1) / ``sizeof``(ar1);``    ``int` `n = ``sizeof``(ar2) / ``sizeof``(ar2);``    ``merge(ar1, ar2, m, 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;` `}`

## Java

 `import` `java.io.*;``import` `java.util.Arrays;``import` `java.util.Collections;` `class` `GFG{` `static` `int` `arr1[] = ``new` `int``[]{ ``1``, ``5``, ``9``, ``10``, ``15``, ``20` `};``static` `int` `arr2[] = ``new` `int``[]{ ``2``, ``3``, ``8``, ``13` `};` `static` `void` `merge(``int` `n, ``int` `m)``{``    ``int` `i = ``0``;``    ``int` `temp = ``0``;``    ` `    ``// While loop till last element``    ``// of array 1(sorted)``    ``// is greater than first element``    ``// of array 2(sorted)``    ``while` `(arr1[n - ``1``] > arr2[``0``])``    ``{``        ``if` `(arr1[i] > arr2[``0``])``        ``{``            ` `            ``// Swap arr1[i] with first element``            ``// of arr2 and sorting the updated``            ``// arr2(arr1 is already sorted)``            ``// swap(arr1[i],arr2);``            ``temp = arr1[i];``            ``arr1[i] = arr2[``0``];``            ``arr2[``0``] = temp;``            ``Arrays.sort(arr2);``        ``}``        ``i++;``    ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``merge(arr1.length, arr2.length);` `    ``System.out.print(``"After Merging \nFirst Array: "``);``    ``System.out.println(Arrays.toString(arr1));``    ` `    ``System.out.print(``"Second Array:  "``);``    ``System.out.println(Arrays.toString(arr2));``}``}` `// This code is contributed by Aakash Tiwari(nighteagle)`
Output

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

Method 4: Let length of shorter array be ‘m’ and larger array be ‘n’

Step 1: Select the shorter array and find the index at which partition should be done. Similar to this https://www.geeksforgeeks.org/median-of-two-sorted-arrays-of-different-sizes/

Step 1: Partition the shorter array at its median (l1).

Step 2: Select the first n-l1 elements from the second array. Step 3: Compare the border elements i.e.

if l1 < r2 and l2 < r2 we have found the index

else if l1 > r2 we have to search in the left subarray

else we have to search in the right subarray

NOTE : This step will store all the smallest elements in the shorter array.

Step 2: Swap all the elements right to the index(i) of the shorter array with the first n-i elements of the larger array.

Step 3: Sort both the arrays.

::::: if len(arr1) > len(arr2) all the smallest elements are stored in arr2 so we have to move all the elements in arr1 since we have to print arr1 first.

Step 4: Rotate the larger array (arr1) m times counter-clockwise.

Step 5: Swap the first m elements of both the arrays.

## C++

 `#include ``using` `namespace` `std;` `void` `swap(``int``& a, ``int``& b)``{``    ``int` `temp = a;``    ``a = b;``    ``b = temp;``}` `void` `rotate(``int` `a[], ``int` `n, ``int` `idx)``{``    ``int` `i;``    ``for` `(i = 0; i < idx / 2; i++)``        ``swap(a[i], a[idx - 1 - i]);``    ``for` `(i = idx; i < (n + idx) / 2; i++)``        ``swap(a[i], a[n - 1 - (i - idx)]);``    ``for` `(i = 0; i < n / 2; i++)``        ``swap(a[i], a[n - 1 - i]);``}` `void` `sol(``int` `a1[], ``int` `a2[], ``int` `n, ``int` `m)``{``    ``int` `l = 0, h = n - 1, idx = 0;``    ``//---------------------------------------------------------``    ``while` `(l <= h) {``        ``// select the median of the remaining subarray``        ``int` `c1 = (l + h) / 2;``        ``// select the first elements from the larger array``        ``// euqal to the size of remaining portion to the``        ``// right of the smaller array``        ``int` `c2 = n - c1 - 1;``        ``int` `l1 = a1[c1];``        ``int` `l2 = a2[c2 - 1];``        ``int` `r1 = c1 == n - 1 ? INT_MAX : a1[c1 + 1];``        ``int` `r2 = c2 == m ? INT_MAX : a2[c2];``        ``// compare the border elements and check for the``        ``// target index``        ``if` `(l1 > r2) {``            ``h = c1 - 1;``            ``if` `(h == -1)``                ``idx = 0;``        ``}``        ``else` `if` `(l2 > r1) {``            ``l = c1 + 1;``            ``if` `(l == n - 1)``                ``idx = n;``        ``}``        ``else` `{``            ``idx = c1 + 1;``            ``break``;``        ``}``    ``}` `    ``for` `(``int` `i = idx; i < n; i++)``        ``swap(a1[i], a2[i - idx]);` `    ``sort(a1, a1 + n);` `    ``sort(a2, a2 + m);``}` `void` `merge(``int` `arr1[], ``int` `arr2[], ``int` `n, ``int` `m)``{``    ``// code here``    ``if` `(n > m) {``        ``sol(arr2, arr1, m, n);``        ``rotate(arr1, n, n - m);` `        ``for` `(``int` `i = 0; i < m; i++)``            ``swap(arr2[i], arr1[i]);``    ``}``    ``else` `{``        ``sol(arr1, arr2, n, m);``    ``}``}` `int` `main()``{` `    ``int` `ar1[] = { 1, 5, 9, 10, 15, 20 };``    ``int` `ar2[] = { 2, 3, 8, 13 };``    ``int` `m = ``sizeof``(ar1) / ``sizeof``(ar1);``    ``int` `n = ``sizeof``(ar2) / ``sizeof``(ar2);``    ``merge(ar1, ar2, m, 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;``}`

## Python3

 `# Python program to merge``# two sorted arrays``# with O(1) extra space.` `# Merge ar1[] and ar2[]``# with O(1) extra space`  `def` `rotate(a, n, idx):``    ``for` `i ``in` `range``((``int``)(idx``/``2``)):``        ``a[i], a[idx``-``1``-``i] ``=` `a[idx``-``1``-``i], a[i]``    ``for` `i ``in` `range``(idx, (``int``)((n``+``idx)``/``2``)):``        ``a[i], a[n``-``1``-``(i``-``idx)] ``=` `a[n``-``1``-``(i``-``idx)], a[i]``    ``for` `i ``in` `range``((``int``)(n``/``2``)):``        ``a[i], a[n``-``1``-``i] ``=` `a[n``-``1``-``i], a[i]`  `def` `sol(a1, a2, n, m):``    ``l ``=` `0``    ``h ``=` `n``-``1``    ``idx ``=` `0``    ``while` `(l <``=` `h):``        ``c1 ``=` `(``int``)((l``+``h)``/``2``)``        ``c2 ``=` `n``-``c1``-``1``        ``l1 ``=` `a1[c1]``        ``l2 ``=` `a2[c2``-``1``]``        ``r1 ``=` `sys.maxint ``if` `c1 ``=``=` `n``-``1` `else` `a1[c1``+``1``]``        ``r2 ``=` `sys.maxint ``if` `c2 ``=``=` `m ``else` `a2[c2]``        ``if` `l1 > r2:``            ``h ``=` `c1``-``1``            ``if` `h ``=``=` `-``1``:``                ``idx ``=` `0``        ``elif` `l2 > l1:``            ``l ``=` `c1``+``1``            ``if` `l ``=``=` `n``-``1``:``                ``idx ``=` `n``        ``else``:``            ``idx ``=` `c1``+``1``            ``break``    ``for` `i ``in` `range``(idx, n):``        ``a1[i], a2[i``-``idx] ``=` `a2[i``-``idx], a1[i]` `    ``a1.sort()``    ``a2.sort()`  `def` `merge(a1, a2, n, m):``    ``if` `n > m:``        ``sol(a2, a1, m, n)``        ``rotate(a1, n, n``-``m)``        ``for` `i ``in` `range``(m):``            ``a1[i], a2[i] ``=` `a2[i], a1[i]``    ``else``:``        ``sol(a1, a2, m, n)``# Driver program`  `ar1 ``=` `[``1``, ``5``, ``9``, ``10``, ``15``, ``20``]``ar2 ``=` `[``2``, ``3``, ``8``, ``13``]``m ``=` `len``(ar1)``n ``=` `len``(ar2)` `merge(ar1, ar2, m, n)` `print``(``"After Merging \nFirst Array:"``, end``=``"")``for` `i ``in` `range``(m):``    ``print``(ar1[i], ``" "``, end``=``"")``print``(``"\nSecond Array: "``, end``=``"")``for` `i ``in` `range``(n):``    ``print``(ar2[i], ``" "``, end``=``"")``# This code is contributed``# by Aditya Anand.`
Output
```After Merging
First Array: 1 2 3 5 8 9
Second Array: 10 13 15 20 ```

Time Complexity: O(min(nlogn, mlogm))

Method-5 [Insertion Sort with Simultaneous Merge]

Approach:

1. sort list 1 by always comparing with head/first of list 2 and swapping if required
2. after each head/first swap, perform insertion of the swapped element into correct position in list 2 which will eventually sort list 2 at the end.

For every swapped item from list 1, perform insertion sort in list 2 to find its correct position so that when list 1 is sorted, list 2 is also sorted.

## C++

 `#include ``using` `namespace` `std;` `void` `merge(``int` `arr1[], ``int` `arr2[], ``int` `n, ``int` `m)``{``    ``// two pointer to iterate``    ``int` `i = 0;``    ``int` `j = 0;``    ``while` `(i < n && j < m) {``        ``// if arr1[i] <= arr2[j] then both array is already``        ``// sorted``        ``if` `(arr1[i] <= arr2[j]) {``            ``i++;``        ``}``        ``else` `if` `(arr1[i] > arr2[j]) {``            ``// if arr1[i]>arr2[j] then first we swap both``            ``// element so that arr1[i] become smaller means``            ``// arr1[] become sorted then we check that``            ``// arr2[j] is smaller then all other element in``            ``// right side of arr2[j] if arr2[] is not sorted``            ``// then we linearly do sorting``            ``// means while adjecent element are less than``            ``// new arr2[j] we do sorting like by chnaging``            ``// position of element by shifting one position``            ``// toward left``            ``swap(arr1[i], arr2[j]);``            ``i++;``            ``if` `(j < m - 1 && arr2[j + 1] < arr2[j]) {``                ``int` `temp = arr2[j];``                ``int` `tempj = j + 1;``                ``while` `(arr2[tempj] < temp && tempj < m) {``                    ``arr2[tempj - 1] = arr2[tempj];``                    ``tempj++;``                ``}``                ``arr2[tempj - 1] = temp;``            ``}``        ``}``    ``}``}` `int` `main()``{` `    ``int` `ar1[] = { 1, 5, 9, 10, 15, 20 };``    ``int` `ar2[] = { 2, 3, 8, 13 };``    ``int` `m = ``sizeof``(ar1) / ``sizeof``(ar1);``    ``int` `n = ``sizeof``(ar2) / ``sizeof``(ar2);``    ``merge(ar1, ar2, m, 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;``}`

## Python3

 `# code contributed by mahee96` `# "Insertion sort of list 2 with swaps from list 1"``#``# swap elements to get list 1 correctly, meanwhile``# place the swapped item in correct position of list 2``# eventually list 2 is also sorted``# Time = O(m*n) or O(n*m)``# AUX = O(1)``def` `merge(arr1, arr2):``    ``x ``=` `arr1; y ``=` `arr2``    ``end ``=` `len``(arr1)``    ``i ``=` `0``    ``while``(i < end):                 ``# O(m) or O(n)``        ``if``(x[i] > y[``0``]):``            ``swap(x,y,i,``0``)``            ``insert(y,``0``)             ``# O(n) or O(m) number of shifts``        ``i``+``=``1` `# O(n):``def` `insert(y, i):``    ``orig ``=` `y[i]``    ``i``+``=``1``    ``while` `(i<``len``(y) ``and` `y[i]
Output
```After Merging
First Array: 1 2 3 5 8 9
Second Array: 10 13 15 20 ```

Time Complexity: O(m*n) list 1 traversal and list 2 insertions
Auxiliary Space: O(1)
If m == n: Time = O(n^2) insertion sort complexity

Related Articles :
Merge two sorted arrays
Merge k sorted arrays | Set 1
Thanks to Shubham Chauhan for suggesting 1st solution and Himanshu Kaushik for the 2nd solution. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

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