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++ 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;
}
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+" ");
}
}
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=" ")
// 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() + " ");
}
}
}
// 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.