# Merge two sorted arrays in O(1) extra space using QuickSort partition

• Difficulty Level : Expert
• Last Updated : 02 Dec, 2022

Given two sorted arrays, arr[], brr[] of size N, and M, the task is to merge the two given arrays such that they form a sorted sequence of integers combining elements of both the arrays.

Examples:

Input: arr[] = {10}, brr[] = {2, 3}
Output: 2 3 10
Explanation: The merged sorted array obtained by taking all the elements from the both the arrays is {2, 3, 10}.
Therefore, the required output is 2 3 10.

Input: arr[] = {1, 5, 9, 10, 15, 20}, brr[] = {2, 3, 8, 13}
Output: 1 2 3 5 8 9 10 13 15 20

Naive Approach: Refer to Merge two sorted arrays for the simplest approach to merge the two given arrays.
Time Complexity: O(N * M)
Auxiliary Space: O(1)

Space Optimized Approach: Refer to Merge two sorted arrays with O(1) extra space to merge the two given arrays without using any extra memory.
Time Complexity: O(N * M)
Auxiliary Space: O(1)

Efficient Space Optimized Approach: Refer to Efficiently merging two sorted arrays with O(1) extra space to merge the two given array without using any extra memory.
Time Complexity: O((N + M) * log(N + M))
Auxiliary Space: O(1)

Partition – based Approach: The idea is to consider the (N + 1)th element of the final sorted array as a pivot element and perform the quick sort partition around the pivot element. Finally, store the first N smaller elements of the final sorted array into the array, arr[] and the last M greater elements of the final sorted array into the array, brr[] in any order and sort both these arrays separately. Follow the steps below to solve the problem:

