左程云算法与数据结构基础班

排序优化

在C++的STL中为我们提供了很多排序函数如sort、stable_sort等等，平时我们也会直接使用这些现成的排序函数，为了让我们更加深层的了解底层的排序函数，现在我们从如何实现一个通用的、高性能的排序函数这个问题出发，进而更加全面的理解排序算法。

https://pan.baidu.com/s/1izhWFEqCNhi2LK3MApk6ng?pwd=n4xy

线性排序算法的时间复杂度比较低，适用场景比较特殊。所以如果要写一个通用的排序函数，不能选择线性排序算法。如果对于小规模数据进行排序，可以选择时间复杂度是O(n²)的算法；如果对大规模数据进行排序，时间复杂度是O(nlogn)的算法更加高效。所以，为了兼顾任意规模数据的排序，一般都会首选时间复杂度为O(nlogn)的排序算法来实现排序函数。

时间复杂度是O(nlogn)的排序算法不止一个，我们已经知道的有归并排序、快速排序，后面还会了解一种叫堆排序的排序算法。其中堆排序和快速排序都有比较多的应用，比如Java语言采用堆排序实现排序函数，而C++中采用了快排实现排序函数(后面我们会具体讲解)。

但是我们发现，貌似同样时间复杂度为O(nlogn)的归并排序却不经常被使用，这是因为归并排序并不是原地排序算法，它的空间复杂度为O(n)。所以说，当我们在为数据量比较大的文件排序时，除了数据本身占用的内存之外，我们还需要额外占用很大内存空间，所需的空间耗费就翻倍了。因此，考虑到空间效率的问题，归并排序才不被大家“宠信”。

我们之前在学习快速排序的时候了解到，快速排序并不是在任何情况下的时间复杂度都是O(nlogn)，在最坏的情况下它的时间复杂度甚至会恶化到O(n²)，下面我们来分析如何优化快速排序的问题。

如何优化快速排序？

什么情况下快速排序的时间复杂度会恶化到O(n²)，当要排序的数据本身就是有序的或者接近有序也就是说，有序度接近n(n-1)/2，并且我们每次的分区点都选取最后一个数据，那快速排序算法就会变得非常糟糕，这种O(n²)时间复杂度出现的主要原因还是因为我们分区点选的不够合理。

最理想的分区点：被分区点分开的两个分区中，数据的数量接近相等。

如果只是很粗暴的直接选取第一个或者最后一个数作为分区点，而不考虑数据的特点，那么肯定会出现像上述情况那样，因为数据本身的一些情况导致时间复杂度恶化。为了提高排序算法的性能，我们就是要尽可能的让每次分区都比较平均。下面给出两种比较常用、简单的分区算法：

三数取中法

我们从区间的首、尾、中间，分别取一个数，然后对比大小，取这3个数的中间值作为分区点。这样每间隔某个固定的长度，取数据出来比较，将中间值作为分区点的分区算法，肯定要比单纯的取某一个数据更好。但是，如果要排序的数据比较大，那“三数取中”可能就不够了，可能要“五数取中”或者“十数取中”。

随机法

随机法，顾名思义，就是每次从要排序的区间中，随机的选取一个元素作为分区点。这种方法并不能保证每次分区点都选的比较好，但是从概率的角度来看，也不大可能会出现每次分区点都选的很差的情况，所以平均下，这样选的分区点是比较好的。时间复杂度退化为最糟糕的O(n²)的情况，出现的可能性不大。

Glibc中qsort()排序函数的底层实现原理

为了让我们对如何实现一个排序函数有一个更直观的感受，这里以Glibc中的qsort()函数举例说明。虽然qsort()从名字上来看，很像是基于快速排序算法实现的，实际上它不仅仅使用了快排这一种算法。

如果去看源码，我们会发现，qsort()会优先使用归并排序来排序输入数据，因为归并排序的空间复杂度是O(n)，所以对于小数据量的排序，比如1KB、2KB等，归并排序额外需要1KB、2KB的内存空间，这个内存消耗是我们完全可以接收的，此时我们更加着重考虑的是速度，这也是用空间换时间思想的一种体现。

