In-Place Merge Sort | Set 2

Given an array A[] of size N, the task is to sort the array in increasing order using In-Place Merge Sort.

Examples:

Input: A = {5, 6, 3, 2, 1, 6, 7}
Output: {1, 2, 3, 5, 6, 6, 7}

Input: A = {2, 3, 4, 1}
Output: {1, 2, 3, 4}

Approach: The idea is to use the inplace_merge() function to merge the sorted arrays in O(1) space. Follow the steps below to solve the problem:

• Create a recursive function mergeSort() that accepts the start and the end indices of the array as parameters. Now, perform the following steps:
  • If size of the array is equal to 1, simply return out of the function.
  • Otherwise, calculate the middle index to split the array into two subarrays.
  • Recursively call mergeSort() on the left and right subarrays to sort them separately.
  • Then, call the inplace_merge() function to merge the two subarrays.
• After completing the above steps, print the sorted array A[].

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
#define it vector<int>::iterator
using namespace std;

// Recursive function to split the array
// into two subarrays and sort them
void mergeSortUtil(it left, it right)
{
    // Handle the base case
    if (right - left <= 1)
        return;

    // Otherwise, find the middle index
    it mid = left + (right - left) / 2;

    // Recursively sort
    // the left subarray
    mergeSortUtil(left, mid);

    // Recursively sort
    // the right subarray
    mergeSortUtil(mid, right);

    // Merge the two sorted arrays using
    // inplace_merge() function
    inplace_merge(left, mid, right);

    return;
}

// Function to sort the array
// using inplace Merge Sort
void mergeSort(vector<int> arr)
{
    // Recursive function to sort the array
    mergeSortUtil(arr.begin(), arr.end());

    // Print the sorted array
    for (int el : arr)
        cout << el << " ";
}

// Driver Code
int main()
{
    vector<int> arr = { 5, 6, 3, 2, 1, 6, 7 };

    mergeSort(arr);

    return 0;
}

Java

import java.util.Arrays;

public class MergeSort {

    // Recursive function to split the array
    // into two subarrays and sort them
    public static void mergeSortUtil(int[] arr, int left, int right) {
        // Handle the base case
        if (right - left <= 1) {
            return;
        }

        // Otherwise, find the middle index
        int mid = left + (right - left) / 2;

        // Recursively sort the left subarray
        mergeSortUtil(arr, left, mid);

        // Recursively sort the right subarray
        mergeSortUtil(arr, mid, right);

        // Merge the two sorted arrays
        merge(arr, left, mid, right);
    }

    // Function to merge two sorted subarrays
    public static void merge(int[] arr, int left, int mid, int right) {
        // Create a temporary array to store the merged subarray
        int[] temp = new int[right - left];

        // Initialize indices for the left and right subarrays
        int i = left;
        int j = mid;
        int k = 0;

        // Merge the two subarrays
        while (i < mid && j < right) {
            if (arr[i] < arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }

        // Copy the remaining elements from the left subarray
        while (i < mid) {
            temp[k++] = arr[i++];
        }

        // Copy the remaining elements from the right subarray
        while (j < right) {
            temp[k++] = arr[j++];
        }

        // Copy the merged subarray back to the original array
        for (i = left, k = 0; i < right; i++, k++) {
            arr[i] = temp[k];
        }
    }

    // Function to sort the array using merge sort
    public static void mergeSort(int[] arr) {
        // Recursive function to sort the array
        mergeSortUtil(arr, 0, arr.length);
    }

    public static void main(String[] args) {
        int[] arr = { 5, 6, 3, 2, 1, 6, 7 };

        mergeSort(arr);

      for(int i:arr)
        System.out.print(i+" ");
    }
}

Python3

from typing import List

def mergeSort(arr: List[int]):
    if len(arr) > 1:
        mid = len(arr) // 2
        left_half = arr[:mid]
        right_half = arr[mid:]

        # Recursive call to sort the left and right halves
        mergeSort(left_half)
        mergeSort(right_half)

        i = j = k = 0

        # Merge the sorted halves
        while i < len(left_half) and j < len(right_half):
            if left_half[i] < right_half[j]:
                arr[k] = left_half[i]
                i += 1
            else:
                arr[k] = right_half[j]
                j += 1
            k += 1

