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

• Difficulty Level : Expert
• Last Updated : 02 Nov, 2020

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);` `    ``int` `M = ``sizeof``(brr) / ``sizeof``(brr);` `    ``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`

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
Recommended Articles
Page :