1. Initialize a variable, say index to store the index of each element of the final sorted array.
2. Find the (N + 1)th element of the final sorted array as a pivot element.
3. Perform the quick sort partition around the pivot element.
4. Finally, sort both the array arr[] and brr[] separately.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach``#include ``using` `namespace` `std;` `// Function to perform the partition``// around the pivot element``void` `partition(``int` `arr[], ``int` `N,``               ``int` `brr[], ``int` `M,``               ``int` `Pivot)``{``    ``// Stores index of each element``    ``// of the array, arr[]``    ``int` `l = N - 1;` `    ``// Stores index of each element``    ``// of the array, brr[]``    ``int` `r = 0;` `    ``// Traverse both the array``    ``while` `(l >= 0 && r < M) {` `        ``// If pivot is``        ``// smaller than arr[l]``        ``if` `(arr[l] < Pivot)``            ``l--;` `        ``// If Pivot is``        ``// greater than brr[r]``        ``else` `if` `(brr[r] > Pivot)``            ``r++;` `        ``// If either arr[l] > Pivot``        ``// or brr[r] < Pivot``        ``else` `{``            ``swap(arr[l], brr[r]);``            ``l--;``            ``r++;``        ``}``    ``}``}` `// Function to merge``// the two sorted array``void` `Merge(``int` `arr[], ``int` `N,``           ``int` `brr[], ``int` `M)``{``    ``// Stores index of each element``    ``// of the array arr[]``    ``int` `l = 0;` `    ``// Stores index of each element``    ``// of the array brr[]``    ``int` `r = 0;` `    ``// Stores index of each element``    ``// the final sorted array``    ``int` `index = -1;` `    ``// Stores the pivot element``    ``int` `Pivot = 0;` `    ``// Traverse both the array``    ``while` `(index < N && l < N && r < M) {` `        ``if` `(arr[l] < brr[r]) {``            ``Pivot = arr[l++];``        ``}``        ``else` `{``            ``Pivot = brr[r++];``        ``}``        ``index++;``    ``}` `    ``// If pivot element is not found``    ``// or index < N``    ``while` `(index < N && l < N) {``        ``Pivot = arr[l++];``        ``index++;``    ``}` `    ``// If pivot element is not found``    ``// or index < N``    ``while` `(index < N && r < M) {``        ``Pivot = brr[r++];``        ``index++;``    ``}` `    ``// Place the first N elements of``    ``// the sorted array into arr[]``    ``// and the last M elements of``    ``// the sorted array into brr[]``    ``partition(arr, N, brr,``              ``M, Pivot);` `    ``// Sort both the arrays``    ``sort(arr, arr + N);` `    ``sort(brr, brr + M);` `    ``// Print the first N elements``    ``// in sorted order``    ``for` `(``int` `i = 0; i < N; i++)``        ``cout << arr[i] << ``" "``;` `    ``// Print the last M elements``    ``// in sorted order``    ``for` `(``int` `i = 0; i < M; i++)``        ``cout << brr[i] << ``" "``;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 5, 9 };``    ``int` `brr[] = { 2, 4, 7, 10 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``int` `M = ``sizeof``(brr) / ``sizeof``(brr[0]);``    ``Merge(arr, N, brr, M);` `    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;``class` `GFG{` `// Function to perform the partition``// around the pivot element``static` `void` `partition(``int` `arr[], ``int` `N,``                      ``int` `brr[], ``int` `M,``                      ``int` `Pivot)``{``  ``// Stores index of each element``  ``// of the array, arr[]``  ``int` `l = N - ``1``;` `  ``// Stores index of each element``  ``// of the array, brr[]``  ``int` `r = ``0``;` `  ``// Traverse both the array``  ``while` `(l >= ``0` `&& r < M)``  ``{``    ``// If pivot is``    ``// smaller than arr[l]``    ``if` `(arr[l] < Pivot)``      ``l--;` `    ``// If Pivot is``    ``// greater than brr[r]``    ``else` `if` `(brr[r] > Pivot)``      ``r++;` `    ``// If either arr[l] > Pivot``    ``// or brr[r] < Pivot``    ``else``    ``{``      ``int` `t = arr[l];``      ``arr[l] = brr[r];``      ``brr[r] = t;``      ``l--;``      ``r++;``    ``}``  ``}``}` `// Function to merge``// the two sorted array``static` `void` `Merge(``int` `arr[], ``int` `N,``                  ``int` `brr[], ``int` `M)``{``  ``// Stores index of each element``  ``// of the array arr[]``  ``int` `l = ``0``;` `  ``// Stores index of each element``  ``// of the array brr[]``  ``int` `r = ``0``;` `  ``// Stores index of each element``  ``// the final sorted array``  ``int` `index = -``1``;` `  ``// Stores the pivot element``  ``int` `Pivot = ``0``;` `  ``// Traverse both the array``  ``while` `(index < N && l < N &&``         ``r < M)``  ``{``    ``if` `(arr[l] < brr[r])``    ``{``      ``Pivot = arr[l++];``    ``}``    ``else``    ``{``      ``Pivot = brr[r++];``    ``}``    ``index++;``  ``}` `  ``// If pivot element is not found``  ``// or index < N``  ``while` `(index < N && l < N)``  ``{``    ``Pivot = arr[l++];``    ``index++;``  ``}` `  ``// If pivot element is not``  ``// found or index < N``  ``while` `(index < N && r < M)``  ``{``    ``Pivot = brr[r++];``    ``index++;``  ``}` `  ``// Place the first N elements of``  ``// the sorted array into arr[]``  ``// and the last M elements of``  ``// the sorted array into brr[]``  ``partition(arr, N, brr,``            ``M, Pivot);` `  ``// Sort both the arrays``  ``Arrays.sort(arr);` `  ``Arrays.sort(brr);` `  ``// Print the first N elements``  ``// in sorted order``  ``for` `(``int` `i = ``0``; i < N; i++)``    ``System.out.print(arr[i] + ``" "``);` `  ``// Print the last M elements``  ``// in sorted order``  ``for` `(``int` `i = ``0``; i < M; i++)``    ``System.out.print(brr[i] + ``" "``);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ``int` `arr[] = {``1``, ``5``, ``9``};``  ``int` `brr[] = {``2``, ``4``, ``7``, ``10``};``  ``int` `N = arr.length;``  ``int` `M = brr.length;``  ``Merge(arr, N, brr, M);``}``}` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to perform the partition``# around the pivot element``def` `partition(arr, N, brr, M, Pivot):``    ` `    ``# Stores index of each element``    ``# of the array, arr[]``    ``l ``=` `N ``-` `1``    ` `    ``# Stores index of each element``    ``# of the array, brr[]``    ``r ``=` `0``    ` `    ``# Traverse both the array``    ``while` `(l >``=` `0` `and` `r < M):``        ` `        ``# If pivot is smaller``        ``# than arr[l]``        ``if` `(arr[l] < Pivot):``            ``l ``-``=` `1` `        ``# If Pivot is greater``        ``# than brr[r]``        ``elif` `(brr[r] > Pivot):``            ``r ``+``=` `1` `        ``# If either arr[l] > Pivot``        ``# or brr[r] < Pivot``        ``else``:``            ``arr[l], brr[r] ``=` `brr[r], arr[l]``            ``l ``-``=` `1``            ``r ``+``=` `1` `# Function to merge``# the two sorted array``def` `Merge(arr, N, brr, M):``    ` `    ``# Stores index of each element``    ``# of the array arr[]``    ``l ``=` `0` `    ``# Stores index of each element``    ``# of the array brr[]``    ``r ``=` `0` `    ``# Stores index of each element``    ``# the final sorted array``    ``index ``=` `-``1` `    ``# Stores the pivot element``    ``Pivot ``=` `0` `    ``# Traverse both the array``    ``while` `(index < N ``and` `l < N ``and` `r < M):``        ``if` `(arr[l] < brr[r]):``            ``Pivot ``=` `arr[l]``            ``l ``+``=` `1``        ``else``:``            ``Pivot ``=` `brr[r]``            ``r ``+``=` `1` `        ``index ``+``=` `1` `    ``# If pivot element is not found``    ``# or index < N``    ``while` `(index < N ``and` `l < N):``        ``Pivot ``=` `arr[l]``        ``l ``+``=` `1``        ``index ``+``=` `1` `    ``# If pivot element is not found``    ``# or index < N``    ``while` `(index < N ``and` `r < M):``        ``Pivot ``=` `brr[r]``        ``r ``+``=` `1``        ``index ``+``=` `1` `    ``# Place the first N elements of``    ``# the sorted array into arr[]``    ``# and the last M elements of``    ``# the sorted array into brr[]``    ``partition(arr, N, brr, M, Pivot)` `    ``# Sort both the arrays``    ``arr ``=` `sorted``(arr)` `    ``brr ``=` `sorted``(brr)` `    ``# Print the first N elements``    ``# in sorted order``    ``for` `i ``in` `range``(N):``        ``print``(arr[i], end ``=` `" "``)` `    ``# Print the last M elements``    ``# in sorted order``    ``for` `i ``in` `range``(M):``        ``print``(brr[i], end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``1``, ``5``, ``9` `]``    ``brr ``=` `[ ``2``, ``4``, ``7``, ``10` `]``    ``N ``=` `len``(arr)``    ``M ``=` `len``(brr)``    ` `    ``Merge(arr, N, brr, M)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to implement``// the above approach``using` `System;``class` `GFG{` `// Function to perform the``// partition around the pivot``// element``static` `void` `partition(``int` `[]arr, ``int` `N,``                      ``int` `[]brr, ``int` `M,``                      ``int` `Pivot)``{``  ``// Stores index of each element``  ``// of the array, []arr``  ``int` `l = N - 1;` `  ``// Stores index of each element``  ``// of the array, brr[]``  ``int` `r = 0;` `  ``// Traverse both the array``  ``while` `(l >= 0 && r < M)``  ``{``    ``// If pivot is``    ``// smaller than arr[l]``    ``if` `(arr[l] < Pivot)``      ``l--;` `    ``// If Pivot is``    ``// greater than brr[r]``    ``else` `if` `(brr[r] > Pivot)``      ``r++;` `    ``// If either arr[l] > Pivot``    ``// or brr[r] < Pivot``    ``else``    ``{``      ``int` `t = arr[l];``      ``arr[l] = brr[r];``      ``brr[r] = t;``      ``l--;``      ``r++;``    ``}``  ``}``}` `// Function to merge``// the two sorted array``static` `void` `Merge(``int` `[]arr, ``int` `N,``                  ``int` `[]brr, ``int` `M)``{``  ``// Stores index of each element``  ``// of the array []arr``  ``int` `l = 0;` `  ``// Stores index of each element``  ``// of the array brr[]``  ``int` `r = 0;` `  ``// Stores index of each element``  ``// the readonly sorted array``  ``int` `index = -1;` `  ``// Stores the pivot element``  ``int` `Pivot = 0;` `  ``// Traverse both the array``  ``while` `(index < N && l < N &&``         ``r < M)``  ``{``    ``if` `(arr[l] < brr[r])``    ``{``      ``Pivot = arr[l++];``    ``}``    ``else``    ``{``      ``Pivot = brr[r++];``    ``}``    ``index++;``  ``}` `  ``// If pivot element is not found``  ``// or index < N``  ``while` `(index < N && l < N)``  ``{``    ``Pivot = arr[l++];``    ``index++;``  ``}` `  ``// If pivot element is not``  ``// found or index < N``  ``while` `(index < N && r < M)``  ``{``    ``Pivot = brr[r++];``    ``index++;``  ``}` `  ``// Place the first N elements of``  ``// the sorted array into []arr``  ``// and the last M elements of``  ``// the sorted array into brr[]``  ``partition(arr, N, brr,``            ``M, Pivot);` `  ``// Sort both the arrays``    ``Array.Sort(arr);``    ``Array.Sort(brr);`  `  ``// Print the first N elements``  ``// in sorted order``  ``for` `(``int` `i = 0; i < N; i++)``    ``Console.Write(arr[i] + ``" "``);` `  ``// Print the last M elements``  ``// in sorted order``  ``for` `(``int` `i = 0; i < M; i++)``    ``Console.Write(brr[i] + ``" "``);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``  ``int` `[]arr = {1, 5, 9};``  ``int` `[]brr= {2, 4, 7, 10};``  ``int` `N = arr.Length;``  ``int` `M = brr.Length;``  ``Merge(arr, N, brr, M);``}``}` `// This code is contributed by shikhasingrajput`

