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:
- Initialize a variable, say index to store the index of each element of the final sorted array.
- Find the (N + 1)th element of the final sorted array as a pivot element.
- Perform the quick sort partition around the pivot element.
- Finally, sort both the array arr[] and brr[] separately.
Below is the implementation of the above approach:
// 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 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 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# 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 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 |
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)