TopK問題是指從大量資料（源資料）中獲取最大（或最小）的K個數據。

TopK問題是個很常見的問題：例如學校要從全校學生中找到成績最高的500名學生，再例如某搜尋引擎要統計每天的100條搜尋次數最多的關鍵詞。

對於這個問題，解決方法有很多：

方法一：對源資料中所有資料進行排序，取出前K個數據，就是TopK。

但是當資料量很大時，只需要k個最大的數，整體排序很耗時，效率不高。

方法二：維護一個K長度的陣列a[]，先讀取源資料中的前K個放入陣列，對該陣列進行升序排序，再依次讀取源資料第K個以後的資料，和陣列中最小的元素（a[0]）比較，如果小於a[0]直接pass，大於的話，就丟棄最小的元素a[0]，利用二分法找到其位置，然後該位置前的陣列元素整體向前移位，直到源資料讀取結束。

這比方法一效率會有很大的提高，但是當K的值較大的時候，長度為K的資料整體移位，也是非常耗時的。

對於這種問題，效率比較高的解決方法是使用最小堆。

最小堆（小根堆）是一種資料結構，它首先是一顆完全二叉樹，並且，它所有父節點的值小於或等於兩個子節點的值。

最小堆的儲存結構（物理結構）實際上是一個陣列。如下圖：

堆有幾個重要操作：

BuildHeap：將普通陣列轉換成堆，轉換完成後，陣列就符合堆的特性：所有父節點的值小於或等於兩個子節點的值。

Heapify(int i)：當元素i的左右子樹都是小根堆時，通過Heapify讓i元素下降到適當的位置，以符合堆的性質。

回到上面的取TopK問題上，用最小堆的解決方法就是：先去源資料中的K個元素放到一個長度為K的陣列中去，再把陣列轉換成最小堆。再依次取源資料中的K個之後的資料和堆的根節點（陣列的第一個元素）比較，根據最小堆的性質，根節點一定是堆中最小的元素，如果小於它，則直接pass，大於的話，就替換掉跟元素，並對根元素進行Heapify，直到源資料遍歷結束。

最小堆的實現：

1. publicclass MinHeap  
2. {  
3.     // 堆的儲存結構 - 陣列
4.     privateint[] data;  
5.     // 將一個數組傳入構造方法，並轉換成一個小根堆
6.     public
    MinHeap(int[] data)  
7.     {  
8.         this.data = data;  
9.         buildHeap();  
10.     }  
11.     // 將陣列轉換成最小堆
12.     privatevoid buildHeap()  
13.     {  
14.         // 完全二叉樹只有陣列下標小於或等於 (data.length) / 2 - 1 的元素有孩子結點，遍歷這些結點。
15.         // *比如上面的圖中，陣列有10個元素， (data.length) / 2 - 1的值為4，a[4]有孩子結點，但a[5]沒有*
16.         for (int i = (data.length) / 2 - 1; i >= 0; i--)   
17.         {  
18.             // 對有孩子結點的元素heapify
19.             heapify(i);  
20.         }  
21.     }  
22.     privatevoid heapify(int i)  
23.     {  
24.         // 獲取左右結點的陣列下標
25.         int l = left(i);    
26.         int r = right(i);  
27.         // 這是一個臨時變數，表示 跟結點、左結點、右結點中最小的值的結點的下標
28.         int smallest = i;  
29.         // 存在左結點，且左結點的值小於根結點的值
30.         if (l < data.length && data[l] < data[i])    
31.             smallest = l;    
32.         // 存在右結點，且右結點的值小於以上比較的較小值
33.         if (r < data.length && data[r] < data[smallest])    
34.             smallest = r;    
35.         // 左右結點的值都大於根節點，直接return，不做任何操作
36.         if (i == smallest)    
37.             return;    
38.         // 交換根節點和左右結點中最小的那個值，把根節點的值替換下去
39.         swap(i, smallest);  
40.         // 由於替換後左右子樹會被影響，所以要對受影響的子樹再進行heapify
41.         heapify(smallest);  
42.     }  
43.     // 獲取右結點的陣列下標
44.     privateint right(int i)  
45.     {    
46.         return (i + 1) << 1;    
47.     }     
48.     // 獲取左結點的陣列下標
49.     privateint left(int i)   
50.     {    
51.         return ((i + 1) << 1) - 1;    
52.     }  
53.     // 交換元素位置
54.     privatevoid swap(int i, int j)   
55.     {    
56.         int tmp = data[i];    
57.         data[i] = data[j];    
58.         data[j] = tmp;    
59.     }  
60.     // 獲取對中的最小的元素，根元素
61.     publicint getRoot()  
62.     {  
63.             return data[0];  
64.     }  
65.     // 替換根元素，並重新heapify
66.     publicvoid setRoot(int root)  
67.     {  
68.         data[0] = root;  
69.         heapify(0);  
70.     }  
71. }  