## Javascript

 `// Javascript program to implement``// the above approach` `// Function to perform the partition``// around the pivot element``function` `partition( arr,  N,``    ``brr,  M,``    ``Pivot)``{` `    ``// Stores index of each element``    ``// of the array, arr[]``    ``let l = N - 1;` `    ``// Stores index of each element``    ``// of the array, brr[]``    ``let r = 0;` `    ``// Traverse both the array``    ``while` `(l >= 0 && r < M) {` `        ``// If pivot is``        ``// smaller than arr[l]``        ``if` `(arr[l] < Pivot)``            ``l--;` `        ``// If Pivot is``        ``// greater than brr[r]``        ``else` `if` `(brr[r] > Pivot)``            ``r++;` `        ``// If either arr[l] > Pivot``        ``// or brr[r] < Pivot``        ``else` `{``            ``[arr[l],brr[r]]=[brr[r],arr[l]];``            ``l--;``            ``r++;``        ``}``    ``}``}` `// Function to merge``// the two sorted array``function` `Merge(arr, N,``    ``brr, M)``{` `    ``// Stores index of each element``    ``// of the array arr[]``    ``let l = 0;` `    ``// Stores index of each element``    ``// of the array brr[]``    ``let r = 0;` `    ``// Stores index of each element``    ``// the final sorted array``    ``let index = -1;` `    ``// Stores the pivot element``    ``let Pivot = 0;` `    ``// Traverse both the array``    ``while` `(index < N && l < N && r < M) {` `        ``if` `(arr[l] < brr[r]) {``            ``Pivot = arr[l++];``        ``}``        ``else` `{``            ``Pivot = brr[r++];``        ``}``        ``index++;``    ``}` `    ``// If pivot element is not found``    ``// or index < N``    ``while` `(index < N && l < N) {``        ``Pivot = arr[l++];``        ``index++;``    ``}` `    ``// If pivot element is not found``    ``// or index < N``    ``while` `(index < N && r < M) {``        ``Pivot = brr[r++];``        ``index++;``    ``}` `    ``// Place the first N elements of``    ``// the sorted array into arr[]``    ``// and the last M elements of``    ``// the sorted array into brr[]``    ``partition(arr, N, brr,``        ``M, Pivot);` `    ``// Sort both the arrays``    ``arr.sort((a,b)=>a-b);``    ``brr.sort((a,b)=>a-b);` `    ``// Print the first N elements``    ``// in sorted order``    ``for` `(let i = 0; i < N; i++)``    ``console.log(arr[i]);` `    ``// Print the last M elements``    ``// in sorted order``    ``for` `(let i = 0; i < M; i++)``    ``console.log(brr[i]);``}` `// Driver Code``    ``let arr = [1, 5, 9 ];``    ``let brr = [2, 4, 7, 10 ];``    ``let N = arr.length;``    ``let M = brr.length;``    ``Merge(arr, N, brr, M);` `// This code is contributed by adityamaharshi21`

Output

`1 2 4 5 7 9 10 `

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

Efficient Approach: Refer to merge two sorted arrays to efficiently merge the two given arrays.
Time Complexity: O(N + M)
Auxiliary Space: O(N + M)

My Personal Notes arrow_drop_up