TopK問題：什么是TopK問題？用堆和快排這兩種方式來實現TopK

　　目錄

一、什么是Top K問題

二、Top K的實際應用場景

三、Top K的代碼實現及其效率對比

　　1.用堆來實現Top K

　　2.用快排來實現Top K

　　3.用堆或用快排來實現 TopK 的效率對比

 

　　正文

一、什么是Top K問題？

　　給一個無序的數組，長度為N，  請輸出最小 （或最大）的K個數。

 

二、Top K的實際應用場景

　　排行榜：用戶數量有幾百萬， 但是只需要前100名的用戶成績。 要顯示出來， 且這個排行榜是實時變化的。

 

三、Top K的代碼實現

　　需求：給一個無序的數組，長度為N， 請輸出最大的5個數。 

　　1. 用堆來實現Top K——PriorityQueue（小頂堆）

　　（1）步驟梳理：

　　　　①創建一個結點個數為 k 的小頂堆；

　　　　②當數據量 < k 時，將數據直接放到這個小頂堆中，此時堆的頂結點是最小值；

　　　　③當數據量 >= k時，每產生一個新數據都與堆的頂結點進行比較: 

　　　　　　如果新數據 > 頂結點數據，則將頂結點刪除，將新數據放到堆中，此時堆會進行排序，且維護了堆的總結點數為k;

                        如果新數據＜頂結點數據，則不動。

　　（2）中心思想：使堆的總結點數維持在 k 個。

