Skip to content
Related Articles

Related Articles

Improve Article

Sort an array having first N elements sorted and last M elements are unsorted

  • Difficulty Level : Medium
  • Last Updated : 29 Jun, 2021

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.



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++




// C++ program for the above approach
 
#include <iostream>
using namespace std;
 
// Function for merging the two sorted
// arrays
void merge(int a[], int l, int m, int r)
{
    int s1 = m - l + 1;
    int s2 = r - m;
 
    // Create two temp arrays
    int left[s1];
    int right[s2];
 
    // Copy elements to left array
    for (int i = 0; i < s1; i++)
        left[i] = a[l + i];
 
    // Copy elements to right array
    for (int j = 0; j < s2; j++)
        right[j] = a[j + m + 1];
 
    int i = 0, j = 0, k = l;
 
    // Merge the array back into the
    // array over the range [l, r]
    while (i < s1 && j < s2) {
 
        // If the current left element
        // is smaller than the current
        // right element
        if (left[i] <= right[j]) {
            a[k] = left[i];
            i++;
        }
 
        // Otherwise
        else {
            a[k] = right[j];
            j++;
        }
        k++;
    }
 
    // Copy the remaining elements of
    // the array left[]
    while (i < s1) {
        a[k] = left[i];
        i++;
        k++;
    }
 
    // Copy the remaining elements of
    // the array right[]
    while (j < s2) {
        a[k] = right[j];
        j++;
        k++;
    }
}
 
// Function to sort the array over the
// range [l, r]
void mergesort(int arr[], int l, int r)
{
    if (l < r) {
 
        // Find the middle index
        int mid = l + (r - l) / 2;
 
        // Recursively call for the
        // two halves
        mergesort(arr, l, mid);
        mergesort(arr, mid + 1, r);
 
        // Perform the merge operation
        merge(arr, l, mid, r);
    }
}
 
// Function to sort an array for the
// last m elements are unsorted
void sortlastMElements(int arr[], int N,
                       int M)
{
    int s = M + N - 1;
 
    // Sort the last m elements
    mergesort(arr, N, s);
 
    // Merge the two sorted subarrays
    merge(arr, 0, N - 1, N + M - 1);
 
    // Print the sorted array
    for (int i = 0; i < N + M; i++)
        cout << arr[i] << " ";
}
 
// Driver Code
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




// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function for merging the two sorted
// arrays
static void merge(int a[], int l, int m, int r)
{
    int s1 = m - l + 1;
    int s2 = r - m;
 
    // Create two temp arrays
    int left[] = new int[s1];
    int right[] = new int[s2];
 
    // Copy elements to left array
    for (int i = 0; i < s1; i++)
        left[i] = a[l + i];
 
    // Copy elements to right array
    for (int j = 0; j < s2; j++)
        right[j] = a[j + m + 1];
 
    int i = 0, j = 0, k = l;
 
    // Merge the array back into the
    // array over the range [l, r]
    while (i < s1 && j < s2) {
 
        // If the current left element
        // is smaller than the current
        // right element
        if (left[i] <= right[j]) {
            a[k] = left[i];
            i++;
        }
 
        // Otherwise
        else {
            a[k] = right[j];
            j++;
        }
        k++;
    }
 
    // Copy the remaining elements of
    // the array left[]
    while (i < s1) {
        a[k] = left[i];
        i++;
        k++;
    }
 
    // Copy the remaining elements of
    // the array right[]
    while (j < s2) {
        a[k] = right[j];
        j++;
        k++;
    }
}
 
// Function to sort the array over the
// range [l, r]
static void mergesort(int arr[], int l, int r)
{
    if (l < r) {
 
        // Find the middle index
        int mid = l + (r - l) / 2;
 
        // Recursively call for the
        // two halves
        mergesort(arr, l, mid);
        mergesort(arr, mid + 1, r);
 
        // Perform the merge operation
        merge(arr, l, mid, r);
    }
}
 
// Function to sort an array for the
// last m elements are unsorted
static void sortlastMElements(int arr[], int N,
                       int M)
{
    int s = M + N - 1;
 
    // Sort the last m elements
    mergesort(arr, N, s);
 
    // Merge the two sorted subarrays
    merge(arr, 0, N - 1, N + M - 1);
 
    // Print the sorted array
    for (int i = 0; i < N + M; i++)
         System.out.print( arr[i] + " ");
}
 
// Driver Code
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);
}
}
 
// This code is contributed by code_hunt.

Python3




# Python3 program for the above approach
 
# Function for merging the two sorted
# arrays
def merge(a, l, m, r):
     
    s1 = m - l + 1
    s2 = r - m
 
    # Create two temp arrays
    left = [0 for i in range(s1)]
    right = [0 for i in range(s2)]
 
    # Copy elements to left array
    for i in range(s1):
        left[i] = a[l + i]
 
    # Copy elements to right array
    for j in range(s2):
        right[j] = a[j + m + 1]
         
    i = 0
    j = 0
    k = l
 
    # Merge the array back into the
    # array over the range [l, r]
    while (i < s1 and j < s2):
         
        # If the current left element
        # is smaller than the current
        # right element
        if (left[i] <= right[j]):
            a[k] = left[i]
            i += 1
 
        # Otherwise
        else:
            a[k] = right[j]
            j += 1
             
        k += 1
 
    # Copy the remaining elements of
    # the array left[]
    while (i < s1):
        a[k] = left[i]
        i += 1
        k += 1
 
    # Copy the remaining elements of
    # the array right[]
    while (j < s2):
        a[k] = right[j]
        j += 1
        k += 1
 
