失眠网 > 选择排序插入排序冒泡排序希尔排序算法的总结 - 复杂度实现和稳定性

选择排序插入排序冒泡排序希尔排序算法的总结 - 复杂度实现和稳定性

时间：2024-02-19 19:56:20

原文地址：/p/916b15eae350

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

.08.29 16:20*

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

冒泡排序

冒泡排序的思想是，从第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(n2)，不需要额外空间。冒泡排序是稳定的。

冒泡排序的一个改进是，在内层循环之前设置一个标记变量，用于标记循环是否进行了交换，在内层循环结束时，若判断没有进行交换，则说明剩下的序列中，每个元素都小于等于后面一个元素，即已经有序，可终止循环。这样，冒泡排序的最好时间复杂度可以提升到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(n2)，最好情况是原序列已有序，则忽略内层循环，时间复杂度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 8225 59 94 65 2345 27 73 25 3910// 对每一个子序列进行插入排序得到以下结果10 14 73 25 2313 27 94 33 3925 59 94 65 8245// 恢复一行显示为10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45// 再以3为增量划分，3列，每列即为一个子序列10 14 7325 23 1327 94 3339 25 5994 65 8245// 对每一个子序列进行插入排序得到如下结果10 14 1325 23 3327 25 5939 65 7345 94 8294// 恢复一行为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(n2)，平均时间复杂度试增量选取规则而定，一般认为介于O(n)和O(n2)之间。它不需要额外空间。它是不稳定的。

归并排序

归并排序的思想是，利用二分的特性，将序列分成两个子序列进行排序，将排序后的两个子序列归并（合并），当序列的长度为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];}}

void mergeSort(int a[], int n) {

int *b = new int[n];

mergeSortRecursive(a, b, 0, n - 1);

delete[] b;

}

归并排序的最好，最坏和平均时间复杂度都是O(n*logn)。但需要O(n)的辅助空间。归并排序是稳定的。

快速排序

快速排序可能是最常被提到的排序算法了，快排的思想是，选取第一个数为基准，通过一次遍历将小于它的元素放到它的左侧，将大于它的元素放到它的右侧，然后对它的左右两个子序列分别递归地执行同样的操作。

void quickSortRecursive(int a[], int start, int end) {if (start >= end)return;int mid = a[start];int left = start + 1, right = end;while (left < right) {while (a[left] <= mid && left < right)++left;while (a[right] > mid && left < right)--right;swap(a[left], a[right]);}if (a[left] <= a[start])swap(a[left], a[start]);else--left;if (left)quickSortRecursive(a, start, left - 1);quickSortRecursive(a, left + 1, end);}

void quickSort(int a[], int n) {

quickSortRecursive(a, 0, n - 1);

}

快速排序利用分而治之的思想，它的最好和平均实际复杂度为O(nlogn)，但是，如果选取基准的规则正好与实际数值分布相反，例如我们选取第一个数为基准，而原始序列是倒序的，那么每一轮循环，快排都只能把基准放到最右侧，故快排的最差时间复杂度为O(n2)。快排算法本身没有用到额外的空间，可以说需要的空间为O(1)；对于递归实现，也可以说需要的空间是O(n)，因为在递归调用时有栈的开销，当然最坏情况是O(n)，平均情况是O(logn)。快速排序是不稳定的。

堆排序

堆排序利用的是二叉树的思想，所谓堆就是一个完全二叉树，完全二叉树的意思就是，除了叶子节点，其它所有节点都有两个子节点，这样子的话，完全二叉树就可以用一个一块连续的内存空间（数组）来存储，而不需要指针操作了。堆排序分两个流程，首先是构建大顶堆，然后是从大顶堆中获取按逆序提取元素。

首先是大顶堆，大顶堆即一个完全二叉树，的每一个节点都大于它的所有子节点。大顶堆可以按照从上到下从左到右的顺序，用数组来存储，第i个节点的父节点序号为(i-1)/2，左子节点序号为2i+1，右子节点序号为2(i+1)。构建大顶堆的过程即从后向前遍历所有非叶子节点，若它小于左右子节点，则与左右子节点中最大的交换，然后递归地对原最大节点做同样的操作。下面是一个较好的示意图来自bubkoo：

构建大顶堆示意图

构建完大顶堆后，我们需要按逆序提取元素，从而获得一个递增的序列。首先将根节点和最后一个节点交换，这样最大的元素就放到最后了，然后我们更新大顶堆，再次将新的大顶堆根节点和倒数第二个节点交换，如此循环直到只剩一个节点，此时整个序列有序。下面是一个较好的示意图来自bubkoo：

从大顶堆逆序提取元素使其有序示意图

void updateHeap(int a[], int i, int n) {int iMax = i,iLeft = 2 * i + 1,iRight = 2 * (i + 1);if (iLeft < n && a[iMax] < a[iLeft]) {iMax = iLeft;}if (iRight < n && a[iMax] < a[iRight]) {iMax = iRight;}if (iMax != i) {int tmp = a[iMax];a[iMax] = a[i];a[i] = tmp;updateHeap(a, iMax, n);}}

void heapSort(int a[], int n) {

for (int i = (n - 1) / 2; i >= 0; i–) {

updateHeap(a, i, n);

}

for (int i = n - 1; i > 0; --i) {

int tmp = a[i];

a[i] = a[0];

a[0] = tmp;

updateHeap(a, i, n);

}

堆排序的整个过程中充分利用的二分思想，它的最好、最坏和平均时间复杂度都是O(nlogn)。堆排序不需要额外的空间。堆排序的交换过程不连续，显然是不稳定的。

基数排序

基数排序是一种典型的空间换时间的排序方法。以正整数为例，将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位（个位）排序一直到最高位排序完成以后，数列就变成一个有序序列。

对正整数我们常以10为基数，每一位可以为0到9，对于其它数据类型如字符串，我们可以进一步拓展基数，基数越大越占空间，但时间更快，如果有一段足够长的内存空间，也就是说基数为无穷大，那就足够表示所有出现的数值，我们就可以通过一次遍历就实现排序，当然实现上这是不可能的（对已知输入范围的数据是可能的，而且非常有用的，可以用这种思想来模拟一个简单的hash函数）。

int maxBit(int a[], int n){int maxData = a[0];for (int i = 1; i < n; ++i){if (maxData < a[i]) {maxData = a[i];} }int d = 1;int p = 10;while (maxData >= p){maxData /= 10;++d;}return d;}void radixsort(int a[], int n){int d = maxBit(a, n);int *tmp = new int[n];int *count = new int[10];int i, j, k;int radix = 1;for (i = 1; i <= d; i++, radix *= 10){for (j = 0; j < 10; j++) {count[j] = 0;} for (j = 0; j < n; j++){k = (a[j] / radix) % 10;count[k]++;}for (j = 1; j < 10; j++) {count[j] = count[j - 1] + count[j];} for (j = n - 1; j >= 0; j--){k = (a[j] / radix) % 10;tmp[count[k] - 1] = a[j];count[k]--;}for (j = 0; j < n; j++) {a[j] = tmp[j];}}delete[]tmp;delete[]count;}

基数排序的最好，最好、最坏和平均时间复杂度都是O(n*k)，其中n是数据大小，k是所选基数。它需要O(n+k)的额外空间。它是稳定的。