排序算法之归并排序(Java)

若人们不相信数学简单，只因他们未意识到生命之复杂。
—— 约翰·冯·诺伊曼

归并排序简介

归并排序(Merge Sort)，是创建在归并操作上的一种有效的排序算法。1945年由约翰·冯·诺伊曼首次提出。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用，且各层分治递归可以同时进行。

归并操作

归并操作(merge)，也叫归并算法，是指将两个已经排序的序列合并成一个序列的操作。

归并操作有两种方法可实现：迭代法和递归法。本篇主要介绍性能最优的迭代法。

归并排序思想

假设初始序列含有n个记录，则可以看成n个有序的子序列，每个子序列的长度为1,然后两两归并，得到⌈n/2⌉（⌈x⌉表示不小于x的最小整数）个长度为2或1的有序子序列；再两两归并，···，如此重复，直至得到一个长度为n的有序序列为止，这种排序方法称为2路归并排序。

归并排序过程

具体过程示意图：

算法实现

/**
* @description 对顺序表作归并非递归排序
* @author GongchuangSu
* @since 2016.03.27
* @version v1.0
*/
public class MergeSort {
public static void main(String[] args) {
// SR[0]和TR[0]用作哨兵或临时变量
int[] SR = {
1000, 50, 10, 90, 30, 70, 40, 80, 60, 20
};
int[] TR = new int[10];
TR[0] = 1000;
int k = 1;
while (k < SR.length) {
MergePass(SR, TR, k, SR.length - 1);
k = 2 * k;
MergePass(TR, SR, k, SR.length - 1);
k = 2 * k;
}
for (int i = 0; i < TR.length; i++) {
System.out.println( String.valueOf(SR[i]));
}
}

/**
* 功能：将SR[]中相邻长度为s的子序列两两归并到TR[]
*/
private static void MergePass(int SR[], int TR[], int s, int n) {
int i = 1;
int j;
while (i <= n - 2 * s + 1) {
Merge(SR, TR, i, i + s - 1, i + 2 * s - 1);
i = i + 2 * s;
}
if (i < n - s + 1) // 归并最后两个序列
Merge(SR, TR, i, i + s - 1, n);
else // 若最后只剩下单个子序列
for (j = i; j <= n; j++)
TR[j] = SR[j];
}

/**
* 功能：将有序的SR[i...m]和SR[m+1...n]归并为有序的TR[i...n]
*/
private static void Merge(int SR[], int TR[], int i, int m, int n) {
int j, k, l;
// 将SR中记录由小到大归并入TR
for (j = m + 1, k = i; i <= m && j <= n; k++) {
if (SR[i] < SR[j]) {
TR[k] = SR[i];
i = i + 1;
} else {
TR[k] = SR[j];
j = j + 1;
}
}
// 将剩余的SR[i...m]复制到TR
if (i <= m) {
for (l = 0; l <= m - i; l++)
TR[k + l] = SR[i + l];
}
// 将剩余的SR[j..n]复制到TR
if (j <= n) {
for (l = 0; l <= n - j; l++)
TR[k + l] = SR[j + l];
}
}
}

输出结果：

1000
10
20
30
40
50
60
70
80
90

算法分析

时间复杂度

对于递归法，总的时间复杂度为Θ(nlogn)，而且是其最好、最坏、平均的时间性能。

对于迭代法，其最优时间复杂度为Θ(n)。

空间复杂度

对于递归法，其空间复杂度为Θ(n+logn)。

对于迭代法，其空间复杂度为Θ(n)。

稳定性

归并排序是一种稳定的排序方法。