[数据结构与算法] 归并排序动画及 JAVA 代码实现

目录

1. 归并排序动画

2. 归并排序 Java 实现

3. 总结

时间复杂度

空间复杂度

排序稳定性

---

1. 归并排序动画

 

配合如下所示的每阶段排序后结果，更便于理解：

排序前 = [14, 2, 25, 17, 7, 38, 34, 5, 42, 15, 42]
nums = [2, 14, 25, 17, 7, 38, 34, 5, 42, 15, 42]
nums = [2, 14, 25, 17, 7, 38, 34, 5, 42, 15, 42]
nums = [2, 14, 25, 7, 17, 38, 34, 5, 42, 15, 42]
nums = [2, 14, 25, 7, 17, 38, 34, 5, 42, 15, 42]
nums = [2, 7, 14, 17, 25, 38, 34, 5, 42, 15, 42]
nums = [2, 7, 14, 17, 25, 38, 5, 34, 42, 15, 42]
nums = [2, 7, 14, 17, 25, 38, 5, 34, 42, 15, 42]
nums = [2, 7, 14, 17, 25, 38, 5, 34, 42, 15, 42]
nums = [2, 7, 14, 17, 25, 38, 5, 15, 34, 42, 42]
nums = [2, 5, 7, 14, 15, 17, 25, 34, 38, 42, 42]
排序后 = [2, 5, 7, 14, 15, 17, 25, 34, 38, 42, 42]

 

2. 归并排序 Java 实现

public static void main(String[] args) {
    int[] numbers = {14, 2, 25, 17, 7, 38, 34, 5, 42, 15, 42};

    MergeSort mergeSort = new MergeSort();

    System.out.println("排序前 = " + Arrays.toString(numbers));
    mergeSort.sort(numbers, 0, numbers.length - 1);
    System.out.println("排序后 = " + Arrays.toString(numbers));
}

/**
 * 对 [left,right] 范围进行排序
 * @param nums 数组
 * @param left 对 [left,right] 范围进行排序
 * @param right 对 [left,right] 范围进行排序
 */
public void sort(int[] nums, int left, int right) {

    if (left >= right) {
        return;
    }

    // 找到数组中间值
    int mid = left + (right - left) / 2;

    // 对 [left,mid] 和 [mid+1,right] 分别排序
    sort(nums, left, mid);
    sort(nums, mid + 1, right);

    // 对以排序的 [left,mid] 和 [mid+1,right] 进行合并
    merge(nums, left, mid + 1, right);
    System.out.println("nums = " + Arrays.toString(nums));
}

/**
 * 对两段 [left,right-1][right,length] 排序过的数组范围进行合并
 * @param nums 数组
 * @param left 左起点 [left,right-1]
   @param right 右起点 [right,length]
 * @param length 排序端长度
 */
public void merge(int[] nums, int left, int right, int length) {

    int mid = right - 1;

    int i = left;
    int j = right;
    int index = 0;

    int[] tmp = new int[length - left + 1];

    // 对 [i,mid] [j,length] 两段区域进行合并
    while (i <= mid && j <= length) {
        tmp[index++] = nums[i] <= nums[j] ? nums[i++] : nums[j++];
    }

    // [i,mid] 有剩余则加入数组尾部
    while (i <= mid) {
        tmp[index++] = nums[i++];
    }

    // [j,length] 有剩余则加入数组尾部
    while (j <= length) {
        tmp[index++] = nums[j++];
    }

    // 排序过的区域赋值给原数组
    for (int x = 0; x < tmp.length; x++) {
        nums[left + x] = tmp[x];
    }
}

3. 总结

时间复杂度

merge 函数时间复杂度 O(n)

复杂度

F(n) = 2 * F(n/2) + n

= 4 * F(n/4) + 2 * n

= 8 * F(n/8) + 3 * n

= 2^k * F(n/2^k) + k * n

当 F(n/2^k) = F(1) 时，也就是 n/2^k=1，我们得到 k=logn 。

 F(n) = n * (常数) + nlogn = n * (常数 + logn) ≈ n * logn

所以归并排序时间复杂度为 O(nlogn)

 

空间复杂度

归并排序的空间复杂度为 O(n)

 

排序稳定性

归并排序的稳定性取决于左右两段数组合并方式是否稳定，主要在于如下所示代码的判断

tmp[index++] = nums[i] <= nums[j] ? nums[i++] : nums[j++];

i 为左半部分起点，j 为右半部分起点

当 nums[i] = nums[j] 时，使用的为左半部分的值，所以排序为稳定的排序

如将上述 nums[i] <= nums[j] 换成 nums[i] < nums[j]，则排序为不稳定排序