Javaは：[すばやく]並び選択的に結合し、線形時間を最適化

免責事項：この記事はブロガーオリジナル記事です、続くBY-SAのCC 4.0を著作権契約、複製、元のソースのリンクと、この文を添付してください。

このリンク： https://blog.csdn.net/qq_43336822/article/details/94501099

最悪の場合の複雑さのクイックドレンは、それが最適化する必要がある（N ^ 2）Oに到達します。
：リファレンス前に、各シーケンスの長さの後に行うことができる最悪のケースを避けるために、実質的に同じである、それが配列の中央値のレベルを見つけるために、線形アルゴリズムを使用する必要がある：線形時間選択アルゴリズムを選択します。

実装のソースコード：

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万人に到達します