经典算法 BFPRT算法详解

内容：

1、原始问题     =》  O(N*logN)

2、BFPRT算法    =》 O(N)

1、原始问题

问题描述：给你一个整型数组，返回其中第K小的数

普通解法：

这道题可以利用荷兰国旗改进的 partition 和随机快排的思想：随机选出一个数，将数组以该数作比较划分为 <,=,> 三个部分，

则 = 部分的数是数组中第几小的数不难得知，接着对 < （如果第K小的数在 < 部分）或 > （如果第K小的数在 > 部分）部分的数

递归该过程，直到 = 部分的数正好是整个数组中第K小的数。这种做法不难求得时间复杂度的数学期望为 O(NlogN) （以2为底）。

但这毕竟是数学期望，在实际工程中的表现可能会有偏差(最坏情况下的时间复杂度会达到O(N^2))

BFPRT算法可以说是这种算法的一种优化吧，故在此就不写这种解法的代码了

另外一种普通解法：

用堆去做，时间复杂度是靠谱的O(N*logk)

代码如下：

    // 大根堆比较器
    public static class MaxheapComparator implements Comparator<Integer> {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2 - o1; 
        }
    }

    // O(N*logk)的解法
    public static PriorityQueue getMinKNumsByHeap(int[] arr, int k) {
        if (k < 1 || k > arr.length) {
            return null;
        }
        PriorityQueue<Integer> kHeap = new PriorityQueue<Integer>(k,
                new MaxheapComparator());
        for (int i = 0; i != k; i++) {
            kHeap.add(arr[i]);
        }
        for (int i = k; i != arr.length; i++) {
            if (arr[i] < kHeap.peek()) {
                kHeap.poll();
                kHeap.add(arr[i]);
            }
        }
        return kHeap;
    }

    public static void main(String[] args) {
        int[] arr = { 1, 3, 2, 5, 9 };
        // 测试普通方法
        System.out.println(getMinKNumsByHeap(arr, 1).peek());
        System.out.println(getMinKNumsByHeap(arr, 2).peek());
        System.out.println(getMinKNumsByHeap(arr, 3).peek());
        System.out.println(getMinKNumsByHeap(arr, 4).peek());
        System.out.println(getMinKNumsByHeap(arr, 5).peek());
    }

2、BFPRT算法

BFPRT算法能够做到时间复杂度就是 O(N)    BFPRT算法，接收一个数组和一个K值，返回数组中的一个数

1. 数组被划分为了 N/5 个小部分，每个部分的5个数排序需要 O(1) ，所有部分排完需要 O(N/5)=O(N)

2. 取出每个小部分的中位数，一共有 N/5 个，递归调用BFPRT算法得到这些数中第 (N/5)/2 小的数（即这些数 的中位数），记为 pivot

3. 以 pivot 作为比较，将整个数组划分为 <pivot , =pivot , >pivot 三个区域

4. 判断第K小的数在哪个区域，如果在 = 区域则直接返回 pivot ，如果在 < 或 > 区域，则将这个区域的数递 归调用BFPRT算法

5. base case ：在某次递归调用BFPRT算法时发现这个区域只有一个数，那么这个数就是我们要找的数

    // O(N)的解法
    public static int getMinKthNum(int[] arr, int k){
        if(arr==null||k>arr.length){
            return Integer.MIN_VALUE;
        }
        int[] copyArr = Arrays.copyOf(arr, arr.length);
        return BFPRT(copyArr, 0, arr.length-1, k-1);
    }
    
    private static int[] partition(int[] arr, int begin, int end, int pivot){
        int L = begin-1;
        int R = end + 1;
        int cur = begin;
        while(cur!=R){
            if(arr[cur]>pivot){
                swap(arr, cur, --R);
            } else if(arr[cur]<pivot){
                swap(arr, cur++, ++L);
            } else{
                cur++;
            }
        }
        return new int[]{L+1, R-1};
    }
    
    private static int BFPRT(int[] arr, int begin, int end, int i) {
        if (begin == end) {
            return arr[begin];
        }
        int pivot = medianOfMedians(arr, begin, end);
        int[] pivotRange = partition(arr, begin, end, pivot);
        if(i>=pivotRange[0]&&i<=pivotRange[1]){
            return arr[i];
        } else if(i<pivotRange[0]){
            return BFPRT(arr, begin, pivotRange[0]-1, i);
        } else{
            return BFPRT(arr, pivotRange[1] + 1, end, i);
        }
    }

    private static int medianOfMedians(int[] arr, int begin, int end) {
        int num = end - begin + 1;
        int offset = num % 5 == 0 ? 0 : 1;
        int[] medians = new int[num / 5 + offset];
        for (int i = 0; i < medians.length; i++) {
            int beginI = begin + i * 5;
            int endI = beginI + 4;
            medians[i] = getMedian(arr, beginI, Math.min(endI, end));
        }
        return BFPRT(medians, 0, medians.length - 1, medians.length / 2);
    }
    
    private static int getMedian(int[] arr, int begin, int end){
        insertionSort(arr, begin, end);
        int sum = end + begin;
        int mid = (sum/2) + (sum%2);
        return arr[mid];
    }
    
    private static void insertionSort(int[] arr, int begin, int end){
        if(begin>=end){
            return;
        }
        for(int i=begin+1;i<=end;i++){
            for(int j=i;j>begin;j--){
                if(arr[j]<arr[j-1]){
                    swap(arr, j, j-1);
                } else{
                    break;
                }
            }
        }
    }
    
    private static void swap(int[]arr , int i, int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }