BFPRT算法：（TOP-K问题）

一：背景介绍

在一堆数中求其前 k 大或前 k 小的问题，简称 TOP-K 问题。而目前解决 TOP-K 问题最有效的算法即是 “BFPRT 算法”，又称为 “中位数的中位数算法”，该算法由 Blum、Floyd、Pratt、Rivest、Tarjan 提出，最坏时间复杂度为 O(n)。

在首次接触 TOP-K 问题时，我们的第一反应就是可以先对所有数据进行一次排序，然后取其前 k 即可，但是这么做有两个问题：

快速排序的平均复杂度为 O(nlogn)，但最坏时间复杂度为 O(n2)，不能始终保证较好的复杂度。

我们只需要前 k 大的，而对其余不需要的数也进行了排序，浪费了大量排序时间。

那是否还存在更有效的方法呢？BFPRT 算法的做法就是在快速排序的基础上，通过判断等于区位置与 k 的大小使递归的规模变小，其次通过修改快速排序中基准值的选取方法来降低快速排序在最坏情况下的时间复杂度。

下面先来简单回顾下快速排序的过程，以升序为例：

1、在数组中随机选取一个元素作为基准值；
2、以选取的基准值作为分界点，把小于基准值的放在左边，大于基准值的放在右边；（即将数组划分为3个区域，小于区、等于区、大于区。）
3、分别对左边和右边进行递归，重复上述过程。

二：BFPRT 算法过程及代码

时间复杂度： O（N）

上面提到 BFPRT 算法的做法就是在快速排序的基础上，通过判断等于区位置与 k 的大小使递归的规模变小，其次通过修改快速排序中基准值的选取方法来降低快速排序在最坏情况下的时间复杂度。
那么如何来选取基准值呢？
1、将数组中的 N 个元素分为 N/5 组，每组 5 个元素，若最后一个数组不足 5 个元素，则也将这几个元素组成一组，若这几个元素为偶数，则取上中位数。
eg [4, 5, 6, 7] 取 5

2、将这 N/5 个数组进行排序（使用插入排序），取出这个 N/5 个数组中的中位数， 然后将这 N/5 个中位数再组成一个数组 mArr ，最后调用BFPRT算法来取出数组 mArr 中的中位数作为基准值

3、：以上面选取的基准值为分界点，把小于基准值的放在左边，大于基准值的放在右边；

4、：上面的步骤完成后，判断基准值的位置（即等于区）与 k 的大小，如果在等于区里，则取该基准值为第 K 小的值。如果 k 小于基准值，则将小于区拿去递归（重复1234过程），如果 k 大于基准值，则将大于区拿去递归（重复1234过程）。

5、找到第 k 小的数之后，再遍历数组， 很容易得到前 k 小的数，详细看
getMinKNumsByBFPRT（）。

tips:
为什么要这样取基准值呢，因为将一个数组分为 N/5 个长度为 5 数组， 每个数组又取出中位数，然后将这些中位数组成一个长度为 N/5 的数组，其中取出的这个中位数，大于自己数组中的 N/10 个数，而这 N/10 个数本身在自己5个数的小数组中有2个数比它小，即 (N/10)*2，所以在初始数组中至少有 3*N/10 个数比基准值要小，至少有 7*N/10 个数比基准值要大，可以确定淘汰掉 3*N/10 个数

代码

import java.util.Arrays;

public class BFPRT {

    /**
     * 返回前K小的数
     * @param arr
     * @param k
     * @return
     */
    public static int[] getMinKNumsByBFPRT(int[] arr, int k) {
        if (k < 1 || k > arr.length) {
            return arr;
        }
        int minKth = getMinKthByBFPRT(arr, k);
        int[] res = new int[k];
        int index = 0;
        for (int i = 0; i != arr.length; i++) {
            if (arr[i] < minKth) {
                res[index++] = arr[i];
            }
        }
        for (; index != res.length; index++) {
            res[index] = minKth;
        }
        return res;
    }

    /**
     * 返回数组中第K小的数
     * @param arr
     * @param K
     * @return
     */
    public static int getMinKthByBFPRT(int[] arr, int K) {
        int[] copyArr = copyArray(arr);
        return select(copyArr, 0, copyArr.length - 1, K - 1);
    }

