归并排序及其优化

基本概念

归并排序(英语:Merge sort,或mergesort),是创建在归并操作上的一种有效的排序算法,效率为 O(n\log n)}(大O符号)。1945年由约翰·冯·诺伊曼首次提出。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用,且各层分治递归可以同时进行。

算法步骤

递归法(Top-down)

  1. 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列
  2. 设定两个指针,最初位置分别为两个已经排序序列的起始位置
  3. 比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置
  4. 重复步骤3直到某一指针到达序列尾
  5. 将另一序列剩下的所有元素直接复制到合并序列尾

迭代法(Bottom-up)

  1. 原理如下(假设序列共有 n个元素):
  2. 将序列每相邻两个数字进行归并操作,形成 $ceil(n/2)$个序列,排序后每个序列包含两/一个元素
  3. 若此时序列数不是1个则将上述序列再次归并,形成 $ceil(n/4)$个序列,每个序列包含四/三个元素
  4. 重复步骤2,直到所有元素排序完毕,即序列数为1

二者比较
测试来看 迭代法比递归法要快一点,原因在于递归多了入栈和出栈的操作,优化后二者差距缩小,主要在于递归的merge操作是更高的层次上的,相比而言迭代的merge优化操作没有在递归中的起到的作用大。但是即便如此,迭代的算法依旧快那么一点。

图示

对一个随机点的链表进行排序

复杂度分析

数据结构 数组
最坏时间复杂度 O(n\log n)
最优时间复杂度 O(n\log n)
平均时间复杂度 O(n\log n)
空间复杂度 O(n)

代码实现

递归版

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
80
package SortingAdvance.MergeSort;

import java.util.Arrays;

/**
* @ Description: 归并排序 普通递归版 时间复杂度O(nlogn)
* @ Date: Created in 11:42 2018/7/29
* @ Author: Anthony_Duan
*/
public class MergeSortRecursion {

//不允许实例
private MergeSortRecursion(){}

/**
* 将arr[l...mid]和arr[mid+1...r]两部分进行归并
*/
private static void merge(Comparable[] arr, int l, int mid, int r) {

//拷贝数组,[l,r+1)
Comparable[] aux = Arrays.copyOfRange(arr, l, r + 1);

// i是左半部分的索引,j是右半部分的索引,j的歧视索引为mid+1
int i = l, j = mid + 1;
//k是比较后得到的较小的元素将要放入原数组的索引 注意k是索引原数组的,i,j是索引拷贝后数组的
for (int k = l; k <=r ; k++) {
//如果左半部分的已经全部放到原数组了,将右半部分数组全部依次放入原数组
if (i > mid) {
arr[k] = aux[j-l];
j++;
}
//如果右半部分的已经全部放到原数组了,将左半部分数组全部依次放入原数组
else if (j > r) {
arr[k] = aux[i-l];
i++;
}
//如果左半部分取出的元素比较小,那么将左半部分索引取出的元素放入原数组 然后左半部分索引加一
else if (aux[i - l].compareTo(aux[j - l]) < 0) {
arr[k] = aux[i-l];
i++;
}
//右半部分取出的元素比较小,那么将右半部分索引取出的元素放入元素放入数组,然后右半部分索引加一
else {
arr[k] = aux[j-l];
j++;
}
}
}


// 递归使用归并排序,对arr[l...r]的范围进行排序
private static void sort(Comparable[] arr, int l, int r) {
if (l >= r) {
return;
}

int mid = l + (r - l) / 2;
sort(arr, l, mid);
sort(arr, mid + 1, r);
merge(arr, l, mid, r);
}

public static void sort(Comparable[] arr) {
int n = arr.length;
sort(arr,0,n-1);
}
// 测试MergeSort
public static void main(String[] args) {

// Merge Sort是O(nlogn)复杂度的算法
// 可以在1秒之内轻松处理100万数量级的数据
// 注意:不要轻易尝试使用SelectionSort, InsertionSort或者BubbleSort处理100万级的数据
// 否则,你就见识了O(n^2)的算法和O(nlogn)算法的本质差异:)
int N = 1000000;
Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
SortTestHelper.testSort("SortingAdvance.MergeSortRecursion.MergeSortRecursion", arr);

return;
}
}

迭代版

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
package SortingAdvance.MergeSort;

import java.util.Arrays;

/**
* @ Description: 归并排序 普通迭代版 时间复杂度O(nlogn)
* @ Date: Created in 12:08 2018/7/29
* @ Author: Anthony_Duan
*/
public class MergeSortIteration {

private MergeSortIteration(){}

private static void merge(Comparable[] arr, int l, int mid, int r) {
Comparable[] aux = Arrays.copyOfRange(arr, l, r + 1);

int i = l, j = mid + 1;
for (int k = l; k <=r ; k++) {
if (i > mid) {
arr[k] = aux[j-l];
j++;
} else if (j > r) {
arr[k] = aux[i - l];
i++;
} else if (aux[i-l].compareTo(aux[j-l]) < 0) {
arr[k] = aux[i - l];
i++;
}else {
arr[k] = aux[j - l];
j++;
}
}
}

public static void sort(Comparable[] arr) {
int n = arr.length;

/**
* 迭代的方式是指底而上,递归是自顶向下
* sz 是每次左右部分中元素的个数
* 外层循环控制分组
* 内层循环控制归并
*/
for (int sz = 1; sz < n; sz *= 2) {
for (int i = 0; i < n - sz; i += sz + sz ) {
merge(arr,i,i+sz-1,Math.min(i+sz+sz-1,n-1));
}
}
}

// 测试 MergeSort BU
public static void main(String[] args) {

// MergeSortIteration 也是一个O(nlogn)复杂度的算法,虽然只使用两重for循环
// 所以,MergeSortIteration也可以在1秒之内轻松处理100万数量级的数据
// 注意:不要轻易根据循环层数来判断算法的复杂度,MergeSortIteration就是一个反例
int N = 1000000;
Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
SortTestHelper.testSort("SortingAdvance.MergeSort.MergeSortIteration", arr);

return;
}

}

