算法导论笔记——快速排序

快速排序：
快速排序是最常用的算法之一，空间复杂度为O(logn)，时间复杂度为O(nlogn)，最坏情况下为O(n2)

快速排序使用分治策略，特点是每次找一个主元，根据主元与数组元素的大小，将数组分为三部分，如数组A[p...r]，主元q，分为A[p...q-1],q,A[q+1...r]三部分。寻找合适的主元是算法优化的关键，最初的快速排序将末位的元素作为主元，如果主元是数组中最大值或最小值，那相当于没有分割，排序性能将会大幅下降，退化为选择排序，时间复杂度为O(n2)，选择合适的主元，尽可能的避免最坏情况。

分割操作是快速排序中的关键部分，与归并排序不同，归并排序在分割时不进行排序处理，在合并时进行了排序处理，合并操作也是归并排序的关键部分。

快速排序示例图：

归并排序需要不断的递归运算，空间复杂度为O(n)

快速排序的划分：当输入数组为有序时，快速排序的情况是最坏的，为10，0划分，当为5，5划分时，情况是最好的，产生深度为O(logn)的递归数，需要注意的是，当你不平衡划分时，如9，1划分，快速排序的运行时间仍为O(nlogn)，事实上，任何一种常数比例的划分都会产生O(logn)的递归树，算法的运行时间总是O(logn)。

快速排序优化：
1、随机化算法，将每次选的的主元从数组元素中随机选出，使得最坏情况不再依赖于输入数据，而是依赖于主元取值，实际上，随机化快速排序得到理论最坏情况的可能性仅为1/(2^n)。所以随机化快速排序可以对于绝大多数输入数据达到O(nlogn)的期望时间复杂度。随机化快速排序的唯一缺点在于，一旦输入数据中有很多的相同数据，随机化的效果将直接减弱。对于极限情况，即对于n个相同的数排序，随机化快速排序的时间复杂度将毫无疑问的降低到O(n^2)。解决方法是用一种方法进行扫描，使没有交换的情况下主元保留在原位置。

由于快速排序算法是采用分治技术来进行实现的，这就使得它很容易能够在多台处理机上并行处理。

附：

优化1、当待排序序列的长度分割到一定大小后，使用插入排序。

原因：对于很小和部分有序的数组，快排不如插排好。当待排序序列的长度分割到一定大小后，继续分割的效率比插入排序要差，此时可以使用插排而不是快排

截止范围：待排序序列长度N = 10，虽然在5~20之间任一截止范围都有可能产生类似的结果，这种做法也避免了一些有害的退化情形。摘自《数据结构与算法分析》Mark Allen Weiness 著

[cpp]  view plain copy

1. if (high - low + 1 < 10)  
2. {  
3.     InsertSort(arr,low,high);  
4.     return;  
5. }//else时，正常执行快排  

测试数据：

测试数据分析：针对随机数组，使用三数取中选择枢轴+插排，效率还是可以提高一点，真是针对已排序的数组，是没有任何用处的。因为待排序序列是已经有序的，那么每次划分只能使待排序序列减一。此时，插排是发挥不了作用的。所以这里看不到时间的减少。另外，三数取中选择枢轴+插排还是不能处理重复数组

优化2、在一次分割结束后，可以把与Key相等的元素聚在一起，继续下次分割时，不用再对与key相等元素分割

举例：

待排序序列 1 4 6 7 6 6 7 6 8 6

三数取中选取枢轴：下标为4的数6

转换后，待分割序列：6 4 6 7 1 6 7 6 8 6

             枢轴key：6

本次划分后，未对与key元素相等处理的结果：1 4 6 6 7 6 7 6 8 6

下次的两个子序列为：1 4 6 和 7 6 7 6 8 6

本次划分后，对与key元素相等处理的结果：1 4 6 6 6 6 6 7 8 7

下次的两个子序列为：1 4 和 7 8 7

经过对比，我们可以看出，在一次划分后，把与key相等的元素聚在一起，能减少迭代次数，效率会提高不少

具体过程：在处理过程中，会有两个步骤

第一步，在划分过程中，把与key相等元素放入数组的两端

第二步，划分结束后，把与key相等的元素移到枢轴周围

举例：

待排序序列 1 4 6 7 6 6 7 6 8 6

三数取中选取枢轴：下标为4的数6

转换后，待分割序列：6 4 6 7 1 6 7 6 8 6

             枢轴key：6

