Java：【快速排序优化】与线性时间选择结合

快排在最坏情况下复杂度会达到O(n^2)，需要进行优化。
：可以使每次的基准前后序列长度都大致相同，避免最坏情况的发生，所以需要使用一个线性级别的算法来找出序列的中位数：select线性时间选择算法。

实现源码：

package Keshe;
import java.util.Arrays;

public class Test {

    private static Comparable[] bubble(int left, int right, Comparable []arr){  //冒泡排序，每次调用只起一次泡
        Comparable temp;
        for(int j=left;j<right;j++){
            if(arr[j+1].compareTo(arr[j])<0)
                swap(arr,j+1,j+2);
        }
        return arr;
    }
    private static Comparable[] bubbleSort(int left,int right,Comparable []arr){  //冒泡排序n-1次冒泡
        Comparable temp;
        for(int i=left+1;i<right;i++){
            boolean YN = true;
            for(int j=left;j<right-i;j++){
                if(arr[j+1].compareTo(arr[j])<0){
                    swap(arr,j+1,j);
                    YN = false;
                }
            }
            if(YN) break;
        }
        return arr;
    }
    public static Comparable select(int p,int r,int k,Comparable []arr)//Comperable强行对实现它的每个类的对象进行整体排序
    {
        if(r-p<5) {
            arr=bubbleSort(p,k,arr);
            return arr[p+k-1];
        }
        for(int i=0;i<=(r-p-4)/5 ;i++){
            int s = p+i*5;   //每组第一个元素
            int t = s + 4;      //每组最后一个元素
            for(int j=0;j<3;j++)
                arr=bubble(s,t-j,arr);  //遍历一次只做一次冒泡
            swap(arr,p+i,s+2);
        }
        Comparable x = select(p,p+(r-p-4)/5,(r-p+6)/10,arr);
        int i = partition(p,r,arr);
        int j=i-p+1;
        if(k<=j)
            return select(p,i,k,arr);
        else
            return select(i+1,r,k-j,arr);
    }//线性时间选择

    private static int partition(int p,int r,Comparable []arr){//11, 3, 29, 49, 30, 7, 50, 63, 46, 1, 99
        int i = p,j =r+1;
        Comparable x = arr[p];
        while(true){
            while(arr[++i].compareTo(x)<0 && i<r);
            while(arr[--j].compareTo(x)>0);
            if(i>=j){
                arr[p] = arr[j];
                arr[j] = (int)x;
                break;
            }
            swap(arr,i,j);
        }
        return j;
    }

    public static void swap(Comparable[] arr, int i, int j) {
        Comparable temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
        long a=System.nanoTime();
        Test s = new Test();
        Comparable[] arr = { 11, 3, 29, 49, 30, 7, 50, 63, 46, 1, 99 };
        System.out.println("未排序的数组：" + Arrays.toString(arr));
        s.select(0, arr.length - 1,arr.length/2,arr);
        System.out.println("排序后的数组：" + Arrays.toString(arr));
        System.out.print("运行时间：");
        System.out.println(System.nanoTime()-a+"纳秒");
    }
}

原先的快排运行时间大概在100万纳秒左右，优化后达到50万左右