optimization

Author: realDuYuanChao

Sorts/MergeSort.java

@@ -22,24 +22,22 @@ class MergeSort implements SortAlgorithm {
     @Override
     @SuppressWarnings("unchecked")
     public <T extends Comparable<T>> T[] sort(T[] unsorted) {
-        T[] tmp = (T[]) new Comparable[unsorted.length];
-        doSort(unsorted, tmp, 0, unsorted.length - 1);
+        doSort(unsorted, 0, unsorted.length - 1);
         return unsorted;
     }
 
     /**
      * @param arr   The array to be sorted
-     * @param temp  The copy of the actual array
      * @param left  The first index of the array
      * @param right The last index of the array
      *              Recursively sorts the array in increasing order
      **/
-    private static <T extends Comparable<T>> void doSort(T[] arr, T[] temp, int left, int right) {
+    private static <T extends Comparable<T>> void doSort(T[] arr, int left, int right) {
         if (left < right) {
             int mid = left + (right - left) / 2;
-            doSort(arr, temp, left, mid);
-            doSort(arr, temp, mid + 1, right);
-            merge(arr, temp, left, mid, right);
+            doSort(arr, left, mid);
+            doSort(arr, mid + 1, right);
+            merge(arr, left, mid, right);
         }
 
     }
@@ -48,36 +46,36 @@ private static <T extends Comparable<T>> void doSort(T[] arr, T[] temp, int left
      * This method implements the merge step of the merge sort
      *
      * @param arr   The array to be sorted
-     * @param temp  The copy of the actual array
      * @param left  The first index of the array
      * @param mid   The middle index of the array
      * @param right The last index of the array
      *              merges two parts of an array in increasing order
      **/
 
-    private static <T extends Comparable<T>> void merge(T[] arr, T[] temp, int left, int mid, int right) {
-        System.arraycopy(arr, left, temp, left, right - left + 1);
-
-
+    private static <T extends Comparable<T>> void merge(T[] arr, int left, int mid, int right) {
+        int length = right - left + 1;
+        T[] temp = (T[]) new Comparable[length];
         int i = left;
         int j = mid + 1;
-        int k = left;
+        int k = 0;
 
         while (i <= mid && j <= right) {
-            if (temp[i].compareTo(temp[j]) <= 0) {
-                arr[k++] = temp[i++];
+            if (arr[i].compareTo(arr[j]) <= 0) {
+                temp[k++] = arr[i++];
             } else {
-                arr[k++] = temp[j++];
+                temp[k++] = arr[j++];
             }
         }
 
         while (i <= mid) {
-            arr[k++] = temp[i++];
+            temp[k++] = arr[i++];
         }
 
         while (j <= right) {
-            arr[k++] = temp[j++];
+            temp[k++] = arr[j++];
         }
+
+        System.arraycopy(temp, 0, arr, left, length);
     }
 
     // Driver program