    public static int[] copyArray(int[] arr) {
        int[] res = new int[arr.length];
        for (int i = 0; i != res.length; i++) {
            res[i] = arr[i];
        }
        return res;
    }

    /**
     * 在数组上给一个 end - begin 的范围,在这个范围上,返回位于第 i 位置上的数
     * @param arr
     * @param begin
     * @param end
     * @param i
     * @return
     */
    public static int select(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 select(arr, begin, pivotRange[0] - 1, i);
        }else if (i > pivotRange[1]) {
            return select(arr, pivotRange[1] + 1, end, i);
        }

        return 0;
    }

    /**
     * 求一个范围内的划分值
     * @param arr
     * @param begin
     * @param end
     * @return
     */
    public static int medianOfMedians(int[] arr, int begin, int end) {
        int num = end - begin + 1;
        int offset = num % 5 == 0 ? 0 : 1;
        int[] mArr = new int[num / 5 + offset]; //所有中位数组成的数组
        for (int i = 0; i < mArr.length; i++) {
            int beginI = begin + i * 5;
            int endI = beginI + 4;
            mArr[i] = getMedian(arr, beginI, Math.min(endI, end));
        }
        return select(mArr, 0, mArr.length - 1, mArr.length / 2);
    }

    /**
     * 
     * @param arr
     * @param begin
     * @param end
     * @param pivotValue 基准值
     * @return  返回等于区 最左边的位置 和 最右的位置
     */
    public static int[] partition(int[] arr, int begin, int end, int pivotValue) {
        int small = begin - 1;
        int big = end + 1;
        int i = begin;
        while (i < big) {
            if (arr[i] < pivotValue) {
                small++;
                swap(arr, small, i);
                i++;
            }else if (arr[i] > pivotValue) {
                big--;
                swap(arr, i, big);
            }else {
                i++;
            }
        }
        return new int[] {small + 1, big - 1};
        /*int small = begin - 1;
        int cur = begin;
        int big = end + 1;
        while (cur != big) {
            if (arr[cur] < pivotValue) {
                swap(arr, ++small, cur++);
            } else if (arr[cur] > pivotValue) {
                swap(arr, cur, --big);
            } else {
                cur++;
            }
        }
        int[] range = new int[2];
        range[0] = small + 1;
        range[1] = big - 1;
        return range;*/
    }

    /**
     * 获取上中位数
     * eg 9 10 11 12  取10
     * eg 1 2 3 4 5 取3
     * @param arr
     * @param begin
     * @param end
     * @return
     */
    public static int getMedian(int[] arr, int begin, int end) {
        insertionSort(arr, begin, end);
        return arr[(end - begin) / 2 + begin];
    }

    /**
     * 插入排序
     * @param arr
     * @param begin
     * @param end
     */
    public static void insertionSort(int[] arr, int begin, int end) {
        for (int i = begin + 1; i != end + 1; i++) {
            for (int j = i; j != begin; j--) {
                if (arr[j - 1] > arr[j]) {
                    swap(arr, j - 1, j);
                } else {
                    break;
                }
            }
        }
    }

    public static void swap(int[] arr, int index1, int index2) {
        int tmp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = tmp;
    }

    public static void printArray(int[] arr) {
        System.out.print("前10小的数: ");
        for (int i = 0; i != arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] arr = { 6, 9, 1, 3, 1, 2, 2, 5, 6, 1, 3, 5, 9, 7, 2, 5, 6, 1, 9 };
        printArray(getMinKNumsByBFPRT(arr, 10));
        System.out.println("第10小的数: " + getMinKthByBFPRT(arr, 10));
    }
}

输出

原数组: 6, 9, 1, 3, 1, 2, 2, 5, 6, 1, 3, 5, 9, 7, 2, 5, 6, 1, 9 
前10小的数: 1 3 1 2 2 1 3 2 1 5 
第10小的数: 5

参考：
https://www.61mon.com/index.php/archives/175/
http://blog.csdn.net/liuxiao214/article/details/78597508