常见排序算法的总结 - 复杂度、实现和稳定性

最基础的算法问题，温故知新。排序算法的几个主要指标是，时间复杂度（最好，最差和平均），空间复杂度（额外空间）和稳定性。本文主要描述八种常见算法：简单选择排序、冒泡排序、简单插入排序、希尔排序、归并排序、快速排序、堆排序和基数排序，关于它们的指标统计可以直接看最后。本文均为基本C++实现，不使用STL库。

值得一提的是排序算法的稳定性，之前关注较少。稳定性的意思是对于序列中键值（Key value）相同的元素，它们在排序前后的相对关系保持不变。对于int这样的基本数据类型，稳定性基本上是没有意义的，因为它的键值就是元素本身，两个元素的键值相同他们就可以被认为是相同的。但对于复杂的数据类型，数据的键值相同，数据不一定相同，比如一个Student类，包括Name和Score两个属性，以Score为键值排序，这时候键值相同元素间的相对关系就有意义了。

简单选择排序

应该是最自然的思路。选择排序的思想是，从全部序列中选取最小的，与第0个元素交换，然后从第1个元素往后找出最小的，与第一个元素交换，再从第2个元素往后选取最小的，与第2个元素交换，直到选取最后一个元素。

void selectionSort(int a[], int n) {for (int i = 0; i < n - 1; ++i) {int minIdx = i;for (int j = i + 1; j < n; ++j) {if (a[j] < a[minIdx]) {minIdx = j;}}int tmp = a[i];a[i] = a[minIdx];a[minIdx] = tmp;}
}

无论如何都要完整地执行内外两重循环，故最好、最差和平均时间复杂度都是O(n²)，不需要额外空间。选择排序是不稳定的。

冒泡排序

冒泡排序的思想是，从第0个元素到第n-1个元素遍历，若前面一个元素大于后面一个元素，则交换两个元素，这样可将整个序列中最大的元素冒泡到最后，然后再从第0个到第n-2遍历，如此往复，直到只剩一个元素。

void bubbleSort(int a[], int n) {for (int i = 0; i < n - 1; ++i) {for (int j = 0; j < n - i - 1; ++j) {if (a[j] > a[j + 1]) {int tmp = a[j];a[j] = a[j + 1];a[j + 1] = tmp;}}}
}

冒泡排序与简单选择排序类似，无论如何都要执行完两重循环，故最好、最坏和平均时间复杂度均为O(n²)，不需要额外空间。冒泡排序是稳定的。
冒泡排序的一个改进是，在内层循环之前设置一个标记变量，用于标记循环是否进行了交换，在内层循环结束时，若判断没有进行交换，则说明剩下的序列中，每个元素都小于等于后面一个元素，即已经有序，可终止循环。这样，冒泡排序的最好时间复杂度可以提升到O(n)。

简单插入排序（Insertion Sort）

思路是类似扑克牌的排序，每次从未排序序列的第一个元素，插入到已排序序列中的合适位置。假设初始的有序序列为第0个元素（本文描述的序号都从0开始），只有一个元素的序列肯定是有序的，然后从原先序列的第1个元素开始到第n-1个元素遍历，每次将当前元素插入到它之前序列中的合适位置。

void insertionSortBSearch(int a[], n) {for (int i = 1; i < n; ++i) { int j, val = a[i]; for (j = i - 1; j >= 0 && a[j] > val; --j) {a[j + 1] = a[j];}a[j + 1] = val;}
}

两重循环，最差和平均时间复杂度为O(n²)，最好情况是原序列已有序，则忽略内层循环，时间复杂度O(n)。插入排序是稳定的。
这里，内层循环我们用的是从后向前遍历，来找到合适的插入位置，而内层循环所遍历的，是已排序的数组，所以我们可以使用二分查找来寻找插入位置，从而使时间复杂度提高到O(n*log n)。代码如下。

// 二分查找改进的插入排序
void insertionSortBSearch(int a[], n) {for (int i = 1; i < n; ++i) { int j, val = a[i]; int begin = 0, end = i - 1;while (begin < end) {int mid = begin + (end - begin) / 2;if (a[mid] > val) {end = mid - 1;}else {begin = mid;}}for (j = i - 1; j >= begin; --j) {a[j + 1] = a[j];}a[begin] = val;}
}

希尔排序

希尔排序可以被认为是简单插入排序的一种改进。插入排序一个比较耗时的地方在于需要将元素反复后移，因为它是以1为增量进行比较的元素的后移可能会进行多次。一个长度为n的序列，以1为增量就是一个序列，以2为增量就形成两个序列，以i为增量就形成i个序列。希尔排序的思想是，先以一个较大的增量，将序列分成几个子序列，将这几个子序列分别排序后，合并，在缩小增量进行同样的操作，知道增量为1时，序列已经基本有序，这是进行简单插入排序的效率就会较高。希尔排序的维基词条上有一个比较好的解释例子如下：

// 原始序列
13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10
// 以5为增量划分，5列，每列即为一个子序列
13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10
// 对每一个子序列进行插入排序得到以下结果
10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45
// 恢复一行显示为
10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45
// 再以3为增量划分，3列，每列即为一个子序列
10 14 73
25 23 13
27 94 33
39 25 59
94 65 82
45
// 对每一个子序列进行插入排序得到如下结果
10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94
// 恢复一行为
10 14 13 25 23 33 27 25 59 39 65 73 45 94 82 94
// 然后再以1为增量进行插入排序，即简单插入排序
// 此时序列已经基本有序，分布均匀，需要反复后移的情况较少，效率较高

上面的例子中，我们依次选取了5、3和1为增量，实际中增量的选取并没有统一的规则，唯一的要求就是最后一次迭代的增量需为1。最初的增量选取规则为，从n/2折半递减直到1。还有一些关于希尔排序增量选取的研究，针对不同数据有不同的表现，在此不做展开。下面是增量从n/2折半递减到1的代码示例。

void shellSort(int a[], int n) {for (int step = n / 2; step > 0; step /= 2) {for (int i = step; i < n; ++i) {int j, val = a[i];for (j = n - step; j >= 0 && a[j] > val; j -= step) {a[j + step] = a[j];}a[j + 1] = val;}}
}

希尔排序在简单插入排序的基础上做了些改进，它的最好及最差时间复杂度和简单插入排序一样，分别是是O(n)和O(n²)，平均时间复杂度试增量选取规则而定，一般认为介于O(n)和O(n²)之间。它不需要额外空间。它是不稳定的。

归并排序

归并排序的思想是，利用二分的特性，将序列分成两个子序列进行排序，将排序后的两个子序列归并（合并），当序列的长度为2时，它的两个子序列长度为1，即视为有序，可直接合并，即达到归并排序的最小子状态。基于递归的实现如下：

void mergeSortRecursive(int a[], int b[], int start, int end) {if (start >= end) {return;}int mid = start + (end - start) / 2,start1 = start, end1 = mid,start2 = mid + 1, end2 = end;mergeSortRecursive(a, b, start1, end1);mergeSortRecursive(a, b, start2, end2);int i = 0;while (start1 <= end1 && start2 <= end2) {b[i++] = a[start1] < a[start2] ? a[start1++] : a[start2++];}while (start1 <= end1) {b[i++] = a[start1++];}while (start2 <= end2) {b[i++] = a[start2++];}for (i = start; i < end; ++i) {a[i] = b[i];}
}