MergeSort space optimized made simple

Author: rampatra

src/main/java/com/rampatra/sorting/MergeSort.java

@@ -19,20 +19,20 @@ public class MergeSort {
      * Time complexity:     O(n log n)
      * Space complexity:    O(n) (also needs O(log n) stack space as it is recursive)
      *
-     * @param a
+     * @param arr
      * @return
      */
-    public static int[] mergeSort(int[] a) {
-        if (a.length == 1) return a;
+    public static int[] mergeSort(int[] arr) {
+        if (arr.length == 1) return arr;
 
-        int[] x = mergeSort(Arrays.copyOfRange(a, 0, a.length / 2));
-        int[] y = mergeSort(Arrays.copyOfRange(a, a.length / 2, a.length));
+        int[] x = mergeSort(Arrays.copyOfRange(arr, 0, arr.length / 2));
+        int[] y = mergeSort(Arrays.copyOfRange(arr, arr.length / 2, arr.length));
 
         return merge(x, y);
     }
 
     /**
-     * Merges two sorted arrays {@param a} and {@param b}.
+     * Merges two sorted arrays {@code a} and {@code b}.
      *
      * @param a
      * @param b

src/main/java/com/rampatra/sorting/MergeSortSpaceOptimized.java

@@ -10,59 +10,58 @@ public class MergeSortSpaceOptimized {
 
     /**
      * This is entry point. You can call this method to sort
-     * an array {@code a}.
+     * an array {@code arr}.
      *
-     * @param a array to be sorted
+     * @param arr array to be sorted
      */
-    public static void mergeSort(int[] a) {
-        mergeSort(a, new int[a.length], 0, a.length - 1);
+    public static void mergeSort(int[] arr) {
+        mergeSort(arr, new int[arr.length], 0, arr.length - 1);
     }
 
-    private static void mergeSort(int[] a, int[] helper, int low, int high) {
+    private static void mergeSort(int[] arr, int[] helper, int low, int high) {
         if (low < high) {
             int mid = (low + high) / 2; // to prevent overflow you can instead do: mid = low + (high - low) / 2
 
-            mergeSort(a, helper, low, mid);
-            mergeSort(a, helper, mid + 1, high);
+            mergeSort(arr, helper, low, mid);
+            mergeSort(arr, helper, mid + 1, high);
 
-            merge(a, helper, low, mid, high);
+            merge(arr, helper, low, mid, high);
         }
     }
 
-    private static void merge(int[] a, int[] helper, int low, int mid, int high) {
-        // have a helper array from which you will choose numbers and finally place it in a
-        for (int i = low; i <= high; i++) {
-            helper[i] = a[i];
-        }
-
-        int helperLeft = low;
-        int helperRight = mid + 1;
-        int current = low;
+    private static void merge(int[] arr, int[] helper, int low, int mid, int high) {
+        int k = low;
 
-        // check left half of the helper array with the right half
-        while (helperLeft <= mid && helperRight <= high) {
-            if (helper[helperLeft] < helper[helperRight]) {
-                a[current++] = helper[helperLeft++];
-            } else {
-                a[current++] = helper[helperRight++];
+        /*
+            Similar to merging two sorted arrays, i.e, merge two parts of arr[], arr[low..mid] and arr[mid+1..high],
+            and store in helper[]
+         */
+        for (int i = low, j = mid + 1; i <= mid || j <= high; ) {
+            if (i > mid) {
+                helper[k++] = arr[j++];
+            } else if (j > high) {
+                helper[k++] = arr[i++];
+            } else if (arr[i] <= arr[j]) {
+                helper[k++] = arr[i++];
+            } else if (arr[i] > arr[j]) {
+                helper[k++] = arr[j++];
             }
         }
 
-        // copy the left half of the helper array and not the right
-        // half as the right half is already there in array a
-        for (int i = helperLeft; i <= mid; i++) {
-            a[current++] = helper[i];
+        // finally copy the sorted result from helper[] to arr[]
+        for (int i = low; i <= high; i++) { // note: we can use System.arraycopy() for better performance
+            arr[i] = helper[i];
         }
     }
 
     public static void main(String[] args) {
-        int[] a = {3, 6, 8, 9, 1, 2, 4};
-        System.out.println(Arrays.toString(a));
-        mergeSort(a);
-        System.out.println(Arrays.toString(a));
-        a = new int[]{5, 8, 1, 2, 5, 3, 0, 1, 2, 4};
-        System.out.println(Arrays.toString(a));
-        mergeSort(a);
-        System.out.println(Arrays.toString(a));
+        int[] arr = {3, 6, 8, 9, 1, 2, 4};
+        System.out.println(Arrays.toString(arr));
+        mergeSort(arr);
+        System.out.println(Arrays.toString(arr));
+        arr = new int[]{5, 8, 1, 2, 5, 3, 0, 1, 2, 4};
+        System.out.println(Arrays.toString(arr));
+        mergeSort(arr);
+        System.out.println(Arrays.toString(arr));
     }
 }