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

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 <bits/stdc++.h>
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)