　　（3）代碼實現：

    @Test
    public void getTopKByHeapInsertTopKElement() {
        int arrayLength = 10000000 + 10;
        int topK = 5;

        // 准備一個長度為arrayLength的無序數組：
        int[] array = A03TopKByQuickSortAndNewArray.getDisorderlyArray(arrayLength);

        // 准備一個總結點數為topK的小頂堆：
        PriorityQueue<Integer> heap = new PriorityQueue<>(topK);

        long start = System.currentTimeMillis();
        
        // 始終維持一個總結點個數為k的堆：
        insertButmaintainTheHeapAtTopK(heap, array, topK);
        
        //獲得最大topK：
        printHeap(heap);
        
        long end = System.currentTimeMillis();
        System.out.println("獲得最大top5總耗時： " + (end - start));
    }
    
    /**
     * 用小頂堆來獲取topK：當數據量超過topK后，新產生的數據直接和heap的頂結點進行比較。
     */
    private static void insertButmaintainTheHeapAtTopK(PriorityQueue<Integer> heap, int[] array, int topK) {
        for (int i = 0; i < array.length; i++) {
            if (i < topK) {
                heap.add(array[i]);
            } else {// 怎么維持堆的總結點個數，下面的代碼是關鍵：
                if (null != heap.peek() && array[i] > heap.peek()) {
                    heap.poll();
                    heap.add(array[i]);
                }
            }
        }
    }
    
    /**
     * 獲取最大TopK
     * @param heap
     */
    static void printHeap(PriorityQueue<Integer> heap) {
        Iterator<Integer> iterator = heap.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

　　

 

　　2. 用快排來實現Top K

　　（1）步驟梳理：

　　　　①通過快排，先將無序數組array進行排序；

　　　　②取出最小Top 5，並放到topArray中；【關鍵】

　　　　③超過arrayLength個數據后，又產生了insertNumber個新數據：直接和topArray數組比較，要放也是放到topArray中了；【關鍵】

　　（2）時間復雜度：

　　　　①排序的時間復雜度：O(N*logN)；

　　　　②取出top k的時間復雜度：O(1)，就是遍歷數組。

　　（3）代碼實現：

    @Test
    public void testGetTopKByQuickSortToNewArray() {
        int topK = 5;
        int arrayLength = 10000000;
        
        //准備一個無序數組
        int[] array = getDisorderlyArray(arrayLength);
        
        long start = System.currentTimeMillis();
        
        //1.通過快排，先將無序數組array進行排序
        quickSort(array, 0, array.length-1);
        
        //2.取出最小Top 5，並放到topArray中：
        int[] topKArray = insertToTopArrayFromDisorderlyArray(array, topK);
        
        //3.超過arrayLength個數據后，又產生了insertNumber個新數據：直接和topArray[topKArray.length-1]比較，要放也是放到topArray中了
        insertToTopKArray(topKArray, 10, 100, topKArray.length-1);//生成10個100以內的隨機數作為新數據，和topKArray[topKArray.length-1]
        
        long end = System.currentTimeMillis();
        System.out.println("獲得最大top5總耗時： " + (end - start));
    }
    
    /**
     * 產生新的數據后，再和topKArray數組進行比較，看新數據時候需要插入到topKArray中，若需要插入，則堆topKArray進行重新快排。
     * 
     * @param topKArray topK數組
     * @param insertNumber 新產生的數據的個數
     * @param randomIntRange 在什么范圍內產生新數據，如生成10以內的隨機數。
     * @param topK 在topKArray中，確定要替換的元素的下標。獲得最小topK，則topK是從小到大排序的topKArray的最后一個元素。
     */
    private static void insertToTopKArray(int[] topKArray, int insertNumber, int randomIntRange, int topK) {
        Random random = new Random();
        int randomInt;
        for(int i = 0; i < insertNumber; i++) {
            randomInt = random.nextInt(100);
            if(randomInt < topKArray[topK]) {//新數據如果小於topArray[topK]，則直接用該數去替換topArray，然后再將topArray進行重新排序。
                topKArray[topK] = randomInt;
                quickSort(topKArray, 0, topKArray.length-1);
            }
        }
    }
    
    /**
     * 從有序數組中取出需要的TopK，放到TopK數組中。
     * 
     * @param sourceArray 有序數組
     * @param topK 需要獲取到Top K
     * @return TopK數組
     */
    private static int[] insertToTopArrayFromDisorderlyArray(int[] sourceArray, int topK) {
        int[] topArray = new int[topK];
        for(int i = 0; i < 5; i++) {
            topArray[i] = sourceArray[i];
        }
        return topArray;
    }
    
    /**
     * 快排
     * @param target
     * @param left
     * @param right
     */
    static void quickSort(int[] target, int left, int right) {
        if (left >= right) {
            return;
        }
        int pivot = target[left];// 基准點
        int temp;
        int i = left;
        int j = right;
        while (i < j) {
            while (target[j] >= pivot && i < j) {
                j--;
            }
            while (target[i] <= pivot && i < j) {
                i++;
            }
            if (i < j) {
                temp = target[i];
                target[i] = target[j];
                target[j] = temp;
            }
        }
        // left和right相遇了：
        // ①將相遇點的元素和pivot做交換：
        target[left] = target[j];
        target[j] = pivot;
        // ②基准點兩邊的元素的分別再做排序：
        quickSort(target, left, j - 1);
        quickSort(target, j + 1, right);
    }
    
    /**
     * 准備一個無序數組
     * 
     * @param arrayLength
     * @return int[]
     */
    static int[] getDisorderlyArray(int arrayLength) {
        int[] disorderlyArray = new int[arrayLength];
        Random random = new Random();
        for (int i = 0; i < arrayLength; i++) {
            disorderlyArray[i] = random.nextInt(arrayLength);
        }
        return disorderlyArray;
    }
    
    /**
     * 遍歷數組
     */
    static void showArray(int[] target) {
        for (Integer element : target) {
            System.out.println(element);
        }
    }

 

　　3. 用堆來實現TopK 和 用快排來實現TopK 的效率對比：

　　　　　　　　　　　　　　　　　　“小頂堆”　　　　|　　　　“快排”

　　　　數據量為100萬+10時：　　　　11毫秒　　　　|　　　　124毫秒

　　　　數據量為1000萬+10時：　　　　28毫秒　　　　|　　　　1438毫秒