重写java版归并排序

Author: qrqhuang

5.mergeSort.md

@@ -143,47 +143,52 @@ func merge(left []int, right []int) []int {
 public class MergeSort implements IArraySort {
 
     @Override
-    public int[] sort(int[] sourceArray) throws Exception {
-        // 对 arr 进行拷贝，不改变参数内容
-        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
+    public int[] sort(int[] arr) throws Exception {
+        mergeSort(arr, 0, arr.length - 1);
+        return arr;
+    }
 
-        if (arr.length < 2) {
-            return arr;
+    private void mergeSort(int[] arr, int left, int right) {
+        if (left >= right) {
+            return;
         }
-        int middle = (int) Math.floor(arr.length / 2);
 
-        int[] left = Arrays.copyOfRange(arr, 0, middle);
-        int[] right = Arrays.copyOfRange(arr, middle, arr.length);
+        int mid = (right + left) / 2;
 
-        return merge(sort(left), sort(right));
+        //分
+        mergeSort(arr, left, mid);
+        mergeSort(arr, mid + 1, right);
+        //治
+        merge(arr, left, mid, right);
     }
 
-    protected int[] merge(int[] left, int[] right) {
-        int[] result = new int[left.length + right.length];
-        int i = 0;
-        while (left.length > 0 && right.length > 0) {
-            if (left[0] <= right[0]) {
-                result[i++] = left[0];
-                left = Arrays.copyOfRange(left, 1, left.length);
+
+    /**
+     * 主要思想， 两个已经排序好的数组， 如何归并
+     * 当元素个数趋近单个元素时， 归并即为排序过程
+     */
+    private void merge(int[] arr, int left, int mid, int right) {
+        int[] tmp = new int[right - left + 1];
+
+        int i = left;
+        int j = mid + 1;
+        int k = 0;
+
+        while (i <= mid && j <= right) {
+            if (arr[i] <= arr[j]) { //取等号， 优先匹配左边数组予以填充
+                tmp[k++] = arr[i++];
             } else {
-                result[i++] = right[0];
-                right = Arrays.copyOfRange(right, 1, right.length);
+                tmp[k++] = arr[j++];
             }
         }
 
-        while (left.length > 0) {
-            result[i++] = left[0];
-            left = Arrays.copyOfRange(left, 1, left.length);
-        }
-
-        while (right.length > 0) {
-            result[i++] = right[0];
-            right = Arrays.copyOfRange(right, 1, right.length);
-        }
+        //队尾的直接填充
+        while (i <= mid) tmp[k++] = arr[i++];
+        while (j <= right) tmp[k++] = arr[j++];
 
-        return result;
+        //覆盖原数组
+        System.arraycopy(tmp, 0, arr, left, tmp.length);
     }
-
 }
 ```
 

src/java/main/MergeSort.java

@@ -1,47 +1,55 @@
-import java.util.Arrays;
-
 /**
  * 归并排序
+ * @author qrqhuangcy
+ * @date 2020/5/4
  */
 public class MergeSort implements IArraySort {
 
     @Override
     public int[] sort(int[] arr) throws Exception {
-        if (arr.length < 2) {
-            return arr;
+        mergeSort(arr, 0, arr.length - 1);
+        return arr;
+    }
+
+    private void mergeSort(int[] arr, int left, int right) {
+        if (left >= right) {
+            return;
         }
-        int middle = (int) Math.floor(arr.length / 2);
 
-        int[] left = Arrays.copyOfRange(arr, 0, middle);
-        int[] right = Arrays.copyOfRange(arr, middle, arr.length);
+        int mid = (right + left) / 2;
 
-        return merge(sort(left), sort(right));
+        //分
+        mergeSort(arr, left, mid);
+        mergeSort(arr, mid + 1, right);
+        //治
+        merge(arr, left, mid, right);
     }
 
-    protected int[] merge(int[] left, int[] right) {
-        int[] result = new int[left.length + right.length];
-        int l = 0, r = 0, len = 0;
-        while (len < left.length + right.length) {
-            if (left[l] <= right[r]) {
-                result[len++] = left[l++];
-
-                if (l == left.length) {
-                    for (int i = r; i < right.length; i++) {
-                        result[len++] = right[r++];
-                    }
-                }
-            } else {
-                result[len++] = right[r++];
 
-                if (r == right.length) {
-                    for (int i = l; i < left.length; i++) {
-                        result[len++] = left[l++];
-                    }
-                }
+    /**
+     * 主要思想， 两个已经排序好的数组， 如何归并
+     * 当元素个数趋近单个元素时， 归并即为排序过程
+     */
+    private void merge(int[] arr, int left, int mid, int right) {
+        int[] tmp = new int[right - left + 1];
+
+        int i = left;
+        int j = mid + 1;
+        int k = 0;
+
+        while (i <= mid && j <= right) {
+            if (arr[i] <= arr[j]) { //取等号， 优先匹配左边数组予以填充
+                tmp[k++] = arr[i++];
+            } else {
+                tmp[k++] = arr[j++];
             }
         }
 
-        return result;
-    }
+        //队尾的直接填充
+        while (i <= mid) tmp[k++] = arr[i++];
+        while (j <= right) tmp[k++] = arr[j++];
 
+        //覆盖原数组
+        System.arraycopy(tmp, 0, arr, left, tmp.length);
+    }
 }

src/java/test/ArraySortTest.java

@@ -101,13 +101,6 @@ public void mergeSort() throws Exception {
         assertArrayEquals(sortedArray, new MergeSort().sort(array));
     }
 
-    @Test
-    public void mergeSort_merge() throws Exception {
-        assertArrayEquals(new int[]{1, 2}, new MergeSort().merge(new int[]{1, 2}, new int[]{}));
-        assertArrayEquals(new int[]{1, 2}, new MergeSort().merge(new int[]{1}, new int[]{2}));
-        assertArrayEquals(new int[]{1, 2, 3}, new MergeSort().merge(new int[]{1, 3}, new int[]{2}));
-    }
-
     @Test
     public void quickSort() throws Exception {
         assertArrayEquals(sortedArray, new QuickSort().sort(array));