在Java中以O（n）运行的Quickselect？

所以我要实现一个quickselect算法，每次都选择一个好的轴心点。它所做的是将数组分成5个组，对每个组进行排序并找到中间值。然后取每组的中间值，将这些值分组，然后找到中间值的中间值。以下是我所拥有的：

private static int pickCleverPivot(int left, int right, int[] A){
    int index = 0;
    int n = right-left;
    if (n <= 5) {
        Arrays.sort(A);
        index = n/2;
        return index;
    }
    int numofMedians = (int) Math.ceil(n/5);
    int[] medians = new int[numofMedians];
    int[] groups = new int[5];

    for(int i = 0; i < numofMedians; i++) {
        if (i != numofMedians - 1){
            for (int j = 0; j < 5; j++){
                groups[j] = A[(i*5)+j];
            }
            medians[i] = findMedian(groups, 5);
        } else {
            int numOfRemainders = n % 5;
            int[] remainder = new int[numOfRemainders];
            for (int j = 0; j < numOfRemainders; j++){
                remainder[j] = A[(i*5)+j];
            }
            medians[i] = findMedian(groups, 5);
        }
    }
    return pickCleverPivot(left, left+(numofMedians), medians);
}

public static int findMedian(int[] A, int n){
    Arrays.sort(A);
    if (n % 2 == 0) {
        return (A[n/2] + A[n/2 - 1]) / 2;
    }
    return A[n/2];
}

private static int partition(int left, int right, int[] array, int pIndex){
    //move pivot to last index of the array
    swap(array,pIndex,right);


    int p=array[right];
    int l=left;
    int r=right-1;

    while(l<=r){
        while(l<=r && array[l]<=p){
            l++;
        }
        while(l<=r && array[r]>=p){
            r--;
        }
        if (l<r){
            swap(array,l,r);
        }
    }

    swap(array,l,right);

    return l;
}
private static void swap(int[]array, int a, int b){
    int tmp = array[a];
    array[a] = array[b];
    array[b] = tmp;
}

private static int pickleverpivot（int left，int right，int[]A）{
int指数=0；
int n=右-左；
如果（n）为什么你认为这仅仅是因为它较慢，它不会在O（n）时间内运行？带有随机轴的QuickSelect会在预期的O（n）时间内运行。你的也会这样，但你只是为了选择一个轴而做了很多工作，所以常数因子更大。为什么你认为这仅仅是因为它较慢，它不会在O（n）时间内运行时间？带有随机轴的QuickSelect将在预期的O（n）时间内运行。您的QuickSelect也会在预期的O（n）时间内运行，但您只是为了选择一个轴而做了大量工作，因此常数因子更大。