数据结构与算法之快速排序

快速排序顾名思义，在大部分情况下都能快速的将数据进行排序。百度百科快速排序的定义：通过一趟排序将要排序的数据分成独立的两部分，其中一部分的数据比另一部分的所有数据都要小，然后再按照这个方法对这两部分进行快速排序，排序以递归进行，从而达到将整个数据变成有序序列。快速排序的平均运行时间是O(N log N)。

从快速快速的定义可知，排序是将数据分成两部分，因此选择切分数据的中数非常重要，否则两部分的数据大小可能非常不均匀。

常用的分割策略：

1. 随机选取中数；
2. 三数中值分割法；在实际运用中通常是取数组的第一个值和中间值以及末尾值三者中间的中间数作为区分整个数组的中数。

另外在实际的运用中发现对于数据量比较小的数组使用插入排序更有效，因此需要根据数据量分别处理。

快速排序的代码实例：

package structures.arithmetic;

/**
 * 快速排序
 */
public class QuickSort {
    /**
     * 根据值大小确认使用插入排序还是分组递归排序
     */
    private final static int count = 10;

    /**
     * 快速排序
     * @param a 数组
     * @param left 左侧位置
     * @param right 右侧位置
     * @param <AnyType> 类型
     */
    public static <AnyType extends Comparable<? super AnyType>> void quickSort(AnyType[] a, int left, int right){
        if(left+count<right){
            AnyType centureValue = media3(a, left, right); 
            int i=left, j=right-1;
            for(;;){
                while (a[++i].compareTo(centureValue)<0){ }
                while (a[++j].compareTo(centureValue)>0){ }
                if(i<j){
                    replacePosition(a, i, j);
                }else {
                    break;
                }
            }
            //将中值还原回原来的位置
            replacePosition(a, i,right-1);
            //快速排序较小的哪一组数据
            quickSort(a,left,i-1);
            //快速排序较大的哪一组数据
            quickSort(a, i+1, right);
            
        }else{
            //数据量不大，使用插入排序
            insertSort(a, left, right);
        }
    }

    /**
     * 从数组中取中值
     * @param a
     * @param left
     * @param right
     * @param <AnyType>
     * @return
     */
    private static <AnyType extends Comparable<? super AnyType>> AnyType media3(AnyType[] a, int left, int right) {
    
        int center = (left+right)/2;
        if(a[center].compareTo(a[left])<0){
            replacePosition(a, left, center);
        }
        if(a[right].compareTo(a[left])<0){
            replacePosition(a,left, right);
        }
        if(a[center].compareTo(a[right])<0){
            replacePosition(a, right ,center);
        }
        //将中值的位置和数组末尾的位置替换
        replacePosition(a, center, right-1);
        return a[right-1];
    }

    /**
     * 将位置在left的值和位置在center的值交换
     * @param a 数组
     * @param position1 要交换的位置
     * @param position2 要交换的位置
     */
    private static <AnyType extends Comparable<? super AnyType>> void replacePosition(AnyType[] a, 
                                                                                      int position1, int position2) {
    
        AnyType tmp = a[position1];
        a[position1] = a[position2];
        a[position2] = tmp;
    }

    /**
     * 插入排序
     */
    private static <AnyType extends Comparable<? super AnyType>> void insertSort(AnyType[] a, int left, int right) {
    }
}