1. 程式人生 > >Java最小堆解決TopK問題

Java最小堆解決TopK問題

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];