今天和大家一塊學習下面試中常見的兩個關於堆的面試題，第一：求K個最大值；第二：求中值元素。演算法和資料結構算是筆者的死穴了。
一、求前K個最大的值

首先能想到的是使用Arrays.sort()進行排序後取前K個值即可，效率是O(N*log2^N)。
其次可以進行迴圈選擇K次，每次都從剩下的資料中選擇最大值，效率是O(N*K)。但若K值大於log2^(N)，其效率還不如完全排序。
況且上述方法並沒有考慮到資料的動態性，當資料是動態新增的情況下，如何維護前K個值呢？
此時，維護一個長度為K的陣列，陣列中的K個位置填充我們需要的前K個數值，面對源源不斷的資料，都先找到陣列中的最小值，將新來的資料和最小值進行比較，若是大於最小值，則將最小值替換成新數值。那麼問題來了，每來一個數值都需找到陣列中的最小值進行K次比較，會不會略顯繁瑣呢？
上述方法也僅僅是青銅，真正的王者上場了。解決方法是用最小堆互為這K個數值。最小堆，顧名思義，根節點永遠是最小的數值，那麼新來的元素僅需和根節點進行比較即可：小於根節點則pass，否則新值取代根節點，並且向下調整堆，調整的效率為O(log2^K)，這樣總體的效率是O(N*log2^K)，是不是比上面的方法高效了很多了呢？
Talk is cheap，so codes follow.

前方高能程式碼

class TopK<E> {

  private PriorityQueue<E> p;
  private int k;

  /**
   * 構造器.
   */
  public TopK(int k) {
    this.k = k;
    this.p = new PriorityQueue<>(k);
  }

  /**
   * 新增集合中的所有元素.
   */
  public void addAll(Collection<? extends E> c) {
    for (E e : c) {
      add(e);
    }
  }

  public
 
 void add(E e) {
    // 堆未滿，直接加入
    if (p.size() < k) {
      p.add(e);
      return;
    }
    Comparable<? super E> heap = (Comparable<? super E>) p.peek();
    //新來的小於根節點，不做什麼東西
    if (heap.compareTo(e) > 0) {
      return;
    }
    // 新來的大於根節點，把根節點拋棄，加入新來的數值
    p.poll();
    p.add(e);
  }

  public
 
 <T> T[] toArray(T[] a) {
    return p.toArray(a);
  }

  /**
   * 返回第K大的值.
   */
  public E getKth() {
    return p.peek();
  }
}
/**
 * Created by Mollychin on 2018/5/28.
 */
public class TopKTest {

  public static void main(String[] args) {
    TopK<Integer> top5 = new TopK<>(5);
    List<Integer> integers = Arrays
        .asList(new Integer[]{100, 2, 1, 3, 66, 32, 88, 4, 45, 87, 99, 34, 554, 55, 12, 32});
    top5.addAll(integers);
    System.out.println("保留5個最大的元素，輸出為：");
    System.out.println(Arrays.toString(top5.toArray(new Integer[0])));
    System.out.println(top5.getKth());
  }
}

輸出結果為：

保留5個最大的元素，輸出為：
[87, 99, 88, 100, 554]
87

二、求中值

一個簡單的思路是排序後取中間的那個值即可，效率是O(N*log2^N)。
但上述方法僅適用於全部數值已知，那麼面對動態新增的數值呢？
可以使用兩個堆，最大堆和最小堆。下面是思路：

1. 假設中值是z，則最大堆維護的是小於等於z的數值，最小堆維護的是大於等於z的數值。但是呢，兩個堆都不包含m。
2. 當有新的數值n到達的時候，n與z進行比較，按照步驟一的約定將n加入最大堆或者最小堆中。
3. 走完第二步後，若最小堆和最大堆的元素個數相差2個或者2個以上，則將m加入元素較少的堆中，然後從元素較多的堆中的根節點移除並且賦值給z。
   4.下面我們來看下程式碼實現。

/**
 * Created by Mollychin on 2018/5/28.
 */
public class MedianTest {

  public static void main(String[] args) {
    Median<Integer> integerMedian = new Median<>();
    List<Integer> integers = Arrays
        .asList(new Integer[]{100, 2, 1, 3, 66, 32, 88, 4, 45, 87, 99, 34, 554, 55, 12, 32});
    integerMedian.addAll(integers);
    System.out.println("中位數是："+integerMedian.getM());
  }

}

class Median<E> {

  private PriorityQueue<E> minHeap;
  private PriorityQueue<E> maxHeap;
  private E m;

  public Median() {
    this.minHeap = new PriorityQueue<>();
    this.maxHeap = new PriorityQueue<>();
  }

  private int compare(E e, E m) {
    Comparable<? super E> comparable = (Comparable<? super E>) e;
    return comparable.compareTo(m);
  }

  public void add(E e) {
    // e為第一個數值時
    if (m == null) {
      m = e;
      return;
    }
    if (compare(e, m) <= 0) {
      // 新來的數值小於等於原中值時則加在最大堆裡
      maxHeap.add(e);
    } else {
      minHeap.add(e);
    }
    if (minHeap.size() - maxHeap.size() >= 2) {
      maxHeap.add(this.m);
      this.m = minHeap.poll();
    } else if (maxHeap.size() - minHeap.size() >= 2) {
      minHeap.add(this.m);
      this.m = maxHeap.poll();
    }
  }

  public void addAll(Collection<? extends E> c) {
    for (E e : c) {
      add(e);
    }
  }

  public E getM() {
    return m;
  }
}

中位數是：45

總結
相比較排序，使用堆的效率可以大大提高，而且還可以應對資料來源源不斷到來的情景，可以給出實時滿意的結果。這大概就是演算法和資料結構的藝術吧（逃