# Function to sort the array over the
# range [l, r]
def mergesort(arr, l,  r):
     
    if (l < r):
         
        # Find the middle index
        mid = l + (r - l) // 2
 
        # Recursively call for the
        # two halves
        mergesort(arr, l, mid)
        mergesort(arr, mid + 1, r)
 
        # Perform the merge operation
        merge(arr, l, mid, r)
 
# Function to sort an array for the
# last m elements are unsorted
def sortlastMElements(arr, N, M):
     
    s = M + N - 1
 
    # Sort the last m elements
    mergesort(arr, N, s)
 
    # Merge the two sorted subarrays
    merge(arr, 0, N - 1, N + M - 1)
 
    # Print the sorted array
    for i in range(N + M):
        print(arr[i], end = " ")
 
# Driver Code
if __name__ == '__main__':
     
    N = 3
    M = 5
    arr = [ 2, 8, 10, 17, 15, 23, 4, 12 ]
     
    sortlastMElements(arr, N, M)
     
# This code is contributed by ipg2016107

C#




// C# program for the above approach
using System;
class GFG
{
 
// Function for merging the two sorted
// arrays
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;
  
    // Create two temp arrays
    int[] left = new int[s1];
    int[] right = new int[s2];
  
    // Copy elements to left array
    for (i = 0; i < s1; i++)
        left[i] = a[l + i];
  
    // Copy elements to right array
    for (j = 0; j < s2; j++)
        right[j] = a[j + m + 1];
  
    int k = l;
     
  
    // Merge the array back into the
    // array over the range [l, r]
    while (i < s1 && j < s2) {
  
        // If the current left element
        // is smaller than the current
        // right element
        if (left[i] <= right[j]) {
            a[k] = left[i];
            i++;
        }
  
        // Otherwise
        else {
            a[k] = right[j];
            j++;
        }
        k++;
    }
  
    // Copy the remaining elements of
    // the array left[]
    while (i < s1) {
        a[k] = left[i];
        i++;
        k++;
    }
  
    // Copy the remaining elements of
    // the array right[]
    while (j < s2) {
        a[k] = right[j];
        j++;
        k++;
    }
}
  
// Function to sort the array over the
// range [l, r]
static void mergesort(int[] arr, int l, int r)
{
    if (l < r) {
  
        // Find the middle index
        int mid = l + (r - l) / 2;
  
        // Recursively call for the
        // two halves
        mergesort(arr, l, mid);
        mergesort(arr, mid + 1, r);
  
        // Perform the merge operation
        merge(arr, l, mid, r);
    }
}
  
// Function to sort an array for the
// last m elements are unsorted
static void sortlastMElements(int[] arr, int N,
                       int M)
{
    int s = M + N - 1;
  
    // Sort the last m elements
    mergesort(arr, N, s);
  
    // Merge the two sorted subarrays
    merge(arr, 0, N - 1, N + M - 1);
  
    // Print the sorted array
    for (int i = 0; i < N + M; i++)
         Console.Write( arr[i] + " ");
}
 
// Driver code
static void Main()
{
    int N = 3;
    int M = 5;
    int[] arr = { 2, 8, 10, 17, 15,
                  23, 4, 12 };
    sortlastMElements(arr, N, M);
 
}
}
 
// This code is contributed by sanjoy_62.

Javascript




<script>
 
// JavaScript program for the above approach
 
 
// Function for merging the two sorted
// arrays
function merge(a, l, m, r) {
    let s1 = m - l + 1;
    let s2 = r - m;
 
    // Create two temp arrays
    let left = new Array(s1);
    let right = new Array(s2);
 
    // Copy elements to left array
    for (let i = 0; i < s1; i++)
        left[i] = a[l + i];
 
    // Copy elements to right array
    for (let j = 0; j < s2; j++)
        right[j] = a[j + m + 1];
 
    let i = 0, j = 0, k = l;
 
    // Merge the array back leto the
    // array over the range [l, r]
    while (i < s1 && j < s2) {
 
        // If the current left element
        // is smaller than the current
        // right element
        if (left[i] <= right[j]) {
            a[k] = left[i];
            i++;
        }
 
        // Otherwise
        else {
            a[k] = right[j];
            j++;
        }
        k++;
    }
 
    // Copy the remaining elements of
    // the array left[]
    while (i < s1) {
        a[k] = left[i];
        i++;
        k++;
    }
 
    // Copy the remaining elements of
    // the array right[]
    while (j < s2) {
        a[k] = right[j];
        j++;
        k++;
    }
}
 
// Function to sort the array over the
// range [l, r]
function mergesort(arr, l, r) {
    if (l < r) {
 
        // Find the middle index
        let mid = Math.floor(l + (r - l) / 2);
 
        // Recursively call for the
        // two halves
        mergesort(arr, l, mid);
        mergesort(arr, mid + 1, r);
 
        // Perform the merge operation
        merge(arr, l, mid, r);
    }
}
 
// Function to sort an array for the
// last m elements are unsorted
function sortlastMElements(arr, N, M) {
    let s = M + N - 1;
 
    // Sort the last m elements
    mergesort(arr, N, s);
 
    // Merge the two sorted subarrays
    merge(arr, 0, N - 1, N + M - 1);
 
    // Prlet the sorted array
    for (let i = 0; i < N + M; i++)
        document.write(arr[i] + " ");
}
 
// Driver Code
 
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)

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 :