经典算法 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;
     }