---
comments: true
---
# 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)$ ，非常耗時。
{ class="animation-figure" }
圖 8-6 走訪尋找最大的 k 個元素
!!! tip
當 $k = n$ 時，我們可以得到完整的有序序列，此時等價於“選擇排序”演算法。
## 8.3.2 方法二：排序
如圖 8-7 所示，我們可以先對陣列 `nums` 進行排序，再返回最右邊的 $k$ 個元素，時間複雜度為 $O(n \log n)$ 。
顯然，該方法“超額”完成任務了，因為我們只需找出最大的 $k$ 個元素即可，而不需要排序其他元素。
{ class="animation-figure" }
圖 8-7 排序尋找最大的 k 個元素
## 8.3.3 方法三：堆積
我們可以基於堆積更加高效地解決 Top-k 問題，流程如圖 8-8 所示。
1. 初始化一個小頂堆積，其堆積頂元素最小。
2. 先將陣列的前 $k$ 個元素依次入堆積。
3. 從第 $k + 1$ 個元素開始，若當前元素大於堆積頂元素，則將堆積頂元素出堆積，並將當前元素入堆積。
4. 走訪完成後，堆積中儲存的就是最大的 $k$ 個元素。
=== "<1>"
{ class="animation-figure" }
=== "<2>"
{ class="animation-figure" }
=== "<3>"
{ class="animation-figure" }
=== "<4>"
{ class="animation-figure" }
=== "<5>"
{ class="animation-figure" }
=== "<6>"
{ class="animation-figure" }
=== "<7>"
{ class="animation-figure" }
=== "<8>"
{ class="animation-figure" }
=== "<9>"
{ class="animation-figure" }
圖 8-8 基於堆積尋找最大的 k 個元素
示例程式碼如下：
=== "Python"
```python title="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
```
=== "C++"
```cpp title="top_k.cpp"
/* 基於堆積查詢陣列中最大的 k 個元素 */
priority_queue, greater> topKHeap(vector &nums, int k) {
// 初始化小頂堆積
priority_queue, greater> 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;
}
```
=== "Java"
```java title="top_k.java"
/* 基於堆積查詢陣列中最大的 k 個元素 */
Queue topKHeap(int[] nums, int k) {
// 初始化小頂堆積
Queue heap = new PriorityQueue();
// 將陣列的前 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;
}
```
=== "C#"
```csharp title="top_k.cs"
/* 基於堆積查詢陣列中最大的 k 個元素 */
PriorityQueue TopKHeap(int[] nums, int k) {
// 初始化小頂堆積
PriorityQueue 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;
}
```
=== "Go"
```go title="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
}
```
=== "Swift"
```swift title="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
}
```
=== "JS"
```javascript title="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);
}
```
=== "TS"
```typescript title="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);
}
```
=== "Dart"
```dart title="top_k.dart"
/* 基於堆積查詢陣列中最大的 k 個元素 */
MinHeap topKHeap(List 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;
}
```
=== "Rust"
```rust title="top_k.rs"
/* 基於堆積查詢陣列中最大的 k 個元素 */
fn top_k_heap(nums: Vec, k: usize) -> BinaryHeap> {
// BinaryHeap 是大頂堆積，使用 Reverse 將元素取反，從而實現小頂堆積
let mut heap = BinaryHeap::>::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
}
```
=== "C"
```c title="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;
}
```
=== "Kotlin"
```kotlin title="top_k.kt"
/* 基於堆積查詢陣列中最大的 k 個元素 */
fun topKHeap(nums: IntArray, k: Int): Queue {
// 初始化小頂堆積
val heap = PriorityQueue()
// 將陣列的前 k 個元素入堆積
for (i in 0.. heap.peek()) {
heap.poll()
heap.offer(nums[i])
}
}
return heap
}
```
=== "Ruby"
```ruby title="top_k.rb"
[class]{}-[func]{top_k_heap}
```
=== "Zig"
```zig title="top_k.zig"
[class]{}-[func]{topKHeap}
```
??? pythontutor "視覺化執行"
總共執行了 $n$ 輪入堆積和出堆積，堆積的最大長度為 $k$ ，因此時間複雜度為 $O(n \log k)$ 。該方法的效率很高，當 $k$ 較小時，時間複雜度趨向 $O(n)$ ；當 $k$ 較大時，時間複雜度不會超過 $O(n \log n)$ 。
另外，該方法適用於動態資料流的使用場景。在不斷加入資料時，我們可以持續維護堆積內的元素，從而實現最大的 $k$ 個元素的動態更新。