Related Articles

# 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)

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