但是如果数据量太大，这个时候qsort()函数就会改为用快速排序算法来排序。其中快排算法的分区点选取方法接收“三数取中”法，所以我们发现，其实这些内部的函数也并不是很复杂。还有我们之前提及的递归太深导致堆栈溢出的问题，qsort()是通过自己实现一个堆上的栈，手动模拟递归来解决的。实际上，qsort()并不仅仅用到了归并排序和快速排序，它还用到了插入排序。在快速排序的过程中，当要排序的区间中，元素的个数小于等于4时，qsort()就退化成为插入排序，不再继续用递归来做快速排序，因为我们之前也讲过，在小规模数据面前，O(n²)时间复杂度的算法并不一定O(nlogn)的算法执行时间长。

这里着重分析一下这个说法：我们最开始将复杂度分析的时候说过，算法的性能可以通过时间复杂度来分析，但是，这种分析是比较偏理论的，如果我们深究的话，实际上时间复杂度并不等于代码实际的运行时间。时间复杂度代表的是一个增长的趋势，如果画成增长曲线图，我们会发现O(n²)比O(nlogn)要陡峭，也就是说增长趋势更加猛一些。但是我们在讲解大O复杂度表示法的时候，会省略低阶、系数和常数，也就是说，O(nlogn)在有省略低阶、系数、常数之前可能是O(knlogn+c)，而且k和c有可能还是一个比较大的数。假设k=1000，c=200，当我们对小规模数据(比如n=100)排序时，n²的值实际上比knlogn+c还要小：

knlogn + c = 1000 * 100 * log100 + 200 远大于10000
n * n = 100 * 100= 10000

所以说我们在理论层面分析算法的时间复杂度的时候会抛弃掉很多细节，但是在具体应用的过程中，就需要通过实践来选取更加合适算法来让我们的代码执行效率更高，因此对于小规模数据的排序，O(n²)的排序算法并不一定比O(nlogn)排序算法执行的时间长。对于小数据量的排序，我们选择比较简单、不需要递归的插入排序算法，通过这一改进策略实际上可以节省大约15%(相对于不用截止的做法而自始至终使用快速排序时)的运行时间。这种做法同时也避免了一些有害的退化情形，比如当只有一个或者两个元素的时候却取三个元素的中值这这样的情况。

这里给出实际的快速排序例程：

// 快速排序算法(驱动程序)
template <typename Comparable>
void quicksort(vector<Comparable> &a)
{quicksort(a, 0, a.size() - 1);
}// 执行三数中值分割的代码
template <typename Comparable>
const Comparable & median3(vector<Comparable> &a, int left, int right)
{int centor = (left + right) / 2;if (a[center] < a[left])std::swap(a[left], a[center]);if (a[right] < a[left])std::swap(a[left], a[right]);if (a[right] < a[centor])std::swap(a[centor], a[right]);// 将枢纽元置于right-1处std::swap(a[center], a[right - 1]);return a[right - 1];
}// 进行递归调用的内部快速排序方法
// 使用三数中值分割法，以及截止范围是10的截止技术
template <typename Comparable>
void quicksort(vector<Comparable> &a, int left, int right)
{if (left + 10 <= right){const Comparable &pivot = median3(a, left, right);// 开始分割int i = left, j = right - 1;for (; ; ){while (a[++i] < pivot) { }while (pivot < a[--j]) { }if (i < j)std::swap(a[i], a[j])elsebreak;}// 恢复枢纽元std::swap(a[i], a[right - 1]);// 将小于等于枢纽元的元素排序quicksort(a, left, i - 1);// 将大于等于枢纽元的元素排序quicksort(a, i + 1, right);}else// 对子数组进行一次插入排序insertionSort(a, left, right);
}

还记得之前在链表实现插入删除操作时，我们引入了哨兵的概念来简化我们的代码，提高执行效率。在qsort()插入排序的算法实现中，也利用了这种编程技巧。虽然哨兵可能只是少做一次判断，但是毕竟排序函数是非常常用、非常基础的函数，性能的优化要做到极致。