數據結構--BFPRT算法（TOP-K算法）

在一大堆數中求其前k大或前k小的問題

最壞時間復雜度為O(n)。

 

1.可以將數組排序，然后取出第k小的數   O(nlogn)

2.維護一個k大小的堆　　　　O(nlogk)

public static class MinHeapComparator implements Comparator<Integer> {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o1 - o2;
        }
    }
    /**
     * 維護一個小根堆，每次都是從小根堆取值
     * @param arrays
     * @param k
     * @return
     */
    public static int[] smallOfKByHeap(int[] arrays, int k) {
        if (k == 0 || arrays == null || arrays.length == 0) return null;

        PriorityQueue<Integer> queue = new PriorityQueue<>( new MinHeapComparator() );

        for(int i = 0; i < arrays.length; i++){
            queue.add( arrays[i] );
        }

        int[] res = new int[k];
        for(int i = 0; i < k; i++){
            res[i] = queue.poll();
        }
        return res;
    }

　　

3.一種比較簡單的方法：采用荷蘭國旗的partition解法，隨機（int random = (int)(Math.random() * (right - left + 1)) + left）選取一個數num，進行partition，然后看k在三個區域的哪一部分，在=num區域，則直接返回，若在另外兩個區域，則只求解其中的一半即可，依然采取如下的策略  長期期望 O(N)  取決於每次選取的num的位置

public static int smallOfKByPartition(int[] arrays, int k){
        if(k == 0 || arrays == null || arrays.length == 0) return -1;
        int num = smallK( arrays, 0, arrays.length - 1, k - 1 );
        return num;
    }

    public static int smallK(int[] arrays, int left, int right, int k){
        if(left == right) return arrays[left];
        int[] num = partition( arrays, left, right);

        if(num[0] <= k && num[1] >= k){
            return arrays[k];
        } else if(num[0] > k){
            return smallK( arrays, left, num[0] - 1, k);
        } else{
            return smallK( arrays, num[1] + 1, right, k);
        }
    }

    public static int[] partition(int[] arrays, int left, int right){
        int random = (int) (Math.random() * (right - left + 1)) + left;
        swap(arrays, random, right);

        int index = left;
        int small = left - 1, big = right;
        while(index < big){
            if(arrays[index] < arrays[right]){
                swap(arrays, ++small, index++);
            } else if(arrays[index] == arrays[right]){
                index++;
            } else {
                swap(arrays, index, --big);
            }
        }

        swap(arrays, right, big);
        return new int[]{small + 1, big};
    }

    public static void swap(int[] arrays, int i, int j){
        int temp = arrays[i];
        arrays[i] = arrays[j];
        arrays[j] = temp;
    }

 

<num

=num

>num

4.BFPRT算法：  O(N)    bfprt(array, k)

①將整個數組array[]  5個5個分組，共有n/5組  　　　　　　　　　　　　O(1)

②在組內使用插入排序  　　　　　　　　　　 　　　　　　　　　　  　O(N)

③找到每個組的中位數，組成新的數組（長度為n/5） newArray[]   　　　 O(N)

④遞歸調用bfprt(newArray, newArray.length/2)  求出其中位數  num  　　T(N/5)

⑤然后利用num進行3方法中進行partition，　　　　　　　　　　　　　O(N)　　　　　　　　　　　　

<num

=num

>num

⑥若在=num區域時，則返回，否則，選擇其中的一半進行后續的partition  T(7N/10)

T(N) = T(N/5) + T(7N/10) + O(N) = O(N)