Java排序之歸並排序

1. 簡介

歸並排序的算法是將多個有序數據表合並成一個有序數據表。如果參與合並的只有兩個有序表，則成為二路合並。對於一個原始的待排序數列，往往可以通過分割的方法來歸結為多路合並排序。

2. 歸並排序思路

1. 將長度為n的待排序數組看做是由n個有序長度為1的數組組成
2. 將其兩兩合並，得到長度為2的有序數組
3. 然後再對這些子表進行合並，得到長度為4的有序數組
4. 重復上述過程，一直到最後的子表長度為n也就完成了排序

3. 代碼實例

歸並排序有兩種實現方式：遞歸和非遞歸。在看歸並排序的代碼之前先來看一下怎麽和合並兩個有序數組：

// 基礎，合並兩個有序數組
public static int
 
[] merge2Arr(int[] arr1, int[] arr2) {
  int len1 = arr1.length;
  int len2 = arr2.length;
  int[] res = new int[len1 + len2];  // 使用一個數組用來存儲排好序的數組
  int i = 0, j = 0, k = 0;
  while(i < len1 && j < len2) {
    res[k++] = arr1[i] < arr2[j]? arr1[i++] : arr2[j++];
  }
  while(i < len1) {
    res[k++] = arr1[i++];
  }
  while
 
(j < len2) {
    res[k++] = arr2[j++];
  }
  return res;
}

歸並排序的遞歸實現：

// 歸並排序，遞歸實現
public void sortMergeRecursion(int[] nums) {
  sortMergeRecursionHelper(nums, 0, nums.length - 1);
}
public void sortMergeRecursionHelper(int[] nums,int left, int right) {
  if(left == right) return;  // 當待排序的序列長度為1時，遞歸開始回溯，進行merge
 

  int middle = left + (right - left) / 2;
  sortMergeRecursionHelper(nums, left, middle);
  sortMergeRecursionHelper(nums, middle + 1, right);
  mergeArr(nums, left, middle, right);
}
public void mergeArr(int[] nums, int left, int middle, int right) {
  int[] tem = new int[right - left + 1];
  int i = left, j = middle + 1, k = 0;
  while(i <= middle && j <= right) {
    tem[k++] = nums[i] < nums[j]? nums[i++] : nums[j++];
  }
  while(i <= middle) {
    tem[k++] = nums[i++];
  }
  while(j <= right) {
    tem[k++] = nums[j++];
  }
  // 將輔助數組數據寫入原數組
  int index = 0;
  while(left <= right) {
    nums[left++] = tem[index++];
  }
}

歸並排序的非遞歸實現（叠代）：

// 歸並排序，非遞歸實現(叠代)
public void sortMergeIteration(int[] nums) {
  int len = 1;  // 初始排序數組的長度
  while(len < nums.length) {
    for(int i = 0; i < nums.length; i += len * 2) {
      sortMergeIterationHelper(nums, i, len);
    }
    len *= 2;  // 每次將排序數組的長度*2
  }
}
/**
 * 輔助函數
 * @param nums  原數組
 * @param start 從start位置開始
 * @param len  本次合並的數組長度
 */
public void sortMergeIterationHelper(int[] nums, int start, int len) {
  int[] tem = new int[len * 2];
  int i = start;
  int j = start + len;
  int k = 0;
  while(i < start + len && (j < start + len + len && j < nums.length)) {
    tem[k++] = nums[i] < nums[j]? nums[i++] : nums[j++];
  }
  while(i < start + len && i < nums.length) {  // 註意：這裏i也可能超出長度
    tem[k++] = nums[i++];
  }
  while(j < start + len + len && j < nums.length) {
    tem[k++] = nums[j++];
  }
  int right = start + len + len;
  int index = 0;
  while(start < nums.length && start < right) {
    nums[start++] = tem[index++];
  }
}

歸並排序的時間復雜度為O(n*log2n),空間復雜度為O(n)

歸並排序是一種穩定的排序方法。

參考：

https://blog.csdn.net/y999666/article/details/50942604

Java排序之歸並排序