三种快速排序以及快速排序的优化

转载 2015年07月08日 21:47:59

一、 快速排序的三种方法

1、快速排序的基本思想:

   快速排序使用分治的思想,通过一趟排序将待排序列分割成两部分,其中一部分记录的关键字均比另一部分记录的关键字小。之后分别对这两部分记录继续进行排序,以达到整个序列有序的目的。

2、快速排序的三个步骤:

(1)选择基准:在待排序列中,按照某种方式挑出一个元素,作为 "基准"(pivot)

(2)分割操作:以该基准在序列中的实际位置,把序列分成两个子序列。此时,在基准左边的元素都比该基准小,在基准右边的元素都比基准大

(3)递归地对两个序列进行快速排序,直到序列为空或者只有一个元素。

3、选择基准的方式

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

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

我们介绍三种选择基准的方法

方法(1):固定位置

思想:取序列的第一个或最后一个元素作为基准

基本的快速排序

  1. int SelectPivot(int arr[],int low,int high)  
  2. {  
  3.     return arr[low];//选择选取序列的第一个元素作为基准  
  4. }  

注意:基本的快速排序选取第一个或最后一个元素作为基准。但是,这是一直很不好的处理方法。

测试数据:

测试数据分析:如果输入序列是随机的,处理时间可以接受的。如果数组已经有序时,此时的分割就是一个非常不好的分割。因为每次划分只能使待排序序列减一,此时为最坏情况,快速排序沦为起泡排序,时间复杂度为Θ(n^2)。而且,输入的数据是有序或部分有序的情况是相当常见的。因此,使用第一个元素作为枢纽元是非常糟糕的,为了避免这个情况,就引入了下面两个获取基准的方法。

方法(2):随机选取基准

引入的原因:在待排序列是部分有序时,固定选取枢轴使快排效率底下,要缓解这种情况,就引入了随机选取枢轴

思想:取待排序列中任意一个元素作为基准

随机化算法

  1. /*随机选择枢轴的位置,区间在low和high之间*/  
  2. int SelectPivotRandom(int arr[],int low,int high)  
  3. {  
  4.     //产生枢轴的位置  
  5.     srand((unsigned)time(NULL));  
  6.     int pivotPos = rand()%(high - low) + low;  
  7.   
  8.     //把枢轴位置的元素和low位置元素互换,此时可以和普通的快排一样调用划分函数  
  9.     swap(arr[pivotPos],arr[low]);  
  10.     return arr[low];  
  11. }  

测试数据:

测试数据分析::这是一种相对安全的策略。由于枢轴的位置是随机的,那么产生的分割也不会总是会出现劣质的分割。在整个数组数字全相等时,仍然是最坏情况,时间复杂度是O(n^2)。实际上,随机化快速排序得到理论最坏情况的可能性仅为1/(2^n)。所以随机化快速排序可以对于绝大多数输入数据达到O(nlogn)的期望时间复杂度。一位前辈做出了一个精辟的总结:“随机化快速排序可以满足一个人一辈子的人品需求。”

方法(3):三数取中(median-of-three)

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

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

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

左边为:8,右边为0,中间为6.

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

注意:在选取中轴值时,可以从由左中右三个中选取扩大到五个元素中或者更多元素中选取,一般的,会有(2t+1)平均分区法(median-of-(2t+1),三平均分区法英文为median-of-three)。

具体思想:对待排序序列中low、mid、high三个位置上数据进行排序,取他们中间的那个数据作为枢轴,并用0下标元素存储枢轴。

即:采用三数取中,并用0下标元素存储枢轴。

  1. /*函数作用:取待排序序列中low、mid、high三个位置上数据,选取他们中间的那个数据作为枢轴*/  
  2. int SelectPivotMedianOfThree(int arr[],int low,int high)  
  3. {  
  4.     int mid = low + ((high - low) >> 1);//计算数组中间的元素的下标  
  5.   
  6.     //使用三数取中法选择枢轴  
  7.     if (arr[mid] > arr[high])//目标: arr[mid] <= arr[high]  
  8.     {  
  9.         swap(arr[mid],arr[high]);  
  10.     }  
  11.     if (arr[low] > arr[high])//目标: arr[low] <= arr[high]  
  12.     {  
  13.         swap(arr[low],arr[high]);  
  14.     }  
  15.     if (arr[mid] > arr[low]) //目标: arr[low] >= arr[mid]  
  16.     {  
  17.         swap(arr[mid],arr[low]);  
  18.     }  
  19.     //此时,arr[mid] <= arr[low] <= arr[high]  
  20.     return arr[low];  
  21.     //low的位置上保存这三个位置中间的值  
  22.     //分割时可以直接使用low位置的元素作为枢轴,而不用改变分割函数了  
  23. }  

测试数据:

测试数据分析:使用三数取中选择枢轴优势还是很明显的,但是还是处理不了重复数组

二、 快速排序的优化

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

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

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

  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 46 6 6 67 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两个子序列进行快排

代码

  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),将会提高性能。

代码:

  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函数效率差不多

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

参考文献

http://blog.sina.com.cn/s/blog_5a3744350100jnec.html

http://www.blogjava.net/killme2008/archive/2010/09/08/331404.html

http://www.cnblogs.com/cj723/archive/2011/04/27/2029993.html

http://blog.csdn.net/zuiaituantuan/article/details/5978009

相关文章推荐

快速排序的三种优化

快排算法的特点 实用性强。 很多实际的项目中使用了快排算法。但通常对算法都进行了调整(tuning),比如Java.util.Arrays类中的sort函数就使用了快排算法,但使用了双参考值(...

快速排序的三种实现及两种优化

一、快速排序的概念快速排序(Quicksort)是对冒泡排序的一种改进。快速排序由C. A. R. Hoare在1962年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分...

快速排序过程、partition应用、三种快排四种优化、Java实现

快速排序过程基本思想是分治的思想,说到分治,就应该想到和递归是分不开的。有些书上会使用关键字比较的表述,有些书上会直接使用记录比较表述,这两种说法是两个维度上的说法。这里序列元素的关键字属于记录的一部...

快速排序优化算法

  • 2015年11月24日 18:09
  • 3KB
  • 下载

快速排序的几种实现和优化代码

  • 2012年11月18日 03:57
  • 268KB
  • 下载

三种快速排序法

快速排序法的三种形式。

java快速排序、随机优化快排

  • 2016年05月12日 19:36
  • 3KB
  • 下载

快速排序的三种写法的效率比较

最近在复习排序和查找算法的时候,回想算法课程和数据结构课程上面各种写法,总结一下,顺便比较了一下它们之间的效率,   另《外数据结构》书本上阐述,如果比较的枢纽值不是第一个或者最后一个而是 a[l...

快速排序法 java实现 三种方法实现

快速排序法 (1)定义 快速排序使用分治的思想,通过一趟排序将待排序列分割成两部分,其中一部分记录的关键字均比另一部分记录的关键字小。之后分别对这两部分记录继续进行排序,以达到整个序列有序的目的。 (...

【快速排序】QuickSort(三种实现方法)c++描述

//以下算法详解,可以在《计算机算法设计与分析》(王晓东,三版)和《数据结构》(严蔚敏)中找到详解。 #include using namespace std; /* int Random(int...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:三种快速排序以及快速排序的优化
举报原因:
原因补充:

(最多只允许输入30个字)