跳轉至

8.3   Top-k 問題

Question

給定一個長度為 \(n\) 的無序陣列 nums ，請返回陣列中最大的 \(k\) 個元素。

對於該問題，我們先介紹兩種思路比較直接的解法，再介紹效率更高的堆積解法。

8.3.1   方法一：走訪選擇

我們可以進行圖 8-6 所示的 \(k\) 輪走訪，分別在每輪中提取第 \(1\)、\(2\)、\(\dots\)、\(k\) 大的元素，時間複雜度為 \(O(nk)\) 。

此方法只適用於 \(k \ll n\) 的情況，因為當 \(k\) 與 \(n\) 比較接近時，其時間複雜度趨向於 \(O(n^2)\) ，非常耗時。

走訪尋找最大的 k 個元素

圖 8-6   走訪尋找最大的 k 個元素

Tip

當 \(k = n\) 時，我們可以得到完整的有序序列，此時等價於“選擇排序”演算法。

8.3.2   方法二：排序

如圖 8-7 所示，我們可以先對陣列 nums 進行排序，再返回最右邊的 \(k\) 個元素，時間複雜度為 \(O(n \log n)\) 。

顯然，該方法“超額”完成任務了，因為我們只需找出最大的 \(k\) 個元素即可，而不需要排序其他元素。

排序尋找最大的 k 個元素

圖 8-7   排序尋找最大的 k 個元素

8.3.3   方法三：堆積

我們可以基於堆積更加高效地解決 Top-k 問題，流程如圖 8-8 所示。

  1. 初始化一個小頂堆積，其堆積頂元素最小。
  2. 先將陣列的前 \(k\) 個元素依次入堆積。
  3. 從第 \(k + 1\) 個元素開始，若當前元素大於堆積頂元素，則將堆積頂元素出堆積，並將當前元素入堆積。
  4. 走訪完成後，堆積中儲存的就是最大的 \(k\) 個元素。

基於堆積尋找最大的 k 個元素

top_k_heap_step2

top_k_heap_step3

top_k_heap_step4

top_k_heap_step5

top_k_heap_step6

top_k_heap_step7

top_k_heap_step8

top_k_heap_step9

圖 8-8   基於堆積尋找最大的 k 個元素

示例程式碼如下：

top_k.py
def top_k_heap(nums: list[int], k: int) -> list[int]:
    """基於堆積查詢陣列中最大的 k 個元素"""
    # 初始化小頂堆積
    heap = []
    # 將陣列的前 k 個元素入堆積
    for i in range(k):
        heapq.heappush(heap, nums[i])
    # 從第 k+1 個元素開始，保持堆積的長度為 k
    for i in range(k, len(nums)):
        # 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
        if nums[i] > heap[0]:
            heapq.heappop(heap)
            heapq.heappush(heap, nums[i])
    return heap
top_k.cpp
/* 基於堆積查詢陣列中最大的 k 個元素 */
priority_queue<int, vector<int>, greater<int>> topKHeap(vector<int> &nums, int k) {
    // 初始化小頂堆積
    priority_queue<int, vector<int>, greater<int>> heap;
    // 將陣列的前 k 個元素入堆積
    for (int i = 0; i < k; i++) {
        heap.push(nums[i]);
    }
    // 從第 k+1 個元素開始，保持堆積的長度為 k
    for (int i = k; i < nums.size(); i++) {
        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
        if (nums[i] > heap.top()) {
            heap.pop();
            heap.push(nums[i]);
        }
    }
    return heap;
}
top_k.java
/* 基於堆積查詢陣列中最大的 k 個元素 */
Queue<Integer> topKHeap(int[] nums, int k) {
    // 初始化小頂堆積
    Queue<Integer> heap = new PriorityQueue<Integer>();
    // 將陣列的前 k 個元素入堆積
    for (int i = 0; i < k; i++) {
        heap.offer(nums[i]);
    }
    // 從第 k+1 個元素開始，保持堆積的長度為 k
    for (int i = k; i < nums.length; i++) {
        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
        if (nums[i] > heap.peek()) {
            heap.poll();
            heap.offer(nums[i]);
        }
    }
    return heap;
}
top_k.cs
/* 基於堆積查詢陣列中最大的 k 個元素 */
PriorityQueue<int, int> TopKHeap(int[] nums, int k) {
    // 初始化小頂堆積
    PriorityQueue<int, int> heap = new();
    // 將陣列的前 k 個元素入堆積
    for (int i = 0; i < k; i++) {
        heap.Enqueue(nums[i], nums[i]);
    }
    // 從第 k+1 個元素開始，保持堆積的長度為 k
    for (int i = k; i < nums.Length; i++) {
        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
        if (nums[i] > heap.Peek()) {
            heap.Dequeue();
            heap.Enqueue(nums[i], nums[i]);
        }
    }
    return heap;
}
top_k.go
/* 基於堆積查詢陣列中最大的 k 個元素 */
func topKHeap(nums []int, k int) *minHeap {
    // 初始化小頂堆積
    h := &minHeap{}
    heap.Init(h)
    // 將陣列的前 k 個元素入堆積
    for i := 0; i < k; i++ {
        heap.Push(h, nums[i])
    }
    // 從第 k+1 個元素開始，保持堆積的長度為 k
    for i := k; i < len(nums); i++ {
        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
        if nums[i] > h.Top().(int) {
            heap.Pop(h)
            heap.Push(h, nums[i])
        }
    }
    return h
}
top_k.swift
/* 基於堆積查詢陣列中最大的 k 個元素 */
func topKHeap(nums: [Int], k: Int) -> [Int] {
    // 初始化一個小頂堆積，並將前 k 個元素建堆積
    var heap = Heap(nums.prefix(k))
    // 從第 k+1 個元素開始，保持堆積的長度為 k
    for i in nums.indices.dropFirst(k) {
        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
        if nums[i] > heap.min()! {
            _ = heap.removeMin()
            heap.insert(nums[i])
        }
    }
    return heap.unordered
}
top_k.js
/* 元素入堆積 */
function pushMinHeap(maxHeap, val) {
    // 元素取反
    maxHeap.push(-val);
}

