java归并排序（Merge Sort）—— 详解 + 案例 +时间复杂度_java mergesort

前言

• 归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

---

排序原理

需求：
排序前：{8,4,5,7,1,3,6,2}
排序后：{1,2,3,4,5,6,7,8}

排序原理：

1. 尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止。
2. 将相邻的两个子组进行合并成一个有序的大组；
3. 不断的重复步骤2，直到最终只有一个组为止。

---

代码实现

代码

package study.sort;

public class Merge {
    //归并排序所需要的辅助数组
    private static Comparable[] assist;

    //对数组内的元素进行排序
    public static void sort(Comparable[] a){
        assist = new Comparable[a.length];
        int lo = 0;
        int hi = a.length - 1;
        sort(a,lo,hi);
    }

    //对数组a中从索引lo到索引hi之间的元素进行排序
    private static void sort(Comparable[] a,int lo,int hi){
        //只有一个数据，不用排序了
        if (hi <= lo){
            return;
        }

        int mid = lo + (hi - lo) / 2;

        //对lo到mid之间的元素进行排序
        sort(a,lo,mid);
        //对mid + 1到hi之间的元素进行排序
        sort(a,mid + 1,hi);
        //对lo到mid这组数据和mid到hi这组数据进行归并
        merge(a,lo,mid,hi);
    }

    //从索引lo到所以mid为一个子组，从索引mid+1到索引hi为另一个子组，
    // 把数组a中的这两个子组的数据合并成一个有序的大组（从索引lo到索引hi）
    private static void merge(Comparable[] a,int lo,int mid,int hi){
        //lo到mid这组数据和mid + 1到hi这组数据归并到辅助数组assist对应的索引处
        int i = lo;//定义一个指针，指向assist数组中开始填充数据的索引
        int p1 = lo;//定义一个指针，指向第一组数据的第一个元素
        int p2 = mid + 1;//定义一个指针，指向第二组数据的第一个元素

        //比较左边小组和右边小组中的元素大小，哪个小，就把哪个数据填充到assist数组中
        while (p1 <= mid && p2 <= hi){
            if (less(a[p1],a[p2])){
                assist[i++] = a[p1++];
            }else {
                assist[i++] = a[p2++];
            }
        }

        //上面的循环结束后，如果退出循环的条件是p1 > mid，则证明左边小组中的数据已经归并完毕，
        // 如果退 出循环的条件是p2 > =hi,则证明右边小组的数据已经填充完毕；
        // 所以需要把未填充完毕的数据继续填充到assist中,
        // 下面两个循环，只会执行其中的一个
        while (p1 <= mid){
            assist[i++] = a[p1++];
        }
        while (p2 <= hi){
            assist[i++] = a[p2++];
        }

        //那么现在，assist数组中，从lo到hi的元素是有序的，再把数据拷贝到a数组中对应的索引处
        for (int index = lo; index <= hi ; index++) {
            a[index] = assist[index];
        }
    }


    //判断v是否小于w
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    //交换a数组中，索引i和索引j处的值
    private static void exchange(Comparable[] a, int i, int j) {
        Comparable temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

package study.Test;

import study.sort.Merge;

import java.util.Arrays;

public class MergeTest {
    public static void main(String[] args) {
        Integer[] a =  {8, 4, 5, 7, 1, 3, 6, 2};
        System.out.println("排序前：" + Arrays.toString(a));
        Merge.sort(a);
        System.out.println("排序后：" + Arrays.toString(a));
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

效果图

---

时间复杂度

• 归并排序是分治思想的最典型的例子，上面的算法中，对a[lo…hi]进行排序，先将它分为a[lo…mid]和a[mid+1…hi]两部分，分别通过递归调用将他们单独排序，最后将有序的子数组归并为最终的排序结果。该递归的出口在于如果一个数组不能再被分为两个子数组，那么就会执行merge进行归并，在归并的时候判断元素的大小进行排序。
  
• 用树状图来描述归并，如果一个数组有8个元素，那么它将每次除以2找最小的子数组，共拆log8次，值为3，所以树共有3层,那么自顶向下第k层有2^ k个子数组，每个数组的长度为2^ (3-k)，归并最多需要2^(3-k)次比较。因此每层的比较次数为 2^k * 2^ (3-k)=2^3,那么3层总共为 3*2^3。
• 假设元素的个数为n，那么使用归并排序拆分的次数为log2(n),所以共log2(n)层，那么使用log2(n)替换上面32^3中 的3这个层数，最终得出的归并排序的时间复杂度为：log2(n) 2 ^(log2(n))=log2(n)*n,根据大O推导法则，忽略底数，最终归并排序的时间复杂度为O(nlogn);

归并排序的缺点：
需要申请额外的数组空间，导致空间复杂度提升，是典型的以空间换时间的操作。