優先隊列PriorityQueue實現 大小根堆 解決top k 問題

轉載：https://www.cnblogs.com/lifegoesonitself/p/3391741.html

PriorityQueue是從JDK1.5開始提供的新的數據結構接口，它是一種基於優先級堆的極大優先級隊列。優先級隊列是不同於先進先出隊列的另一種隊列。每次從隊列中取出的是具有最高優先權的元素。如果不提供Comparator的話，優先隊列中元素默認按自然順序排列，也就是數字默認是小的在隊列頭，字符串則按字典序排列（參閱 Comparable），也可以根據 Comparator 來指定，這取決於使用哪種構造方法。優先級隊列不允許 null 元素。依靠自然排序的優先級隊列還不允許插入不可比較的對象（這樣做可能導致 ClassCastException）

此隊列的頭是按指定排序方式的最小元素。如果多個元素都是最小值，則頭是其中一個元素——選擇方法是任意的。

隊列檢索操作 poll、remove、peek 和 element 訪問處於隊列頭的元素。
優先級隊列是無界的，但是有一個內部容量，控制着用於存儲隊列元素的數組的大小。
它總是至少與隊列的大小相同。隨着不斷向優先級隊列添加元素，其容量會自動增加。無需指定容量增加策略的細節。
注意1：該隊列是用數組實現，但是數組大小可以動態增加，容量無限。
注意2：此實現不是同步的。不是線程安全的。如果多個線程中的任意線程從結構上修改了列表， 則這些線程不應同時訪問 PriorityQueue 實例，這時請使用線程安全的PriorityBlockingQueue 類。
注意3：不允許使用 null 元素。
注意4：此實現為插入方法（offer、poll、remove() 和 add 方法）提供 O(log(n)) 時間；
為 remove(Object) 和 contains(Object) 方法提供線性時間；
為檢索方法（peek、element 和 size）提供固定時間。
注意5：方法iterator()中提供的迭代器並不保證以有序的方式遍歷優先級隊列中的元素。
至於原因可參考下面關於PriorityQueue的內部實現
如果需要按順序遍歷，請考慮使用 Arrays.sort(pq.toArray())。
注意6：可以在構造函數中指定如何排序。如：
PriorityQueue()
使用默認的初始容量（11）創建一個 PriorityQueue，並根據其自然順序來排序其元素（使用 Comparable）。
PriorityQueue(int initialCapacity)
使用指定的初始容量創建一個 PriorityQueue，並根據其自然順序來排序其元素（使用 Comparable）。
PriorityQueue(int initialCapacity, Comparator comparator)
使用指定的初始容量創建一個 PriorityQueue，並根據指定的比較器comparator來排序其元素。
注意7：此類及其迭代器實現了 Collection 和 Iterator 接口的所有可選 方法。
PriorityQueue的內部實現
PriorityQueue對元素采用的是堆排序，頭是按指定排序方式的最小元素。堆排序只能保證根是最大（最小），整個堆並不是有序的。
方法iterator()中提供的迭代器可能只是對整個數組的依次遍歷。也就只能保證數組的第一個元素是最小的。

package com.chenshuyi.data;

import java.util.Comparator;
import java.util.Iterator;
import java.util.PriorityQueue;
import java.util.Random;

//固定容量的優先隊列，模擬大頂堆，用於解決求topN小或 topk大的問題
@SuppressWarnings({ "unchecked", "rawtypes" })
public class TopKwithPriorityQueue<E extends Comparable> {
    private PriorityQueue<E> queue;
    private int K; // 堆的最大容量,即 topk,所以maxsize=k

    public TopKwithPriorityQueue(int maxSize) {
        if (maxSize <= 0)
            throw new IllegalArgumentException();
        this.K = maxSize;
        this.queue = new PriorityQueue(maxSize, new Comparator<E>() {
            public int compare(E o1, E o2) {
                return o1.compareTo(o2);
                // 生成最大堆使用o2-o1,生成最小堆使用o1-o2, 並修改 e.compareTo(peek) 比較規則return (o2.compareTo(o1));
            }
        });
    }

    public void add(E e) {
        if (queue.size() < K) { // 未達到最大容量，直接添加
            queue.add(e);
        } else { // 隊列已滿
            E peek = queue.peek(); // 取堆頂元素
            if (e.compareTo(peek) > 0) { // 將新元素與當前堆頂元素比較，保留較小的元素
                queue.poll();
                queue.add(e);
            }
        }
    }

    //    public List<E> sortedList() {
    //    List<E> list = new ArrayList<E>(queue); // 可以將整個優先隊列傳入 arraylist的構造方法做參數
    //    Collections.sort(list); // PriorityQueue本身的遍歷是無序的，最終需要對隊列中的元素進行排序
    //    return list;
    //    }

    public static void main(String[] args) {
        final TopKwithPriorityQueue pq = new TopKwithPriorityQueue(3); // 返回前k=10位
        Random random = new Random();
        int rNum = 0;
        System.out.println("100 個 0~999 之間的隨機數：-----------------------------------");
        for (int i = 1; i <= 20; i++) {
            rNum = random.nextInt(1000);
            System.out.print(rNum + ",");
            pq.add(rNum);
        }
        System.out.println("\n PriorityQueue 本身的遍歷是無序的：返回的top10 最小堆是：-----------------------------------");
        Iterable<Integer> iter = new Iterable<Integer>() {
            public Iterator<Integer> iterator() {
                return pq.queue.iterator();
            }
        };
        for (Integer item : iter) {
            System.out.print(item + ",");
        }
        System.out.println();
        System.out.println("PriorityQueue 排序后的遍歷：返回的top10 最小堆是：-----------------------------------");
        /*
         * for (Integer item : pq.sortedList()) { System.out.println(item); }
         */
        // 或者直接用內置的 poll() 方法，每次取隊首元素（堆頂的最大值）
        while (!pq.queue.isEmpty()) {
            System.out.print(pq.queue.poll() + ", ");
        }
    }
}

 

由於僅僅保存了K個數據，有調整最小堆的時間復雜度為O(lnK)，因此TOp K算法(問題)時間復雜度為O(nlnK)

堆排序算法的性能分析：

　　空間復雜度:o(1)；　

       堆調整一次的時間復雜度是O(logK)。所以，通過堆來解決top K 問題的時間復雜度是O(nlogK).

       其中，n為數據的個數,K為堆維護的數據的個數。

　　穩定性：不穩定