        # Check for any remaining elements in both halves
        while i < len(left_half):
            arr[k] = left_half[i]
            i += 1
            k += 1

        while j < len(right_half):
            arr[k] = right_half[j]
            j += 1
            k += 1

# Driver Code
if __name__ == '__main__':
    arr = [5, 6, 3, 2, 1, 6, 7]

    mergeSort(arr)

    # Print the sorted array
    for el in arr:
        print(el, end=" ")

C#

// Include namespace system
using System;


public class MergeSort
{
    // Recursive function to split the array
    // into two subarrays and sort them
    public static void mergeSortUtil(int[] arr, int left, int right)
    {
        // Handle the base case
        if (right - left <= 1)
        {
            return;
        }
        // Otherwise, find the middle index
        var mid = left + (int)((right - left) / 2);
        // Recursively sort the left subarray
        MergeSort.mergeSortUtil(arr, left, mid);
        // Recursively sort the right subarray
        MergeSort.mergeSortUtil(arr, mid, right);
        // Merge the two sorted arrays
        MergeSort.merge(arr, left, mid, right);
    }
    // Function to merge two sorted subarrays
    public static void merge(int[] arr, int left, int mid, int right)
    {
        // Create a temporary array to store the merged subarray
        int[] temp = new int[right - left];
        // Initialize indices for the left and right subarrays
        var i = left;
        var j = mid;
        var k = 0;
        // Merge the two subarrays
        while (i < mid && j < right)
        {
            if (arr[i] < arr[j])
            {
                temp[k++] = arr[i++];
            }
            else
            {
                temp[k++] = arr[j++];
            }
        }
        // Copy the remaining elements from the left subarray
        while (i < mid)
        {
            temp[k++] = arr[i++];
        }
        // Copy the remaining elements from the right subarray
        while (j < right)
        {
            temp[k++] = arr[j++];
        }
        // Copy the merged subarray back to the original array
        for (i = left, k = 0; i < right; i++, k++)
        {
            arr[i] = temp[k];
        }
    }
    // Function to sort the array using merge sort
    public static void mergeSort(int[] arr)
    {
        // Recursive function to sort the array
        MergeSort.mergeSortUtil(arr, 0, arr.Length);
    }
    public static void Main(String[] args)
    {
        int[] arr = {5, 6, 3, 2, 1, 6, 7};
        MergeSort.mergeSort(arr);
        foreach (int i in arr)
        {            Console.Write(i.ToString() + " ");
        }
    }
}

Javascript

// Recursive function to split the array
// into two subarrays and sort them
function mergeSortUtil(left, right) {
  // Handle the base case
  if (right - left <= 1) {
    return;
  }

  // Otherwise, find the middle index
  const mid = left + Math.floor((right - left) / 2);

  // Recursively sort
  // the left subarray
  mergeSortUtil(left, mid);

  // Recursively sort
  // the right subarray
  mergeSortUtil(mid, right);

  // Merge the two sorted arrays using
  // splice() function
  const leftArr = arr.slice(left, mid);
  const rightArr = arr.slice(mid, right);
  let i = 0;
  let j = 0;
  let k = left;
  while (i < leftArr.length && j < rightArr.length) {
    if (leftArr[i] < rightArr[j]) {
      arr[k] = leftArr[i];
      i++;
    } else {
      arr[k] = rightArr[j];
      j++;
    }
    k++;
  }
  while (i < leftArr.length) {
    arr[k] = leftArr[i];
    i++;
    k++;
  }
  while (j < rightArr.length) {
    arr[k] = rightArr[j];
    j++;
    k++;
  }
}

// Function to sort the array
// using inplace Merge Sort
function mergeSort(arr) {
  // Recursive function to sort the array
  mergeSortUtil(0, arr.length);

  // Print the sorted array
  console.log(arr.join(" "));
}

// Driver Code
const arr = [5, 6, 3, 2, 1, 6, 7];
mergeSort(arr);

// This code is contributed by akashish__

Output

1 2 3 5 6 6 7

Time Complexity: O(N * log(N))
Auxiliary Space: O(1)

Alternate Approaches: Refer to the previous article for other approaches to solve this problem.