快速排序

#算法思想

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

实现快速排序算法的核心是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