利用最小堆獲取TopK：

1. publicclass TopK  
2. {  
3.     publicstaticvoid main(String[] args)  
4.     {  
5.         // 源資料
6.         int[] data = {56,275,12,6,45,478,41,1236,456,12,546,45};  
7. // 獲取Top5
8.         int[] top5 = topK(data, 5);  
9.         for(int i=0;i<5;i++)  
10.         {  
11.             System.out.println(top5[i]);  
12.         }  
13.     }  
14.     // 從data陣列中獲取最大的k個數
15.     privatestaticint[] topK(int[] data,int k)  
16.     {  
17.         // 先取K個元素放入一個數組topk中
18.         int[] topk = newint[k];   
19.         for(int i = 0;i< k;i++)  
20.         {  
21.             topk[i] = data[i];  
22. 相關推薦

    Java最小堆解決TopK問題

    TopK問題是指從大量資料（源資料）中獲取最大（或最小）的K個數據。 TopK問題是個很常見的問題：例如學校要從全校學生中找到成績最高的500名學生，再例如某搜尋引擎要統計每天的100條搜尋次數最多的關鍵詞。 對於這個問題，解決方法有很多： 方法一：對源資料中所有資料進行排序，取出前K個

    最小堆解決TopK 問題

    TopK問題是指從大量資料（源資料）中獲取最大（或最小）的K個數據。 解決方法一、 對源資料中所有資料進行排序，取出前K個數據，就是TopK。 解決方法二 維護一個K長度的陣列a[]，先讀取源資料中的前K個放入陣列，對該陣列進行升序排序，再依次讀取源資料

    最小堆解決Top K問題

    問題描述： 有一組資料n個，要求取出這組資料中最大的K個值。 對於這個問題，解法有很多中。比如排序及部分排序，不過效率最高的要數最小堆，它的時間複雜度為O(nlogk)。 解題思路： 取出

    最小堆解決 Top K 問題

    Top K 問題指從一組資料中選出最大的K個數。常見的例子有：熱門搜尋前10，最常聽的20首歌等。 對於這類問題，可能我們會首先想到先對這組資料進行排序，再選取前K個數。雖然這能解決問題，但效率不高，因為我們只需要部分有序，它卻對整體進行了排序。最小堆是解決To

    java最小堆實現優先權佇列和求最大的n個數問題

    堆在實現優先權佇列和求最大最小的n個數問題上，有著莫大的優勢！ 對於最大堆和最小堆的定義此處不再贅述，課參考網上文章：http://blog.csdn.net/genios/article/details/8157031 本文主要是對最小堆進行實現和應用，僅供新手參考。

    scala寫算法-用小根堆解決topK

    app unit roo ast atm mark 構建 操作 mnt topK問題是指從大量數據中獲取最大(或最小)的k個數,比如從全校學生中尋找成績最高的500名學生等等. 本問題可采用小根堆解決.思路是先把源數據中的前k個數放入堆中,然後構建堆,使其保持堆序(可以簡單

    堆排序 最大堆 最小堆 Java實現

    堆排序 最大堆 最小堆 Java 堆排序啊，其實是一種數據結構，二叉樹，二叉樹分為是滿二叉樹和完全二叉樹。一棵深度為 k，且有 2k - 1 個節點稱之為滿二叉樹，完全二叉樹：深度為 k，有 n 個節點的二叉樹，當且僅當其每一個節點都與深度為 k 的滿二叉樹中序號為 1 至 n 的節點對應時，

    Java heap的實現 最小堆的實現 程式碼簡潔

    public class HeapMin { private int[] Heap; private int maxsize; private int size; public HeapMin(int max) { maxsize = max; Heap

    最小堆的java實現

    <pre name="code" class="plain">//從大牛那裡轉來的最小堆的動態新增與刪除，以後好好看 public class Node {/** * 堆結點 * 節點資料型別為：int */private int iDate;public No

    用鄰接表和最小堆實現Dijkstra 最短路演算法 （Java實現）

    演算法特點： 迪科斯徹演算法使用了廣度優先搜尋解決賦權有向圖或者無向圖的單源最短路徑問題，演算法最終得到一個最短路徑樹。該演算法常用於路由演算法或者作為其他圖演算法的一個子模組。 演算法的思路 Dijkstra演算法採用的是一種貪心的策略，宣告一個數

    STL -最大最小堆 priority_queue

    常用函數 cnblogs () mes color pre pac clas 常用 //添加頭文件#include<queue> using namespace std; 最大堆實現： 優先輸出大數據 priority_queue<Type, Cont

    最小堆的建立 插入 與刪除

    操作 2個 是把 完全二叉樹 bsp 通過 函數 問題 .... 堆是完全二叉樹，完全二叉樹最大的特點就是 把數據儲存在數組裏 通過父子結點的關系來做 不用實際建樹 parent=leftchild/2； leftchild=2*parent 右就加1這兒指的是序號關

    libevent(二)尾隊列 && 最小堆

    結構 pty signed don eap main .com first 存儲 本文主要研究libevent中用來存儲事件的兩個結構體。 尾隊列 具體定義位於queue.h中。 #define TAILQ_HEAD(name, type)

    c++用priority_queue實現最小堆，並求解最大的n個數

    輸出 return bool rand cto and gre main 最小堆 1 //c++用priority_queue實現最小堆，並求解很多數中的最大的n個數 2 #include <iostream> 3 #include <queue&

    利用最小堆找出10億個數中最大的10000個數

    AS 如果 算法 最小值 分治 但是 空間 找出最大值 根節點 最小堆 最小堆是一種完全二叉樹，特點是根節點比兩個子節點都小（或者根節點比子節點都大） 過程 先找10000個數構建最小堆 依次遍歷10億個數，如果比最小堆的最小值大，則替換這個最小值，並重新構建最小堆 最後

    最大堆和最小堆

    new clas 代碼 轉移 break OS 分支 -s std 參考：https://blog.csdn.net/guoweimelon/article/details/50904346 一、堆樹的定義 堆樹的定義如下： （1）堆樹是一顆完全二叉樹； （2）

    最小堆

    pre bsp != class build code amp void IV int a[Max],n; void build(int t) { int Min=a[t]; int l=2*t,k=t; int r=2*t+1;

    2018中國大學生程序設計競賽 - 網絡選拔賽 1001 - Buy and Resell 【優先隊列維護最小堆+貪心】

    input 不出 def pop earch 無限 math 上交 要去 題目傳送門：http://acm.hdu.edu.cn/showproblem.php?pid=6438 Buy and Resell Time Limit: 2000/1000 MS (Java/O

    leetcode703+第k大的數字，最小堆使用

    https://leetcode.com/problems/kth-largest-element-in-a-stream/description/ class KthLargest { public: int size; priority_queue<int, vec

    堆樹（最大堆 最小堆）詳解

    分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！