Sort an array having first N elements sorted and last M elements are unsorted
Last Updated :
25 Apr, 2023
Given two positive integers, N and M, and an array arr[ ] consisting of (N + M) integers such that the first N elements are sorted in ascending order and the last M elements are unsorted, the task is to sort the given array in ascending order.
Examples:
Input: N = 3, M = 5, arr[] = {2, 8, 10, 17, 15, 23, 4, 12}
Output: 2 4 8 10 12 15 17 23
Input: N = 4, M = 3, arr[] = {4, 7, 9, 11, 10, 5, 17}
Output: 4 5 7 9 10 11 17
Naive Approach: The simplest approach to solve the given problem is to use the inbuilt sort() function to sort the given array.
C++
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int arr[] = { 2, 8, 10, 17, 15,
23, 4, 12 };
int n = sizeof (arr) / sizeof (arr[0]);
sort(arr, arr + n);
for ( int i = 0; i < n; i++) {
cout << arr[i] << " " ;
}
cout << endl;
return 0;
}
|
Java
import java.util.Arrays;
class GFG {
public static void main(String[] args)
{
int [] arr = { 2 , 8 , 10 , 17 , 15 , 23 , 4 , 12 };
int n = arr.length;
Arrays.sort(arr);
for ( int i = 0 ; i < n; i++) {
System.out.print(arr[i] + " " );
}
System.out.println();
}
}
|
Python3
if __name__ = = '__main__' :
arr = [ 2 , 8 , 10 , 17 , 15 , 23 , 4 , 12 ]
n = len (arr)
arr.sort()
for i in range (n):
print (arr[i], end = " " )
print ()
|
C#
using System;
using System.Linq;
class Program {
static void Main( string [] args)
{
int [] arr = { 2, 8, 10, 17, 15, 23, 4, 12 };
int n = arr.Length;
Array.Sort(arr);
for ( int i = 0; i < n; i++) {
Console.Write(arr[i] + " " );
}
Console.WriteLine();
Console.ReadLine();
}
}
|
Javascript
let arr = [2, 8, 10, 17, 15, 23, 4, 12];
let n = arr.length;
arr.sort( function (a,b){ return a - b});
for (let i = 0; i < n; i++) {
console.log(arr[i] + " " );
}
console.log();
|
Output
2 4 8 10 12 15 17 23
Time Complexity: O((N + M)log(N + M))
Auxiliary Space: O(1)
Efficient Approach: The above approach can also be optimized by using the idea of Merge Sort. The idea is to perform the merge sort operation on the last M array elements and then use the concept of merging two sorted arrays for the first N and the last M element of the array. Follow the steps below to solve the problem:
- Perform the merge sort operation on the last M array elements using the approach discussed in this article.
- After the above steps, the subarrays arr[1, N] and arr[N + 1, M] is sorted in ascending order.
- Merge the two sorted subarrays arr[1, N] and arr[N + 1, M] using the approach discussed in this article.
- After completing the above steps, print the array arr[] as the resultant array.
Below is the implementation of the above approach:
C++
#include <iostream>
using namespace std;
void merge( int a[], int l, int m, int r)
{
int s1 = m - l + 1;
int s2 = r - m;
int left[s1];
int right[s2];
for ( int i = 0; i < s1; i++)
left[i] = a[l + i];
for ( int j = 0; j < s2; j++)
right[j] = a[j + m + 1];
int i = 0, j = 0, k = l;
while (i < s1 && j < s2) {
if (left[i] <= right[j]) {
a[k] = left[i];
i++;
}
else {
a[k] = right[j];
j++;
}
k++;
}
while (i < s1) {
a[k] = left[i];
i++;
k++;
}
while (j < s2) {
a[k] = right[j];
j++;
k++;
}
}
void mergesort( int arr[], int l, int r)
{
if (l < r) {
int mid = l + (r - l) / 2;
mergesort(arr, l, mid);
mergesort(arr, mid + 1, r);
merge(arr, l, mid, r);
}
}
void sortlastMElements( int arr[], int N,
int M)
{
int s = M + N - 1;
mergesort(arr, N, s);
merge(arr, 0, N - 1, N + M - 1);
for ( int i = 0; i < N + M; i++)
cout << arr[i] << " " ;
}
int main()
{
int N = 3;
int M = 5;
int arr[] = { 2, 8, 10, 17, 15,
23, 4, 12 };
sortlastMElements(arr, N, M);
return 0;
}
|
Java
import java.util.*;
class GFG{
static void merge( int a[], int l, int m, int r)
{
int s1 = m - l + 1 ;
int s2 = r - m;
int left[] = new int [s1];
int right[] = new int [s2];
for ( int i = 0 ; i < s1; i++)
left[i] = a[l + i];
for ( int j = 0 ; j < s2; j++)
right[j] = a[j + m + 1 ];
int i = 0 , j = 0 , k = l;
while (i < s1 && j < s2) {
if (left[i] <= right[j]) {
a[k] = left[i];
i++;
}
else {
a[k] = right[j];
j++;
}
k++;
}
while (i < s1) {
a[k] = left[i];
i++;
k++;
}
while (j < s2) {
a[k] = right[j];
j++;
k++;
}
}
static void mergesort( int arr[], int l, int r)
{
if (l < r) {
int mid = l + (r - l) / 2 ;
mergesort(arr, l, mid);
mergesort(arr, mid + 1 , r);
merge(arr, l, mid, r);
}
}
static void sortlastMElements( int arr[], int N,
int M)
{
int s = M + N - 1 ;
mergesort(arr, N, s);
merge(arr, 0 , N - 1 , N + M - 1 );
for ( int i = 0 ; i < N + M; i++)
System.out.print( arr[i] + " " );
}
public static void main(String[] args)
{
int N = 3 ;
int M = 5 ;
int arr[] = { 2 , 8 , 10 , 17 , 15 ,
23 , 4 , 12 };
sortlastMElements(arr, N, M);
}
}
|
Python3
def merge(a, l, m, r):
s1 = m - l + 1
s2 = r - m
left = [ 0 for i in range (s1)]
right = [ 0 for i in range (s2)]
for i in range (s1):
left[i] = a[l + i]
for j in range (s2):
right[j] = a[j + m + 1 ]
i = 0
j = 0
k = l
while (i < s1 and j < s2):
if (left[i] < = right[j]):
a[k] = left[i]
i + = 1
else :
a[k] = right[j]
j + = 1
k + = 1
while (i < s1):
a[k] = left[i]
i + = 1
k + = 1
while (j < s2):
a[k] = right[j]
j + = 1
k + = 1
def mergesort(arr, l, r):
if (l < r):
mid = l + (r - l) / / 2
mergesort(arr, l, mid)
mergesort(arr, mid + 1 , r)
merge(arr, l, mid, r)
def sortlastMElements(arr, N, M):
s = M + N - 1
mergesort(arr, N, s)
merge(arr, 0 , N - 1 , N + M - 1 )
for i in range (N + M):
print (arr[i], end = " " )
if __name__ = = '__main__' :
N = 3
M = 5
arr = [ 2 , 8 , 10 , 17 , 15 , 23 , 4 , 12 ]
sortlastMElements(arr, N, M)
|
C#
using System;
class GFG
{
static void merge( int [] a, int l, int m, int r)
{
int s1 = m - l + 1;
int s2 = r - m;
int i = 0, j = 0;
int [] left = new int [s1];
int [] right = new int [s2];
for (i = 0; i < s1; i++)
left[i] = a[l + i];
for (j = 0; j < s2; j++)
right[j] = a[j + m + 1];
int k = l;
while (i < s1 && j < s2) {
if (left[i] <= right[j]) {
a[k] = left[i];
i++;
}
else {
a[k] = right[j];
j++;
}
k++;
}
while (i < s1) {
a[k] = left[i];
i++;
k++;
}
while (j < s2) {
a[k] = right[j];
j++;
k++;
}
}
static void mergesort( int [] arr, int l, int r)
{
if (l < r) {
int mid = l + (r - l) / 2;
mergesort(arr, l, mid);
mergesort(arr, mid + 1, r);
merge(arr, l, mid, r);
}
}
static void sortlastMElements( int [] arr, int N,
int M)
{
int s = M + N - 1;
mergesort(arr, N, s);
merge(arr, 0, N - 1, N + M - 1);
for ( int i = 0; i < N + M; i++)
Console.Write( arr[i] + " " );
}
static void Main()
{
int N = 3;
int M = 5;
int [] arr = { 2, 8, 10, 17, 15,
23, 4, 12 };
sortlastMElements(arr, N, M);
}
}
|
Javascript
<script>
function merge(a, l, m, r) {
let s1 = m - l + 1;
let s2 = r - m;
let left = new Array(s1);
let right = new Array(s2);
for (let i = 0; i < s1; i++)
left[i] = a[l + i];
for (let j = 0; j < s2; j++)
right[j] = a[j + m + 1];
let i = 0, j = 0, k = l;
while (i < s1 && j < s2) {
if (left[i] <= right[j]) {
a[k] = left[i];
i++;
}
else {
a[k] = right[j];
j++;
}
k++;
}
while (i < s1) {
a[k] = left[i];
i++;
k++;
}
while (j < s2) {
a[k] = right[j];
j++;
k++;
}
}
function mergesort(arr, l, r) {
if (l < r) {
let mid = Math.floor(l + (r - l) / 2);
mergesort(arr, l, mid);
mergesort(arr, mid + 1, r);
merge(arr, l, mid, r);
}
}
function sortlastMElements(arr, N, M) {
let s = M + N - 1;
mergesort(arr, N, s);
merge(arr, 0, N - 1, N + M - 1);
for (let i = 0; i < N + M; i++)
document.write(arr[i] + " " );
}
let N = 3;
let M = 5;
let arr = [2, 8, 10, 17, 15,
23, 4, 12];
sortlastMElements(arr, N, M);
</script>
|
Output:
2 4 8 10 12 15 17 23
Time Complexity: O(M*log M)
Auxiliary Space: O(N + M)
Share your thoughts in the comments
Please Login to comment...