对BFPRT算法理解

对于求一个数组中第k小的数, 可以用快速排序的中间过程解决, 例如 找到的基准数的位置>k, 这时候就只需要对于前半部分再进行行 一次这个中间过程.直到找到 第K个数.

然而问题是，快速排序的基准数如果选的不好，范围就缩小不了1/2甚至还没有, 时间复杂度可能会到o(n^2).

所以 关于 选择基准数 可以不随机选，而是通过如下步骤:

[1] 将数组每5个分成一组, 可能最后一组不足5个

[2] 进行组内排序， 因为对5个进行排序的时间复杂度可以看成o(1), 所以总消耗o(n).

[3] 将每一组的中位数提取出来形成一个新的数组, 这个新的数组的长度是1  + n/5,  然后对这个新数组 再进行[1][2][3]步骤, 不过是找这个中位数数组的1/2位置的元素. 得到它之后, 

[4] 利用得到的中位数数组的第1/2个数作为基准, 进行快速排序的part过程

对组内排序进行分析, 一开始是o(n) , 递归调用是  o(n/5) ,  o(n/25)  ... 这个是趋于o(n)的,  然而有空间消耗

/**
     * 找出数组中第k小数字
     * @param arr
     * @param k 从0开始计数 [0, arr.len-1]
     * @return
     */
    public  int bFPRT(int[] arr, int k, int left, int right) {
        Objects.requireNonNull(arr);
        if (k < left || k > right) {
            throw new IllegalArgumentException("K属于[" + left + ", " + right + "]");
        } else if (right - left <= 0) {
            return arr[left];
        }
        
        
        final int z = 5;
        // 每5个一组, 组内排序
        sortForGroup(arr, z, left, right);
        
        
        // 抽取中位数, 组成一个新数组
        int newArr[] = new int[(right - left) / 5 + 1];
        getMidNumberFormGroup(arr, z, newArr, left, right);
        int midValue = bFPRT(newArr, newArr.length / 2 , 0, newArr.length - 1);
        
        int[] ret = part(arr, 0, arr.length-1, midValue);
        if (ret[0] >= k && ret[1] <= k) {
            return arr[ret[0]];
        } else if (k < ret[0]) {
            return bFPRT(arr, k, 0, ret[0] - 1);
        } else {
            return bFPRT(arr, k, ret[1] + 1, right);
        }
    }
    
    private void getMidNumberFormGroup(int[] arr, int z, int[] midArr, int left, int right) {
        
        int l = left , r = left + z - 1 > right ? right : left + z - 1;
        for (int i = 0;i < midArr.length;i ++) {
            
            midArr[i] = arr[l + (r-l)/2];
            l = l + z;
            if (l + z > right) {
                r = right;
            } else {
                r = l + z;
            }
            
            
        }
    }
    private void sortForGroup(int[] arr, int z, int left, int right) {
        // 0 1 2 3 4 5 6
        for (int i = left;i <= right;i += z) {
            int j = i + z;
            if (j > arr.length - 1) {
                j = arr.length - 1;
            }
            Arrays.sort(arr, i, j + 1);
        }
    }
    /**
     * 这个是快速排序Part的过程, base 必须是[left, right]之内的数
     * 如果base==null, 随机去一个作为基数
     * 返回的数组 ret[0] 是 第一个等于base的索引位置, ret[1]是最后一个等于base的索引位置
     * @param arr
     * @param left
     * @param right
     * @param base
     * @return
     */
    public int[] part(int[] arr, int left, int right, Integer base) {
        if (arr == null || arr.length == 0) {
            throw new IllegalArgumentException();
        }
        ThreadLocalRandom random = ThreadLocalRandom.current();
        int realBase = (base == null)? arr[left + random.nextInt(right - left + 1)] : base;
        int lt = left - 1, gt = right;
        int i = left;
        while (i <= gt) {
            if (arr[i] < realBase) {
                change(arr, ++lt, i++);
            } else if (arr[i] > realBase) {
                change(arr, gt--, i);
            } else {
                i++;
            }
        }
        
        return new int[] {lt+1, gt};
    }
    public void change(int[] arr, int i, int j) {
        if (i == j) {
            return;
        }
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }