快速排序

算法思想

实现

快速排序算法的优化
优化一优化枢轴的选取位置

优化二优化不必要的交换

优化三优化数据量较小时的排序

优化四优化递归操作

算法思想

通过一趟快速排序将待排序的记录分割成独立的两部分，其中一部分记录的关键字均比另一部分的记录的关键字小，则可分别对这两部分记录继续进行排序，达到整个记录有序。

实现快速排序算法的核心是partition函数，这个函数的主要目的先选取当中的一个关键字（称为枢轴），然后尽可能将他放在一个位置，使得它左边的值都比它小，右边的值比它大。

实现

快速排序算法实现

public class QuickSort3 {

public void quickSort(int[] a){
qSort(a,0,a.length - 1);
//打印输出
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}

private void qSort(int[] a, int low, int high) {
int pivot = 0;
if(low < high){
//将数组a一分为二
pivot = partition(a,low,high);
//对第一部分进行递归排序
qSort(a,low,pivot);
//对第二部分进行递归排序
qSort(a,pivot + 1,high);
}
}

private int partition(int[] a, int low, int high) {
//用第一个元素作为枢轴记录
int pivotkey = a[low];
while(low < high){
//将比枢轴记录小的交换到低端
while(low < high && a[high] >= pivotkey){
high--;
}
swap(a,low,high);
//将比枢轴记录大的交换到高端
while(low < high && a[low] <= pivotkey){
low++;
}
swap(a,low,high);
}
//返回枢轴所在的位置
return low;
}

private void swap(int[] a, int low, int high) {
int temp = a[low];
a[low] = a[high];
a[high] = temp;
}

public static void main(String[] args) {
new QuickSort3().quickSort(new int[]{50,10,90,30,70,40,80,60,20});
}
}

快速排序算法的最优时间复杂度是O(nlogn)，在如下的情况下是最优的：对于一组具有n个关键字的记录，partition函数每次都划分得很均匀，也就是每次调用partition函数之后，比枢轴小的关键字和比枢轴大的关键字的数量基本相等。这样下次调用partition函数的时候所用的时间是上次调用partition函数的两倍加上比较元素的时间，所以这是最优的情况。

在最坏的情况指的就是每次调用partition函数，只得到一个比上一次划分少一个记录的子序列（因为只要调用partition函数，必须至少会有一次关键字的交换）。由于只减少了一个关键字，所以后面还需要进行n-1次（总共有n个关键字）递归调用partition函数。所以到最后总共需要比较的次数是∑n−1i=1=n−1+n−2+…+1=n(n−1)2，所以最终的时间复杂度是O(n2)。

在平均的情况下，枢轴的关键字应该在k位置(1≤k≤n)。所以最优情况下的时间复杂度是O(nlogn)。

那么快速排序算法的空间复杂度又是如何呢？最优和平均情况下空间复杂度都是O(logn)，在最坏情况就是n−1次调用，所以空间复杂度是O(n)。

快速排序算法的优化

优化一：优化枢轴的选取位置

可以发现我们上面的算法中，枢轴的选取是在第一个位置的，这种选取枢轴位置的最大弊端就是很可能在调用partition函数的时候，只更换了两个元素的位置，而其他位置的元素并没有发生变化，这就是上面分析中提到的最坏的情况，发现导致这种情况的根源在于选取的枢轴的大小要么太大要么太小（因为太大或者太小，high或low的值只能减小一个位置或者增加一个位置），那么优化的思路就是让枢轴既不会太大又不会太小。所以可以采用三数取中法：这种方法就是取三个关键字先进行排序，将中间的数作为枢轴，一般是取左端、右端和中间的三个数。这样排序之后就能基本保证枢轴既不会太大又不会太小。所以我们只需要修改partition函数如下：

private int partition2(int[] a, int low, int high) {
//用第一个元素作为枢轴记录
int pivotkey = 0;
//计算数组中间的下标
int m = low + (high - low)/2;
if(a[low] > a[high]){
swap(a, low, high);
}
if(a[m] > a[high]){
swap(a, m, high);
}
if(a[low] > a[m]){
swap(a, low, m);
}
pivotkey = a[low];
while(low < high){
//将比枢轴记录小的交换到低端
while(low < high && a[high] >= pivotkey){
high--;
}
swap(a,low,high);
//将比枢轴记录大的交换到高端
while(low < high && a[low] <= pivotkey){
low++;
}
swap(a,low,high);
}
//返回枢轴所在的位置
return low;
}

优化二：优化不必要的交换

经过上面的优化，我们选取枢轴关键字基本是适中大小的，分析枢轴的位置变化过程，从最后一个位置到第一个位置，再到中间那个位置。其实枢轴的目标就是中间那个位置，所以在枢轴到达中间位置的很多交换其实是不必要的。基于这个思路可以继续优化partition函数如下：

private int partition3(int[] a, int low, int high) {
//用第一个元素作为枢轴记录
int pivotkey = 0;
//计算数组中间的下标
int m = low + (high - low)/2;
if(a[low] > a[high]){
swap(a, low, high);
}
if(a[m] > a[high]){
swap(a, m, high);
}
if(a[low] > a[m]){
swap(a, low, m);
}
pivotkey = a[low];
//把枢轴元素备份到一个临时变量中
int temp = pivotkey;
while(low < high){
//将比枢轴记录小的交换到低端
while(low < high && a[high] >= pivotkey){
high--;
}
//采用替换而不是交换的方式操作
a[low] = a[high];
//将比枢轴记录大的交换到高端
while(low < high && a[low] <= pivotkey){
low++;
}
//采用替换而不是交换的方式操作
a[high] = a[low];
}
//将枢轴的值替换回给a[low]
a[low] = temp;
//返回枢轴所在的位置
return low;
}

优化三：优化数据量较小时的排序

在数据量较小的时候使用简单排序算法反而更简单，更高效，正如排序数组{2,1,3}的时候，使用简单排序算法比如直接插入排序只要两次比较久搞定了，使用快速排序的话还要划分，明显效率低一些。所以我们可以对partition函数进行小数组的优化，有资料认为当数组的长度不大于7的时候算是小数组，也有认为是50，这个其实不是最重要的，这个时候就使用直接插入排序算法就很好用。所以基于这个思路优化代码如下：

private void qSort(int[] a, int low, int high) {
int pivot = 0;
if(low < high && (high - low) > MAX_LENGTH_SORT){
//MAX_LENGTH_SORT暂且定为50
//将数组a一分为二
pivot = partition3(a,low,high);
//对第一部分进行递归排序
qSort(a,low,pivot);
//对第二部分进行递归排序
qSort(a,pivot + 1,high);
}else{
//小数组的时候使用直接插入排序
insertSort(a);
}
}

优化四：优化递归操作

递归对性能较大，如果递归的层次很多的话将会造成栈溢出，因此如果能够能够减少递归次数的话将会对函数的性能提高不少。下面对qSort函数进行代码优化如下：

private void qSort2(int[] a, int low, int high) {
int pivot = 0;
if(low < high && (high - low) > MAX_LENGTH_SORT){
while(low < high){
//将数组a一分为二
pivot = partition3(a,low,high);
//对第一部分进行递归排序
qSort2(a,low,pivot);
//对第二部分进行尾递归,这里之所以可以将pivot+1赋给low，是因为一/次递归结束
//之后，low的值就没有用处了。下一次递归调用的执行的就是qSort(a,pivot + 1,high)
low = pivot +1;
}
}else{
//小数组的时候使用直接插入排序
insertSort(a);
}
}

转载：

原文地址：

http://blog.csdn.net/u011116672/article/details/50134835