优化策略

策略1:对于arr[mid] <= arr[mid+1]的情况,不进行merge
策略2:对于小数组, 使用插入排序优化

递归优化版

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
package SortingAdvance.MergeSort;

import java.util.Arrays;

/**
* @ Description: 归并排序递归优化版 时间复杂度 O(nlogn)
* @ Date: Created in 12:49 2018/7/29
* @ Author: Anthony_Duan
*/
public class MergeSortRecursionAdvance {


// 我们的算法类不允许产生任何实例
private MergeSortRecursionAdvance(){}

// 将arr[l...mid]和arr[mid+1...r]两部分进行归并
private static void merge(Comparable[] arr, int l, int mid, int r) {

Comparable[] aux = Arrays.copyOfRange(arr, l, r+1);

// 初始化,i指向左半部分的起始索引位置l;j指向右半部分起始索引位置mid+1
int i = l, j = mid+1;
for( int k = l ; k <= r; k ++ ){

if( i > mid ){ // 如果左半部分元素已经全部处理完毕
arr[k] = aux[j-l]; j ++;
}
else if( j > r ){ // 如果右半部分元素已经全部处理完毕
arr[k] = aux[i-l]; i ++;
}
else if( aux[i-l].compareTo(aux[j-l]) < 0 ){ // 左半部分所指元素 < 右半部分所指元素
arr[k] = aux[i-l]; i ++;
}
else{ // 左半部分所指元素 >= 右半部分所指元素
arr[k] = aux[j-l]; j ++;
}
}
}


private static void sort(Comparable[] arr, int l, int r) {

//优化2: 对于小规模数组,说那个插入排序
if (r -l <=15) {
InsertionSortAdvance.sort(arr, l, r);
return;
}

int mid = (l + r) / 2;
sort(arr, l, mid);
sort(arr, mid + 1, r);


//优化1:对于arr[mid]<= arr[mid+1]的情况,不进行merge
// 对于近乎有序的数组非常有效,但是对于一般情况,有一定的性能损失
if (arr[mid].compareTo(arr[mid + 1]) > 0) {
merge(arr, l, mid, r);
}
}

public static void sort(Comparable[] arr) {
int n = arr.length;
sort(arr, 0, n - 1);
}


public static void main(String[] args) {
int N = 1000000;
Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
SortTestHelper.testSort("SortingAdvance.MergeSort.MergeSortRecursionAdvance", arr);

return;
}
}

迭代优化版

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
package SortingAdvance.MergeSort;


import SortingBasic.InsertionSort.InsertionSort;

import java.util.Arrays;

/**
* @ Description: 归并排序迭代优化版 时间复杂度O(nlogn)
* @ Date: Created in 13:04 2018/7/29
* @ Author: Anthony_Duan
*/
public class MergeSortIterationAdvance {

// 我们的算法类不允许产生任何实例
private MergeSortIterationAdvance(){}

// 将arr[l...mid]和arr[mid+1...r]两部分进行归并
private static void merge(Comparable[] arr, int l, int mid, int r) {

Comparable[] aux = Arrays.copyOfRange(arr, l, r+1);

// 初始化,i指向左半部分的起始索引位置l;j指向右半部分起始索引位置mid+1
int i = l, j = mid+1;
for( int k = l ; k <= r; k ++ ){

if( i > mid ){ // 如果左半部分元素已经全部处理完毕
arr[k] = aux[j-l]; j ++;
}
else if( j > r ){ // 如果右半部分元素已经全部处理完毕
arr[k] = aux[i-l]; i ++;
}
else if( aux[i-l].compareTo(aux[j-l]) < 0 ){ // 左半部分所指元素 < 右半部分所指元素
arr[k] = aux[i-l]; i ++;
}
else{ // 左半部分所指元素 >= 右半部分所指元素
arr[k] = aux[j-l]; j ++;
}
}
}

public static void sort(Comparable[] arr){

int n = arr.length;

// 对于小数组, 使用插入排序优化
for( int i = 0 ; i < n ; i += 16 ) {
InsertionSortAdvance.sort(arr, i, Math.min(i+15, n-1) );
}

for( int sz = 16; sz < n ; sz += sz ) {
for( int i = 0 ; i < n - sz ; i += sz+sz )
// 对于arr[mid] <= arr[mid+1]的情况,不进行merge
{
if( arr[i+sz-1].compareTo(arr[i+sz]) > 0 ) {
merge(arr, i, i+sz-1, Math.min(i+sz+sz-1,n-1) );
}
}
}

}

public static void main(String[] args) {

int N = 1000000;
Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
SortTestHelper.testSort("SortingAdvance.MergeSort.MergeSortIterationAdvance", arr);

return;
}


}
-------------End Of This ArticleThank You For Reading-------------