/* 元素出堆積 */
function popMinHeap(maxHeap) {
    // 元素取反
    return -maxHeap.pop();
}

/* 訪問堆積頂元素 */
function peekMinHeap(maxHeap) {
    // 元素取反
    return -maxHeap.peek();
}

/* 取出堆積中元素 */
function getMinHeap(maxHeap) {
    // 元素取反
    return maxHeap.getMaxHeap().map((num) => -num);
}

/* 基於堆積查詢陣列中最大的 k 個元素 */
function topKHeap(nums, k) {
    // 初始化小頂堆積
    // 請注意：我們將堆積中所有元素取反，從而用大頂堆積來模擬小頂堆積
    const maxHeap = new MaxHeap([]);
    // 將陣列的前 k 個元素入堆積
    for (let i = 0; i < k; i++) {
        pushMinHeap(maxHeap, nums[i]);
    }
    // 從第 k+1 個元素開始，保持堆積的長度為 k
    for (let i = k; i < nums.length; i++) {
        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
        if (nums[i] > peekMinHeap(maxHeap)) {
            popMinHeap(maxHeap);
            pushMinHeap(maxHeap, nums[i]);
        }
    }
    // 返回堆積中元素
    return getMinHeap(maxHeap);
}
top_k.ts
/* 元素入堆積 */
function pushMinHeap(maxHeap: MaxHeap, val: number): void {
    // 元素取反
    maxHeap.push(-val);
}

/* 元素出堆積 */
function popMinHeap(maxHeap: MaxHeap): number {
    // 元素取反
    return -maxHeap.pop();
}

/* 訪問堆積頂元素 */
function peekMinHeap(maxHeap: MaxHeap): number {
    // 元素取反
    return -maxHeap.peek();
}

/* 取出堆積中元素 */
function getMinHeap(maxHeap: MaxHeap): number[] {
    // 元素取反
    return maxHeap.getMaxHeap().map((num: number) => -num);
}

