BFPRT算法 查找第k小的数

一、算法来历

　　BFPRT算法由五位大佬（Blum 、Floyd 、 Pratt 、Rivest arjan）提出，并由其五人的首字母命名也称五个好朋友算法。用于在n个数中取得第k小的数或第k大的数。

二、算法主要思路

　　假设BFPRT算法函数为  int BFPRT(int[ ] arr,int k),其中arr数组为含有n个数待查找的数组

　　1.先将n个数以每五个数为一组进行分组，最后一组不足五个数也为一组。

　　2.将分好组的数组进行组内排序。

　　3.拿出每组的中位数(最后一组如果为偶数则拿出上中位数),组成新的数组。

　　4.调用BFPRT算法求出第3步数组中的中位数(递归)作为主元。

　　5.以第4步中得到的主元作为分界点，小于主元的放在左边，大于主元的放在右边。

　　6.判断主元的位置X与k的大小，如果X等于k则表明该中位数是第k小的元素，返回X。若X小于k，在X右边继续寻找第k小的元素。

　　否则，在X左边的数组中继续寻找第k个小的元素。

三、代码

public class BFPRT {
    
    public static int[] getMinKNumsByBFPRT(int[] arr,int k){//获取最小的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;
    }
    
    public static int getMinKthByBFPRT(int []arr,int K){ //获取第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;
    }
    
    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{
            return select(arr,pivotRange[1]+1,end,i);
        }
    }
    
    public static int medianOfMedians(int[] arr,int begin,int end){ //获取中位数数组的中位数
        int num = end - begin +1;
        int offset = num%5==0?0:1; //是否有不足5的组
        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(end, endI));
        }
        return select(mArr,0,mArr.length-1,mArr.length/2);
    }
    
    public static int[] partition(int[] arr,int begin,int end,int pivotValue){
        int small = begin-1;
        int  cur = begin;
        int big = end +1;
        while(cur!=big){
            if(arr[cur]<pivotValue){ //移到pivotValue左边
                swap(arr,++small,cur++);
            }else if(arr[cur]>pivotValue){  //移动到pivotValue右边
                swap(arr,--big,cur);
            }else{
                cur++;
            }
        }
        int[] range = new int [2];
        range[0] = small+1;
        range[1] = big-1;
        return range;
    }
    
    public static int getMedian(int[] arr,int begin,int end){  //获取中位数
        insertionSort(arr, begin, end);
        int sum = begin+end;
        int mid = sum/2 + (sum%2);
        return arr[mid];
    }
    
    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 temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
    }
    
    public static void printArray(int [] arr){
        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 };
        // sorted : { 1, 1, 1, 1, 2, 2, 2, 3, 3, 5, 5, 5, 6, 6, 6, 7, 9, 9, 9 }
        printArray(getMinKNumsByBFPRT(arr, 10));
    }
}

 四、时间复杂度

　　O（N）