四、快速排序（Quick Sort）
快速排序是一种使用很广泛的排序算法，属于交换排序类。
思路：
使用“分治”的递归算法进行排序
步骤：
1）基准情形：N=0或1，无需排序，返回
2）N>1，从数组S中任意取一个元素ν，称之为枢纽元（pivot）
3）分割：
将比ν大的元素全部放到v的右边，S1
将比v小的元素全部放到v的左边，S2
4）对左右两个区间递归地快速排序，直到序列中只有0或1个元素
quicksort(S1)
quicksort(S2)
注意：应避免创建新的数组，占据额外的内存空间
分割方法：
第 3）步分割的方法不是唯一的，因此成为了一种设计决策。
（1）常见的，将第一个元素作为枢纽元
如果输入是随机的，是可以的；
如果输入是预排序或反序的，则会产生一个劣质的分割，所有元素都在S1或S2中，且对所有递归情形都一样。
花费的时间是二次的，且枢纽元是无效的。
类似的，还有选取前2个互异的元素中的较大者作为枢纽元。
（2）随机选取基准数
安全，不会总发生劣质的分割。
对绝大多数输入数据达到O(NlogN)的期望时间复杂度。
（3）三数中值分割法（Median-of-Three）
最佳枢纽元：一个数组N个数的中值，即第N/2个最大的数。但很难算出，且明显减慢快排的速度
一般做法：使用左端、右端、中心位置上的三个元素的中值作为基准数。
消除了预排序输入的不好情形，且减少了大约14%的比较次数。避免“元素当初输入时不够随机”带来的恶化效应。
/** * 快速排序的驱动程序 */ void quicksort(vector<int> &a) { quicksort(a, 0, a.size() - 1); } void quicksort(vector<int> &a, int left, int right)
void quicksort(vector<int> &a, int left, int right) { if (left >= right) return; /* 找到枢纽元 */ int base = division(a, left, right); int pivot = a[base]; /* 开始分割 */ int i = left; int j = right; while (i < j) { /* 先从右向左找到小于枢纽元的数 */ while (a[j] >= pivot && i < j) j--; /* 再从左向右找到大于枢纽元的数 */ while (a[i] <= pivot && i < j) i++; /*如果两者没有交会，则交换两数在数组中的位置 */ if (i < j) std::swap(a[i], a[j]); } /* 将枢纽元归位 */ std::swap(a[base], a[i]); /* 递归地对左、右两半部分进行快速排序 */ quicksort(a, left, i - 1); quicksort(a, i + 1, right); }
/** * 使用第一个元素或[left,right]内的随机数作为枢纽元 */ int division(vector<int> &a, int left, int right) { /* 以下方案二选一 */ /* 随机选取[left,right]范围内的数作为枢纽元 */ int i = rand() % (right-left+1) + left; // [left,right]内的随机数 std::swap(a[left], a[i]); return left; /* 使用第一个数作为枢纽元 */ return left; }
- 使用三数中值分割法（Median-of-Three）
void quicksort(vector<int> &a, int left, int right) { if (left >= right) return; int pivot = division(a, left, right); int i = left; // 开始位置，警戒标志 int j = right - 1; while (i < j) { /* 从left+1和right-2开始 */ while (a[++i] < pivot){} while (pivot < a[--j]){} if (i < j) std::swap(a[i], a[j]); else break; } std::swap(a[right - 1], a[i]); quicksort(a, left, i - 1); quicksort(a, i + 1, right); }
int division(vector<int> &a, int left, int right) { int center = (left + right) / 2; if (a[center] < a[left]) std::swap(a[left], a[center]); if (a[left] > a[right]) std::swap(a[left], a[right]); if (a[center] > a[right]) std::swap(a[right], a[center]); std::swap(a[center], a[right - 1]); return a[right - 1]; }
分析：选取a[left]，a[center]，a[right]的中值作为基准值。
先对三者进行排序，a[left]< a[center]<a[right]，a[center]为三者的中值，作为枢纽元pivot，而a[left]， a[right]都处于分割阶段应该在的区间。
可以把pivot放到a[right-1]，并在分割阶段将i和j初始化为left和right-1。a[left]<pivot，所以a[left]作为j的警戒标记，不必担心j跑过端点；由于i会停在pivot元素处，所以将pivot存储在a[right-1]处为i提供了一个警戒标记，不必担心i跑过端点。
时间复杂度：
N=0或1，时间为常数，记为1。
N>1，用时为：T(N)=T(i)+T(N-i-1)+cN（分割花费的时间）
|
1）最坏情形： 枢纽元始终是最小元素，此时i=0，忽略无关紧要的T(0)=1 T(N)=T(N-1)+cN T(N-1)=T(N-2)+c(N-1) ...... T(2)=T(1)+c(2) 相加可得 T(N) =T(1)+c(2+3+4+...+N) =Θ (N2) |
1）最好情形： 枢纽元正好位于中间，为简化，假设两个子数组恰好是原数组的一半大小 T(N)=2T(N/2)+cN ——> T(N)/N=T(N/2)/(N/2)+c T(N/2)/(N/2)=T(N/4)/(N/4)+c ...... T(2)/2=T(1)/1+c 相加可得 T(N) =cNlogN+N =Θ (NlogN) |
3) 平均情形：
T(N)=O(NlogN)
适用情形：
对于很小的数组(N<=20)，快速排序不如插入排序好。通常的解决办法是，对于小的数组不递归地使用快速排序，而是使用插入排序这样的对小数组有效的排序算法。截止范围在N = 5~20之间都可以，相对只用快排的方式，实际上可以节省15%的运行时间。
if(left+10<=right) { // 使用快速排序 quicksort(a,left,right); } else { // 对小数组使用插入排序 insertionSort(a,left,right); }
STL的sort算法，数据量大时采用快排，分段递归排序，一旦分段后的数据量小于某个门槛，为避免快排的递归调用带来过大的额外负载，就改用插入排序。如果递归层次过深，还会改用堆排序。