归并排序详解-优快云博客

转自
https://blog.youkuaiyun.com/u014672511/article/details/80593436
https://blog.youkuaiyun.com/hpccph15/article/details/80880992

1. 简介

归并排序的算法是将多个有序数据表合并成一个有序数据表。如果参与合并的只有两个有序表，则成为二路合并。对于一个原始的待排序数列，往往可以通过分割的方法来归结为多路合并排序。

2. 归并排序思路

将长度为n的待排序数组看做是由n个有序长度为1的数组组成
将其两两合并，得到长度为2的有序数组
然后再对这些子表进行合并，得到长度为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;
}

归并排序的递归实现：

// 归并排序 O(nlogn)
    private void mergeSort(int[] numbers, int from, int to) {
        if (from >= to) {
            return;
        }
        int mid = (to + from) / 2;
        mergeSort(numbers, from, mid);
        mergeSort(numbers, mid + 1, to);
        merge(numbers, from, mid, to);
    }

    private void merge(int[] array, int from, int mid, int to) {
        int[] tmp = new int[to - from + 1];
        int i = from, j = mid + 1, k = 0;
        while (i <= mid && j <= to) {
            if (array[i] <= array[j]) {
                tmp[k++] = array[i++];
            } else {
                tmp[k++] = array[j++];
            }
        }
        while (i <= mid) {
            tmp[k++] = array[i++];
        }
        while (j <= to) {
            tmp[k++] = array[j++];
        }
        //把tmp中的数据复制到array中
        System.arraycopy(tmp, 0, array, from, to - from + 1);
    }

归并排序的非递归实现（迭代）：

  // 归并排序，非递归实现(迭代)
    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)。
归并排序是一种稳定的排序方法。

4. 举例分析

以数组A{5,2,4,7,1,3,2,6}中的8个数为例：

mergeSort(A,0,7)----A{5,2,4,7,1,3,2,6}

mergeSort(A,0,3)----A{5,2,4,7,1,3,2,6}

mergeSort(A,0,1)----A{5,2,4,7,1,3,2,6}
mergeSort(A,0,0)----A{5,2,4,7,1,3,2,6}
mergeSort(A,1,1)----A{5,2,4,7,1,3,2,6}
merge(A,0,1)数组A中0_0和11都有序，所以归并，但操作的还是数组A，只是元素范围是0~1.归并结果A{2,5,4,7,1,3,2,6}

mergeSort(A,2,3)----A{5,2,4,7,1,3,2,6}
mergeSort(A,2,2)—A{5,2,4,7,1,3,2,6}
mergeSort(A,3,3)—A{5,2,4,7,1,3,2,6}
merge(A,2,3)数组A中2_2和33都有序，所以归并，但操作的还是数组A，只是元素范围是2~3.归并结果A{2,5,4,7,1,3,2,6}

merge(A,0,3)数组A中0_1和23都有序，所以归并，归并结果A{2,4,5,7,1,3,2,6}

mergeSort (A,4,7)----A{2,5,4,7,1,3,2,6}同理，结果为A{2,5,4,7,1,2,3,6}

merge(A,0,7)数组A中0_3和47都有序，所归并，归并结果为A{1,2,2,3,4,5,6,7}