第一步，在划分过程中，把与key相等元素放入数组的两端

结果为：6 4 1 6(枢轴) 7 8 7 6 6 6

此时，与6相等的元素全放入在两端了

第二步，划分结束后，把与key相等的元素移到枢轴周围

结果为：1 4 66(枢轴)  6 6 6 7 8 7

此时，与6相等的元素全移到枢轴周围了

之后，在1 4 和 7 8 7两个子序列进行快排

代码

[cpp]  view plain copy

1. void QSort(int arr[],int low,int high)  
2. {  
3.     int first = low;  
4.     int last = high;  
5.   
6.     int left = low;  
7.     int right = high;  
8.   
9.     int leftLen = 0;  
10.     int rightLen = 0;  
11.   
12.     if (high - low + 1 < 10)  
13.     {  
14.         InsertSort(arr,low,high);  
15.         return;  
16.     }  
17.       
18.     //一次分割  
19.     int key = SelectPivotMedianOfThree(arr,low,high);//使用三数取中法选择枢轴  
20.           
21.     while(low < high)  
22.     {  
23.         while(high > low && arr[high] >= key)  
24.         {  
25.             if (arr[high] == key)//处理相等元素  
26.             {  
27.                 swap(arr[right],arr[high]);  
28.                 right--;  
29.                 rightLen++;  
30.             }  
31.             high--;  
32.         }  
33.         arr[low] = arr[high];  
34.         while(high > low && arr[low] <= key)  
35.         {  
36.             if (arr[low] == key)  
37.             {  
38.                 swap(arr[left],arr[low]);  
39.                 left++;  
40.                 leftLen++;  
41.             }  
42.             low++;  
43.         }  
44.         arr[high] = arr[low];  
45.     }  
46.     arr[low] = key;  
47.   
48.     //一次快排结束  
49.     //把与枢轴key相同的元素移到枢轴最终位置周围  
50.     int i = low - 1;  
51.     int j = first;  
52.     while(j < left && arr[i] != key)  
53.     {  
54.         swap(arr[i],arr[j]);  
55.         i--;  
56.         j++;  
57.     }  
58.     i = low + 1;  
59.     j = last;  
60.     while(j > right && arr[i] != key)  
61.     {  
62.         swap(arr[i],arr[j]);  
63.         i++;  
64.         j--;  
65.     }  
66.     QSort(arr,first,low - 1 - leftLen);  
67.     QSort(arr,low + 1 + rightLen,last);  
68. }  

测试数据：

 测试数据分析：三数取中选择枢轴+插排+聚集相等元素的组合，效果竟然好的出奇。

原因：在数组中，如果有相等的元素，那么就可以减少不少冗余的划分。这点在重复数组中体现特别明显啊。

其实这里，插排的作用还是不怎么大的。

优化3：优化递归操作

快排函数在函数尾部有两次递归操作，我们可以对其使用尾递归优化

优点：如果待排序的序列划分极端不平衡，递归的深度将趋近于n，而栈的大小是很有限的，每次递归调用都会耗费一定的栈空间，函数的参数越多，每次递归耗费的空间也越多。优化后，可以缩减堆栈深度，由原来的O(n)缩减为O(logn)，将会提高性能。

代码：

[cpp]  view plain copy

1. void QSort(int arr[],int low,int high)  
2. {   
3.     int pivotPos = -1;  
4.     if (high - low + 1 < 10)  
5.     {  
6.         InsertSort(arr,low,high);  
7.         return;  
8.     }  
9.     while(low < high)  
10.     {  
11.         pivotPos = Partition(arr,low,high);  
12.         QSort(arr,low,pivot-1);  
13.         low = pivot + 1;  
14.     }  
15. }  

注意：在第一次递归后，low就没用了，此时第二次递归可以使用循环代替

测试数据：

测试数据分析：其实这种优化编译器会自己优化，相比不使用优化的方法，时间几乎没有减少

优化4：使用并行或多线程处理子序列（略）

所有的数据测试：

概括：这里效率最好的快排组合 是：三数取中+插排+聚集相等元素,它和STL中的Sort函数效率差不多

注意：由于测试数据不稳定，数据也仅仅反应大概的情况。如果时间上没有成倍的增加或减少，仅仅有小额变化的话，我们可以看成时间差不多。

至于相关的快速排序代码，网上有很多，这里就不再多写。