快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。
一趟快速排序的算法是：
1）设置两个变量I、J，排序开始的时候：I=0，J=N-1；
2）以第一个数组元素作为关键数据，赋值给
key
，即
key
=A[0]；
3）从J开始向前搜索，即由后开始向前搜索（J=J-1即J--），找到第一个小于
key
的值A[j]，A[j]与A[i]交换；
4）从I开始向后搜索，即由前开始向后搜索（I=I+1即I++），找到第一个大于
key
的A[i]，A[i]与A[j]交换；
5）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。找到并交换的时候i， j指针位置不变。另外当i=j这过程一定正好是i+或j-完成的最后令循环结束。）
示例
：待排序的数组A的值分别是：（初始关键数据：
key
=49） 注意关键
key
永远不变，永远是和
key
进行比较，无论在什么位置，最后的目的就是把
key
放在中间，小的放前面大的放后面。
| A[0] |
A[1] |
A[2] |
A[3] |
A[4] |
A[5] |
A[6] |
| 49 |
38 |
65 |
97 |
76 |
13 |
27 |
进行第一次交换后：27 38 65 97 76 13 49
( 按照算法的第三步从后面开始找）
进行第二次交换后：27 38 49 97 76 13 65
( 按照算法的第四步从前面开始找>
key
的值，65>49,两者交换，此时：I=3 )
进行第三次交换后：27 38 13 97 76 49 65
( 按照算法的第五步将又一次执行算法的第三步从后开始找
进行第四次交换后：27 38 13 49 76 97 65
( 按照算法的第四步从前面开始找大于
key
的值，97>49，两者交换，此时：I=4,J=6 )
此时再执行第三步的时候就发现I=J=5，从而结束一趟快速排序，那么经过一趟快速排序之后的结果是：27 38 13 49 76 97 65，即所有大于
key
49的数全部在49的后面，所有小于
key
（49）的数全部在
key
（49）的前面。
java实现第一趟排序
public class QuickSort {
public static void main(String[] args)
{
int [] arry={49,38, 65, 97, 76, 13, 27 };
//程序还有问题.比如当数据为49,38, 65, 97, 76, 13, 27,12,11 的时候,第一次就把最小一位放到第一位,,而出现问题
QuickSort.method2(arry);
Arrays.sort(arry, 0, arry.length);
for (int i = 0; i < arry.length; i++) {
System.out.println("结果:"+arry[i]);
}
}
/**
* 快速排序
* @param arry
*/
public static void method2(int [] array){
//1）设置两个变量I、J，排序开始的时候：I=0，J=N-1；
int i=0;
int j=array.length-1;//获取数组最后一位
//2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]；
int k=array[0];//获取数组第一位
int f=0;
boolean check=false;
int x=0;
while(i != j){
//3）从J开始向前搜索，即由后开始向前搜索（J=J-1），找到第一个小于key的值A[J]，A[j]与A[i]交换；
while(array[j] > k){
j--;
}
int temp = k;
k = array[j];
array[j] = temp;
//[49, 38, 65, 97, 76, 13, 27] //[27, 38, 65, 97, 76, 13, 49]//[27, 38, 49, 97, 76, 13, 65]
//[27, 38, 49, 97, 76, 49, 65] //[27, 38, 13, 97, 76, 49, 65]//[27, 38, 13, 49, 76, 97, 65]
//[27, 38, 13, 49, 76, 97, 65]
//4）从I开始向后搜索，即由前开始向后搜索（I=I+1），找到第一个大于key的A[I]，A[j]与A[i]交换；
while (array[i] < k){
i++;
}
int temp1= k;
k = array[i];
array[i] = temp1;
//[27, 38, 65, 97, 76, 13, 49] //[27, 38, 49, 97, 76, 13, 49] //[27, 38, 49, 97, 76, 13, 65]
//[27, 38, 13, 97, 76, 49, 65] //[27, 38, 13, 49, 76, 49, 65] //[27, 38, 13, 49, 76, 97, 65]
System.out.println(array[i]+" "+array[j]);
if(array[i]==array[j]){
x++;
if(x>(array.length/2+1)){
check=true;
}
}
if(i==j||check){
k=array[0];//获取数组第一位
if(i==j&&i==0){
k=array[1];
}
i=0;
j=array.length-1;//获取数组最后一位
check=false;
x=0;
if(f>(array.length/2+1)){
k=array[j];
}
if(f==array.length){
break;
}
f++;
}//[27, 38, 13, 49, 76, 97, 65] //[13, 27, 38, 49, 76, 97, 65]
}
}
}
运行结果：27 38 13 49 76 97 65快速排序就是递归调用此过程——在以49为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述数组A的快速排序的全过程如图6所示：初始状态 {49 38 65 97 76 13 27} 进行一次快速排序之后划分为 {27 38 13} 49 {76 97 65} 分别对前后两部分进行快速排序 {27 38 13} 经第三步和第四步交换后变成 {13 27 38} 完成排序。{76 97 65} 经第三步和第四步交换后变成 {65 76 97} 完成排序。图示
变种算法
快速排序（Quicksort）有几个值得一提的变种算法，这里进行一些简要介绍：
随机化快排：
快速排序的最坏情况基于每次划分对主元的选择。基本的快速排序选取第一个元素作为主元。这样在数组已经有序的情况下，每次划分将得到最坏的结果。一种比较常见的优化方法是随机化算法，即随机选取一个元素作为主元。这种情况下虽然最坏情况仍然是O(n^2），但最坏情况不再依赖于输入数据，而是由于随机函数取值不佳。实际上，随机化快速排序得到理论最坏情况的可能性仅为1/(2^n）。所以随机化快速排序可以对于绝大多数输入数据达到O(nlogn）的期望时间复杂度。一位前辈做出了一个精辟的总结：“随机化快速排序可以满足一个人一辈子的人品需求。”
随机化快速排序的唯一缺点在于，一旦输入数据中有很多的相同数据，随机化的效果将直接减弱。对于极限情况，即对于n个相同的数排序，随机化快速排序的时间复杂度将毫无疑问的降低到O(n^2）。解决方法是用一种方法进行扫描，使没有交换的情况下主元保留在原位置。
平衡快排（Balanced Quicksort）
：每次尽可能地选择一个能够代表中值的元素作为关键数据，然后遵循普通快排的原则进行比较、替换和递归。通常来说，选择这个数据的方法是取开头、结尾、中间3个数据，通过比较选出其中的中值。取这3个值的好处是在实际问题（例如信息学竞赛……）中，出现近似顺序数据或逆序数据的概率较大，此时中间数据必然成为中值，而也是事实上的近似中值。万一遇到正好中间大两边小（或反之）的数据，取的值都接近最值，那么由于至少能将两部分分开，实际效率也会有2倍左右的增加，而且利于将数据略微打乱，破坏退化的结构。
外部快排（External Quicksort）
：与普通快排不同的是，关键数据是一段buffer，首先将之前和之后的M/2个元素读入buffer并对该buffer中的这些元素进行排序，然后从被排序数组的开头（或者结尾）读入下一个元素，假如这个元素小于buffer中最小的元素，把它写到最开头的空位上；假如这个元素大于buffer中最大的元素，则写到最后的空位上；否则把buffer中最大或者最小的元素写入数组，并把这个元素放在buffer里。保持最大值低于这些关键数据，最小值高于这些关键数据，从而避免对已经有序的中间的数据进行重排。完成后，数组的中间空位必然空出，把这个buffer写入数组中间空位。然后递归地对外部更小的部分，循环地对其他部分进行排序。
三路基数快排（Three-way Radix Quicksort，也称作Multikey Quicksort、Multi-key Quicksort）
：结合了 基数排序
（radix sort，如一般的 字符串
比较排序就是基数排序）和快排的特点，是字符串排序中比较高效的算法。该算法被排序数组的元素具有一个特点，即multikey，如一个字符串，每个字母可以看作是一个key。算法每次在被排序数组中任意选择一个元素作为关键数据，首先仅考虑这个元素的第一个key（字母），然后把其他元素通过key的比较分成小于、等于、大于关键数据的三个部分。然后递归地基于这一个key位置对“小于”和“大于”部分进行排序，基于下一个key对“等于”部分进行排序。
Java
public class QuickSort {
public static void sort(Comparable[] data,int low,int high) {
// 枢纽元，一般以第一个元素为基准进行划分
int i = low;
int j = high;
if (low < high) {
// 从数组两端交替地向中间扫描
Comparable pivotKey = data[low];
// 进行扫描的指针i,j;i从左边开始，j从右边开始
while (i < j) {
while (i < j && data[j].compareTo(pivotKey) > 0) {
j--;
}// end while
if (i < j) {
// 比枢纽元素小的移动到左边
data[i] = data[j];
i++;
}// end if
while (i < j && data[i].compareTo(pivotKey) < 0) {
i++;
}// end while
if (i < j) {
// 比枢纽元素大的移动到右边
data[j] = data[i];
j--;
}// end if
}// end while
// 枢纽元素移动到正确位置
data[i] = pivotKey;
// 前半个子表递归排序
sort(data,low,i - 1);
// 后半个子表递归排序
sort(data,i + 1,high);
}// end if
}// end sort
public static void main(String[] args) {
// 在JDK1.5版本以上，基本数据类型可以自动装箱
// int,double等基本类型的包装类已实现了Comparable接口
Comparable[] c = { 4,9,23,1,45,27,5,2 };
sort(c,0,c.length - 1);
for (Comparable data : c) {
System.out.println(data);
}
}
}
C#
namespace temp
{
public class QuickSort
{
///
/// 排序
///
/// ；待排序数组
/// ；数组第一个元素索引Index
/// ；数组最后一个元素索引Index
private static void Sort(int[] numbers,int left,int right)
{
//左边索引小于右边，则还未排序完成
if (left < right)
{
//取中间的元素作为比较基准，小于他的往左边移，大于他的往右边移
int middle = numbers[(left + right) / 2];
int i = left - 1;
int j = right + 1;
while (true)
{
while (numbers[++i] < middle && i middle && j>0) ;
if (i >= j)
break;
Swap(numbers,i,j);
}
Sort(numbers,left,i - 1);
Sort(numbers,j + 1,right);
}
}
///
/// 交换元素值
///
/// ；数组
/// ；当前左边索引
/// ；当前右边索引
private static void Swap(int[] numbers,int i,int j)
{
int number = numbers[i];
numbers[i] = numbers[j];
numbers[j] = number;
}
public static void Main()
{
int[] max = { 6,5,2,9,7,4,0 };
Sort(max,0,max.Length-1);
StringBuilder temp =new StringBuilder();
for (int i = 0; i < max.Length; i++)
{
temp.Append(max[i].ToString()+",");
}
Console.WriteLine(temp.ToString().Substring(0,temp.Length-1));
Console.ReadLine();
}
}
}
javascript
var quickSort = function(array){
var arr = array;
var i = 0;
var j = arr.length-1;
var qSort = function(i,j){
if( i == j ){ return }// 当前组仅有一个元素则结束
var ai = arr[i];//取出的主元
var ii = i;//记录i的开始位置
var jj = j;//记录J的开始位置
while( i < j ){
// j <-------
if( arr[j] >= ai){
j--;
}else{
arr[i] = arr[j];
i++;
while( i < j){
if(arr[i] > ai){
arr[j] = arr[i];
break;
}else{
i++;
}
}
var k = arr[i];
}
}
if( ii == i){
qSort(++i,jj);
return ;
}
arr[i] = ai;
qSort(ii,i);//第一组排序
qSort(j,jj);//第二组排序
//---
}
qSort(i,j);
return array;
}
alert(quickSort([54,61,8,7,4,6,84,94,94,654,13,456,7981,7,465,79,16,49]));
此javascript脚本来自博客园idche
javascript，标准版本
var list=new Array(93,1,7,9,8,3,10,33,79,45,32,11,0,88,99,12,4,66,64,31,100,78);
document.write(sort(list).valueOf());
function sort(arr){
return quickSort(arr,0,arr.length-1);
// 快排函数
function quickSort(arr,l,r){
if(lmid);
if(i>=j)break;
var temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
quickSort(arr,l,i-1);
quickSort(arr,j+1,r);
}
return arr;
}
}
// PS：浏览到快排发现第一个 idche 版本过于复杂，故自己补了个 标准快排方法，希望能帮助同学们理解。
性能分析
下面我们就最好情况，最坏情况和平均情况对快速排序算法的性能作一点分析。
注意：
这里为方便起见，我们假设算法Quick_Sort的范围阈值为1（即一直将线性表分解到只剩一个元素），这对该 算法复杂性
的分析没有本质的影响。
我们先分析函数 partition
的性能，该函数对于确定的输入复杂性是确定的。观察该函数，我们发现，对于有n个元素的确定输入L[p..r]，该函数运行时间显然为θ（n）。
最坏情况
无论适用哪一种方法来选择pivot，由于我们不知道各个元素间的相对大小关系（若知道就已经排好序了），所以我们无法确定pivot的选择对划分造成的影响。因此对各种pivot选择法而言，最坏情况和最好情况都是相同的。
我们从直觉上可以判断出最坏情况发生在每次划分过程产生的两个区间分别包含n-1个元素和1个元素的时候（设输入的表有n个元素）。下面我们暂时认为该猜测正确，在后文我们再详细证明该猜测。
对于有n个元素的表L[p..r]，由于函数Partition的计算时间为θ（n），所以快速排序在序坏情况下的复杂性有递归式如下：
T(1)=θ（1),T(n)=T(n-1)+T(1)+θ（n) (1)
用迭代法可以解出上式的解为T(n)=θ（n2）。
这个最坏情况运行时间与 插入排序
是一样的。
下面我们来证明这种每次划分过程产生的两个区间分别包含n-1个元素和1个元素的情况就是最坏情况。
设T(n）是过程Quick_Sort作用于规模为n的输入上的最坏情况的时间，则
T(n)=max(T(q)+T(n-q))+θ（n)，其中1≤q≤n-1 (2)
我们假设对于任何k
将归纳假设代入（2），得到：
T(n）≤max(cq2+c(n-q)2)+θ（n)=c*max(q2+(n-q)2)+θ（n)
因为在[1,n-1]上q2+(n-q)2关于q递减，所以当q=1时q2+(n-q)2有最大值n2-2(n-1）。于是有：
T(n）≤cn2-2c(n-1)+θ（n）≤cn2
只要c足够大，上面的第二个小于等于号就可以成立。于是对于所有的n都有T(n）≤cn。
这样， 排序算法
的最坏情况运行时间为θ（n2），且最坏情况发生在每次划分过程产生的两个区间分别包含n-1个元素和1个元素的时候。
时间复杂度为o（n2）。
最好情况
如果每次划分过程产生的区间大小都为n/2，则快速排序法运行就快得多了。这时有：
T(n)=2T(n/2)+θ（n),T(1)=θ（1) (3)
解得：T(n)=θ（nlogn)
快速排序法最佳情况下执行过程的递归树如下图所示，图中lgn表示以2位底的对数，而本文中用logn表示以2位底的对数.
图2快速排序法最佳情况下执行过程的递归树
由于快速排序法也是基于比较的排序法，其运行时间为Ω（nlogn)，所以如果每次划分过程产生的区间大小都为n/2，则运行时间θ（nlogn）就是最好情况运行时间。
但是，是否一定要每次平均划分才能达到最好情况呢？要理解这一点就必须理解对称性是如何在描述运行时间的递归式中反映的。我们假设每次划分过程都产生9:1的划分，乍一看该划分很不对称。我们可以得到递归式：
T(n)=T(n/10)+T(9n/10)+θ（n),T(1)=θ（1) (4)
这个递归式对应的递归树如下图所示：
图3(4）式对应的递归树
请注意该树的每一层都有代价n，直到在深度log10n=θ（logn）处达到边界条件，以后各层代价至多为n。递归于深度log10/9n=θ（logn）处结束。这样，快速排序的总时间代价为T(n)=θ（nlogn），从渐进意义上看就和划分是在中间进行的一样。事实上，即使是99:1的划分时间代价也为θ（nlogn）。其原因在于，任何一种按常数比例进行划分所产生的递归树的深度都为θ（nlogn），其中每一层的代价为
O
(n），因而不管常数比例是什么，总的运行时间都为θ（nlogn），只不过其中隐含的常数因子有所不同。（关于 算法复杂性
的渐进阶，请参阅 算法的复杂性
)
平均情况
我们首先对平均情况下的性能作直觉上的分析。
要想对快速排序的平均情况有个较为清楚的概念，我们就要对遇到的各种输入作个假设。通常都假设输入数据的所有排列都是等可能的。后文中我们要讨论这个假设。
当我们对一个随机的输入数组应用快速排序时，要想在每一层上都有同样的划分是不太可能的。我们所能期望的是某些划分较对称，另一些则很不对称。事实上，我们可以证明，如果选择L[p..r]的第一个元素作为支点元素，Partition所产生的划分80%以上都比9:1更对称，而另20%则比9:1差，这里证明从略。
平均情况下，Partition产生的划分中既有“好的”，又有“差的”。这时，与Partition执行过程对应的递归树中，好、差划分是随机地分布在树的各层上的。为与我们的直觉相一致，假设好、差划分交替出现在树的各层上，且好的划分是最佳情况划分，而差的划分是最坏情况下的划分，图4(a）表示了递归树的连续两层上的划分情况。在根节点处，划分的代价为n，划分出来的两个子表的大小为n-1和1，即最坏情况。在根的下一层，大小为n-1的子表按最佳情况划分成大小各为（n-1)/2的两个子表。这儿我们假设含1个元素的子表的边界条件代价为1。
图4 快速排序的递归树划分中的两种情况
在一个差的划分后接一个好的划分后，产生出三个子表，大小各为1，（n-1)/2和（n-1)/2，代价共为2n-1=θ（n）。这与图4(b）中的情况差不多。该图中一层划分就产生出大小为（n-1)/2+1和（n-1)/2的两个子表，代价为n=θ（n）。这种划分差不多是完全对称的，比9:1的划分要好。从直觉上看，差的划分的代价θ（n）可被吸收到好的划分的代价θ（n）中去，结果是一个好的划分。这样，当好、差划分交替分布划分都是好的一样：仍是θ（nlogn），但θ记号中隐含的常数因子要略大一些。关于平均情况的严格分析将在后文给出。
在前文从直觉上探讨快速排序的平均性态过程中，我们已假定输入数据的所有排列都是等可能的。如果输入的分布满足这个假设时，快速排序是对足够大的输入的理想选择。但在实际应用中，这个假设就不会总是成立。
解决的方法是，利用随机化策略，能够克服分布的等可能性假设所带来的问题。
一种随机化策略是：与对输入的分布作“假设”不同的是对输入的分布作“规定”。具体地说，在排序输入的线性表前，对其元素加以随机排列，以强制的方法使每种排列满足等可能性。事实上，我们可以找到一个能在O(n）时间内对含n个元素的 数组
加以随机排列的算法。这种修改不改变算法的最坏情况运行时间，但它却使得运行时间能够独立于输入数据已排序的情况。
另一种随机化策略是：利用前文介绍的选择支点元素pivot的第四种方法，即随机地在L[p..r]中选择一个元素作为支点元素pivot。实际应用中通常采用这种方法。
快速排序的随机化版本有一个和其他随机化算法一样的有趣性质：没有一个特别的输入会导致最坏情况性态。这种算法的最坏情况性态是由随机数产生器决定的。你即使有意给出一个坏的输入也没用，因为随机化排列会使得输入数据的次序对算法不产生影响。只有在随机数产生器给出了一个很不巧的排列时，随机化算法的最坏情况性态才会出现。事实上可以证明几乎所有的排列都可使快速排序接近平均情况性态，只有非常少的几个排列才会导致算法的近最坏情况性态。
一般来说，当一个算法可按多条路子做下去，但又很难决定哪一条保证是好的选择时，随机化策略是很有用的。如果大部分选择都是好的，则随机地选一个就行了。通常，一个算法在其执行过程中要做很多选择。如果一个好的选择的获益大于坏的选择的代价，那么随机地做一个选择就能得到一个很有效的算法。我们在前文已经了解到，对快速排序来说，一组好坏相杂的划分仍能产生很好的运行时间。因此我们可以认为该算法的随机化版本也能具有较好的性态。
在前文我们从直觉上分析了快速排序在平均情况下的性能为θ（nlogn），我们将在下面定量地分析快速排序法在平均情况下的性能。为了满足输入的数据的所有排列都是等可能的这个假设，我们采用上面提到的随机选择pivot的方法，并且在Select_pivot函数中将选出的pivot与L[p]交换位置（这不是必需的，纯粹是为了下文分析的方便，这样L[p]就是支点元素pivot）。那种基于对输入数据加以随机排列的随机化算法的平均性态也很好，只是比这儿介绍的这个版本更难以分析。
我们先来看看Partition的执行过程。为简化分析，假设所有输入数据都是不同的。即使这个假设不满足，快速排序的平均情况运行时间仍为θ（nlogn），但这时的分析就要复杂一些。
由Partition返回的值q仅依赖于pivot在L[p..r]中的
秩（rank)
，某个数在一个集合中的秩是指该集合中小于或等于该数的元素的个数。如果设n为L[p..r]的元素个数，将L[p]与L[p..r]中的一个随机元素pivot交换就得rank(pivot)=i(i=1,2,..,n）的概率为l/n。
下一步来计算划分过程不同结果的可能性。如果rank(pivot)=1，即pivot是L[p..r]中最小的元素，则 Partition
的循环结束时指针i停在i=p处，指针j停在k=p处。当返回q时，划分结果的"低区"中就含有唯一的元素L[p]=pivot。这个事件发生的概率为1/n，因为rank(pivot)=i的概率为1/n。
如果rank(pivot）≥2，则至少有一个元素小于L[p]，故在外循环while循环的第一次执行中，指针i停于i=p处，指针j则在达到p之前就停住了。这时通过交换就可将L[p]置于划分结果的高区中。当Partition结束时，低区的rank(pivot)-1个元素中的每一个都严格小于pivot（因为假设输入的元素不重复）。这样，对每个i=1,2,..,n-1，当rank(pivot）≥2时，划分的低区中含i个元素的概率为 l/n。
把这两种情况综合起来，我们的结论为：划分的低区的大小为1的概率为2/n，低区大小为i的概率为1/n，i=2,3,..n-1。
现在让我们来对Quick_Sort的期望运行时间建立一个递归式。设T(n）表示排序含n个元素的表所需的平均时间，则：
（5）
其中T(1)=θ（1）。
q的分布基本上是均匀的，但是q=1的可能性是其他值的两倍。根据前面作的最坏情况的分析有：
T(1)=θ（1),T(n-1)=θ（n2），所以
这可被（5）式中的θ（n）所吸收，所以（5）式可简化为：
(6)
注意对k=1,2,..,n-1，和式中每一项T(k）为T(q）和T(n-q）的机会各有一次，把这两项迭起来有：
(7)
我们用 代入法
来解上述 递归
方程。归纳假设T(n）≤a*nlogn+b，其中a>0,b>0为待定常数。可以选择足够大的a,b使anlogn+b>T(1），对于n>1有：
（8）
下面我们来确定和式
（9）
的界。
因为和式中每一项至多是nlogn，则有界：
这是个比较紧的界，但是对于解递归式（8）来说还不够强。为解该递归式，我们希望有界：
为了得到这个界，可以将和式（9）分解为两部分，这时有：
等号右边的第一个和式中的logk可由log(n/2)=logn-1从上方限界。第二个和式中的logk可由logn从上方限界，这样，
对于n≥2成立。即：
(10)
将（10）代入（8）式得：
（11）
因为我们可以选择足够大的a使a*n/4能够决定θ（n)+b，所以快速 排序
的平均运行时间为θ（nlogn）。
