校招复习之快速排序

转载自：点击打开链接

1 快速排序的基本思想

快速排序（Quicksort）是对冒泡排序的一种改进。

它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

2 快速排序的三个步骤

1) 选择基准：在待排序列中，按照某种方式挑出一个元素，作为 “基准”（pivot）；
   2) 分割操作：以该基准在序列中的实际位置，把序列分成两个子序列。此时，在基准左边的元素都比该基准小，在基准右边的元素都比基准大；
   3) 递归地对两个序列进行快速排序，直到序列为空或者只有一个元素；

3  选择基准元的方式

对于分治算法，当每次划分时，算法若都能分成两个等长的子序列时，那么分治算法效率会达到最大。也就是说，基准的选择是很重要的。选择基准的方式决定了两个分割后两个子序列的长度，进而对整个算法的效率产生决定性影响。

最理想的方法是，选择的基准恰好能把待排序序列分成两个等长的子序列。

  方法1 固定基准元

如果输入序列是随机的，处理时间是可以接受的。如果数组已经有序时，此时的分割就是一个非常不好的分割。因为每次划分只能使待排序序列减一，此时为最坏情况，快速排序沦为冒泡排序，时间复杂度为Θ(n^2)。而且，输入的数据是有序或部分有序的情况是相当常见的。因此，使用第一个元素作为基准元是非常糟糕的，应该立即放弃这种想法。

方法2 随机基准元

这是一种相对安全的策略。由于基准元的位置是随机的，那么产生的分割也不会总是会出现劣质的分割。在整个数组数字全相等时，仍然是最坏情况，时间复杂度是O(n^2）。实际上，随机化快速排序得到理论最坏情况的可能性仅为1/(2^n）。所以随机化快速排序可以对于绝大多数输入数据达到O(nlogn）的期望时间复杂度。

方法3 三数取中

引入的原因：虽然随机选取基准时，减少出现不好分割的几率，但是还是最坏情况下还是O(n^2），要缓解这种情况，就引入了三数取中选取基准。

分析：最佳的划分是将待排序的序列分成等长的子序列，最佳的状态我们可以使用序列的中间的值，也就是第N/2个数。可是，这很难算出来，并且会明显减慢快速排序的速度。这样的中值的估计可以通过随机选取三个元素并用它们的中值作为基准元而得到。事实上，随机性并没有多大的帮助，因此一般的做法是使用左端、右端和中心位置上的三个元素的中值作为基准元。显然使用三数中值分割法消除了预排序输入的不好情形，并且减少快排大约5%的比较次数。

举例：待排序序列为：8 1 4 9 6 3 5 2 7 0

左边为：8，右边为0，中间为6

我们这里取三个数排序后，中间那个数作为枢轴，则枢轴为6。

下面是实现代码：

[cpp]  view plain  copy

 

1. //交换子表的记录，使枢轴记录到位，并返回枢轴所在的位置  
2. int Partition(int array[], int low, int high){  
3.   
4.     /*三数中值分割法*/  
5.     int m = low + (high - low) / 2;//数组中间元素的下标  
6.     if (array[low]>array[high])   //保证左端较小  
7.         swap(array, low, high);  
8.     if (array[m] > array[high])   //保证中间较小  
9.         swap(array, high, m);  
10.     if (array[m] > array[low])  
11.         swap(array, m, low);      //保证左端最小  
12.     //此时array[low]已经为整个序列左中右三个关键字的中间值  
13.     int pivotkey = array[low];  
14.   
15.     /*固定基准元 
16.      int pivotkey = array[low]; 
17.      */  
18.   
19.     /*随机基准元 
20.     int randomIndex = rand() % (high - low) + low;//取数组中随机下标 
21.     swap(array, randomIndex, low);                //与第一个数交换 
22.     int pivotkey = array[low]; 
23.     */  
24.   
25.     int i = low, j = high;  
26.     while(i!=j) //从表的两端交替向中间扫描,当没有相遇  
27.     {  
28.         while (array[j] >= pivotkey&&i<j){  
29.             j--;  
30.         }  
31.         while (array[i] <= pivotkey&&i<j){  
32.             i++;  
33.         }  
34.         if (i<j)  
35.         {  
36.             swap(array, i, j);  
37.         }     
38.     }  
39.     //最终将基准数归位  
40.     swap(array, low, i);  
41.     return i;              //返回枢轴所在的位置  
42. }  
43. void QSort(int array[], int low, int high){  
44.     int pivot;  
45.     if (low<high)  
46.     {  
47.         pivot = Partition(array, low, high);//算出枢轴值  
48.         QSort(array, low, pivot - 1);       //对低子表递归排序  
49.         QSort(array, pivot + 1, high);      //对高子表递归排序  
50.     }  
51. }  
52. //对array做快速排序  
53. void QuickSort(int array[], int n){  
54.     QSort(array, 0, n - 1);  
55. }  

快速排序的优化

对于很小的数组（N<=20）,快速排序不如插入排序好。不仅如此，因为快速排序是递归的，所以这样的情况经常发生。通常的解决办法是对于小的数组不递归的使用快速排序，而代之以诸如插入排序这样的对小数组有效的排序算法。使用这种策略实际上可以节省大约15%的（相对于自始至终使用快速排序时）的运行时间。一种好的截止范围是N=10，虽然在5到20之间任一截止范围都有可能产生类似的结果。

下面是代码：

[cpp]  view plain  copy

 

1. void QSort(int array[], int low, int high){  
2.     int pivot;  
3.     if (high-low+1>=10)  
4.     {     
5.         pivot = Partition(array, low, high);//算出枢轴值  
6.         QSort(array, low, pivot - 1);       //对低子表递归排序  
7.         QSort(array, pivot + 1, high);      //对高子表递归排序  
8.     }  
9.     else{  
10.         InsertSort(array+low, high-low+1); //插入排序  
11.     }         
12. }  

插入排序代码：

[cpp]  view plain  copy

 

1. /************************************************************************/  
2. /* 插入排序      时间复杂度：O(n^2)，空间复杂度：O(1)，稳定                                                       */  
3. /************************************************************************/  
4. void InsertSort(int array[], int n){  
5.     int j;  
6.     for (int i = 1; i < n;++i)  
7.     {  
8.         int key = array[i];  
9.         for (j = i; j>0 && array[j - 1] > key;j--)  
10.         {  
11.             array[j] = array[j - 1];  
12.         }  
13.         array[j] = key;  
14.     }  
15. }