归并排序（借助额外空间）

public class Merge {
    
    @SuppressWarnings("rawtypes")
    private static Comparable[] aux;

    public static <T> void sort(Comparable<T> [] a) {
        aux = new Comparable[a.length];
        sort(a, 0, a.length - 1);
    }

    private static <T> void sort(Comparable<T> [] a, int lo, int hi) {
        if (hi <= lo) {
            return;
        }
        int mid = lo + (hi -lo) / 2;
        sort(a, lo, mid); // 将左半边排序
        sort(a, mid + 1, hi); // 将右半边排序
        merge(a, lo, mid, hi); // 归并结果
    }

    @SuppressWarnings("unchecked")
    private static <T> void merge(Comparable<T>[] a, int lo, int mid, int hi) {
        // i初始化为最左边的元素
        // j初始化为最右边的元素
        int i = lo, j = mid + 1;

        for (int k = lo; k <= hi; k ++) {
            aux[k] = a[k];
        }
        
        // k和i, j同时移动
        for (int k = lo; k <= hi; k ++) {
            if (i > mid) { // 左边用完
                a[k] = aux[j ++]; // 取右边的元素
            } else if (j > hi) { // 右边用完
                a[k] = aux[i ++]; // 去左边的元素
            } else if (aux[j].compareTo(aux[i]) < 0) { // 右边比左边小
                a[k] = aux[j ++];   // 取右边的
            } else { // 左边比右边小
                a[k] = aux[i ++]; // 取左边的
            }
        }
    }
}

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