/* 基於堆積查詢陣列中最大的 k 個元素 */
function topKHeap(nums: number[], k: number): number[] {
    // 初始化小頂堆積
    // 請注意：我們將堆積中所有元素取反，從而用大頂堆積來模擬小頂堆積
    const maxHeap = new MaxHeap([]);
    // 將陣列的前 k 個元素入堆積
    for (let i = 0; i < k; i++) {
        pushMinHeap(maxHeap, nums[i]);
    }
    // 從第 k+1 個元素開始，保持堆積的長度為 k
    for (let i = k; i < nums.length; i++) {
        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
        if (nums[i] > peekMinHeap(maxHeap)) {
            popMinHeap(maxHeap);
            pushMinHeap(maxHeap, nums[i]);
        }
    }
    // 返回堆積中元素
    return getMinHeap(maxHeap);
}
top_k.dart
/* 基於堆積查詢陣列中最大的 k 個元素 */
MinHeap topKHeap(List<int> nums, int k) {
  // 初始化小頂堆積，將陣列的前 k 個元素入堆積
  MinHeap heap = MinHeap(nums.sublist(0, k));
  // 從第 k+1 個元素開始，保持堆積的長度為 k
  for (int i = k; i < nums.length; i++) {
    // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
    if (nums[i] > heap.peek()) {
      heap.pop();
      heap.push(nums[i]);
    }
  }
  return heap;
}
top_k.rs
/* 基於堆積查詢陣列中最大的 k 個元素 */
fn top_k_heap(nums: Vec<i32>, k: usize) -> BinaryHeap<Reverse<i32>> {
    // BinaryHeap 是大頂堆積，使用 Reverse 將元素取反，從而實現小頂堆積
    let mut heap = BinaryHeap::<Reverse<i32>>::new();
    // 將陣列的前 k 個元素入堆積
    for &num in nums.iter().take(k) {
        heap.push(Reverse(num));
    }
    // 從第 k+1 個元素開始，保持堆積的長度為 k
    for &num in nums.iter().skip(k) {
        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
        if num > heap.peek().unwrap().0 {
            heap.pop();
            heap.push(Reverse(num));
        }
    }
    heap
}
top_k.c
/* 元素入堆積 */
void pushMinHeap(MaxHeap *maxHeap, int val) {
    // 元素取反
    push(maxHeap, -val);
}

/* 元素出堆積 */
int popMinHeap(MaxHeap *maxHeap) {
    // 元素取反
    return -pop(maxHeap);
}

/* 訪問堆積頂元素 */
int peekMinHeap(MaxHeap *maxHeap) {
    // 元素取反
    return -peek(maxHeap);
}

/* 取出堆積中元素 */
int *getMinHeap(MaxHeap *maxHeap) {
    // 將堆積中所有元素取反並存入 res 陣列
    int *res = (int *)malloc(maxHeap->size * sizeof(int));
    for (int i = 0; i < maxHeap->size; i++) {
        res[i] = -maxHeap->data[i];
    }
    return res;
}

/* 取出堆積中元素 */
int *getMinHeap(MaxHeap *maxHeap) {
    // 將堆積中所有元素取反並存入 res 陣列
    int *res = (int *)malloc(maxHeap->size * sizeof(int));
    for (int i = 0; i < maxHeap->size; i++) {
        res[i] = -maxHeap->data[i];
    }
    return res;
}

// 基於堆積查詢陣列中最大的 k 個元素的函式
int *topKHeap(int *nums, int sizeNums, int k) {
    // 初始化小頂堆積
    // 請注意：我們將堆積中所有元素取反，從而用大頂堆積來模擬小頂堆積
    int *empty = (int *)malloc(0);
    MaxHeap *maxHeap = newMaxHeap(empty, 0);
    // 將陣列的前 k 個元素入堆積
    for (int i = 0; i < k; i++) {
        pushMinHeap(maxHeap, nums[i]);
    }
    // 從第 k+1 個元素開始，保持堆積的長度為 k
    for (int i = k; i < sizeNums; i++) {
        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
        if (nums[i] > peekMinHeap(maxHeap)) {
            popMinHeap(maxHeap);
            pushMinHeap(maxHeap, nums[i]);
        }
    }
    int *res = getMinHeap(maxHeap);
    // 釋放記憶體
    delMaxHeap(maxHeap);
    return res;
}
top_k.kt
/* 基於堆積查詢陣列中最大的 k 個元素 */
fun topKHeap(nums: IntArray, k: Int): Queue<Int> {
    // 初始化小頂堆積
    val heap = PriorityQueue<Int>()
    // 將陣列的前 k 個元素入堆積
    for (i in 0..<k) {
        heap.offer(nums[i])
    }
    // 從第 k+1 個元素開始，保持堆積的長度為 k
    for (i in k..<nums.size) {
        // 若當前元素大於堆積頂元素，則將堆積頂元素出堆積、當前元素入堆積
        if (nums[i] > heap.peek()) {
            heap.poll()
            heap.offer(nums[i])
        }
    }
    return heap
}
top_k.rb
[class]{}-[func]{top_k_heap}
top_k.zig
[class]{}-[func]{topKHeap}
視覺化執行

總共執行了 \(n\) 輪入堆積和出堆積，堆積的最大長度為 \(k\) ，因此時間複雜度為 \(O(n \log k)\) 。該方法的效率很高，當 \(k\) 較小時，時間複雜度趨向 \(O(n)\) ；當 \(k\) 較大時，時間複雜度不會超過 \(O(n \log n)\) 。

另外，該方法適用於動態資料流的使用場景。在不斷加入資料時，我們可以持續維護堆積內的元素，從而實現最大的 \(k\) 個元素的動態更新。