面試題：求第K大元素（topK）[加強版]

在原來基礎上增長了算法E。

1、引言

​ 這就是相似求Top（K）問題，什麼意思呢？怎麼在無序數組中找到第幾（K）大元素？咱們這裏不考慮海量數據，能裝入內存。

2、普通算法

算法A：

將數組中的元素升序排序，找到數組下標k-1的元素便可。這是你們最容易想到的方法，若是使用簡單排序算法，時間複雜度爲O(n^2)。

算法B:

1. 第一步：初始化長度爲K的一個數組，先讀入K個元素，將元素降序排序（升序也能夠），這時候第K大元素就在最後一個。
2. 第二步：讀入下一個元素就與已排序的第K大元素比較，若是大於，則將當前的第K大元素刪掉，並將此元素放到前K-1個正確的位置上（這裏就是簡單的插入排序了。不瞭解插入排序的朋友能夠看這裏圖解選擇排序與插入排序）。
3. 時間複雜度：第一步採用普通排序算法時間複雜度是O(k^2)；第二步：(N-k)*(k-1) = Nk-k^2+k。因此算法B的時間複雜度爲O(NK)。當k=N/2（向下取整）時，時間複雜度仍是O(n^2)。

其實求第K大問題，也能夠求反，即求第N-k+1小問題。這是等價的。因此當K=N/2時，是最難的地方，但也頗有趣，這時候的K對應的值就是中位數。

3、較好算法

算法C：

1. 算法思想：將數據讀入一個數組，對數組進行buildHeap(咱們這裏構建大頂堆)，以後對堆進行K次deleteMax操做，第K次的結果就是咱們須要的值。（由於是大頂堆，因此數據從大到小排了序，堆排序之後會詳細說）。

2. 如今咱們來解決上節遺留的問題，爲何buildHeap是線性的？不熟悉堆的能夠看一下 圖解優先隊列（堆）。咱們先來看看代碼實現。

   public PriorityQueue(T[] items) {
          //當前堆中的元素個數
          currentSize = items.length;
          //可自行實現聲明
          array = (T[]) new Comparable[currentSize +1];
          int i = 1;
          for (T item : items){
              array[i++] = item;
          }
          buildHeap();
      }
   
   private void buildHeap() {
          for (int i = currentSize / 2; i > 0; i--){
              //堆的下濾方法，可參考上面的連接
              percolateDown(i);
          }
      }
   

圖中初始化的是一顆無序樹，通過7次percolateDown後，獲得一個大頂堆。從圖中能夠看到，共有9條虛線，每一條對應於2次比較，總共18次比較。爲了肯定buildHeap的時間界，咱們須要統計虛線的條數，這能夠經過計算堆中全部節點的高度和獲得，它是虛線的最大條數。該和是O(N)。

定理：包含2^h+1-1個節點、高爲h的理想二叉樹（滿二叉樹）的節點的高度的和是2^h+1-1-（h+1）。

1. 什麼叫滿二叉樹？滿二叉樹是徹底填滿的二叉樹，最後一層都是填滿的，如圖中所示。徹底二叉樹，是除最後一層之外都是填滿的，最後一層外也必須從左到右依次填入，就是上一篇中說的堆的結構。滿二叉樹必定是徹底二叉樹，徹底二叉樹不必定是滿二叉樹。

2. 證實定理：

   容易看出，滿二叉樹中，高度爲h上，有1個節點；高度h-1上2個節點，高度h-2上有2^2個節點及通常在高度h-i上的2ⁱ個節點組成。
   

方程兩邊乘以2獲得：

兩式相減獲得：

因此定理得證。由於堆由徹底二叉樹構成，因此堆的節點數在2^h和2^h+1之間，因此意味着這個和是O(N)。因此buildHeap是線性的。因此算法C的時間複雜度是：初始化數組爲O(N)，buildHeap爲O(N)，K次deleeMax須要O(klogN)，因此總的時間複雜度是：O(N+N+klogN)=O(N+klogN)，若是K爲N/2時，運行時間是O(NlogN)。

算法D：

1. 算法思想：咱們採用算法B的思想，只是咱們這裏構建一個節點數爲K的小頂堆，只要下一個數比根節點大，就刪除根節點，並將這個數進行下濾操做。因此算法最終的第K大數就是根節點的數。
2. 時間複雜度：對K個數進行buildHeap是O(k)，最壞狀況下假設剩下的N-k個數都要進入堆中進行下濾操做，總的須要O(k+(N-k)logk)。若是K爲N/2，則須要O(NlogN)。

算法E：快速選擇

參考快速排序及其優化，使用快速排序的思想，進行一點點改動。

• 算法思想：

1. 若是S中元素個數是1，那麼k=1並將S中的元素返回。若是正在使用小數組的截止方法且|S|<=CUTOFF，則將S排序並返回第K個最大元素
2. 選取一個S中的元素v，稱之爲樞紐元（pivot）；
3. 將S-{v}（S中除了樞紐元中的其他元素）劃分爲兩個不相交的集合S₁和S₂，S₁集合中的全部元素小於等於樞紐元v，S₂中的全部元素大於等於樞紐元；
4. 若是k<=|S₁|，那麼第k個最大元必然在S₁中。這時，咱們返回quickSelect(S₁，k)。若是k=1+|S₁|，那麼樞紐元就是第k個最大元，咱們直接返回樞紐元。不然，這第k個最大元必定在S₂中，它就是S₂中的第（k-|S₁|-1）個最大元。咱們進行一次遞歸調用並返回quickSelect(S₂，k-|S₁|-1)。

• java實現：

public class QuickSelect {
    /**
     * 截止範圍
     */
    private static final int CUTOFF = 5;

    public static void main(String[] args) {
        Integer[] a = {8, 1, 4, 9, 6, 3, 5, 2, 7, 0, 12, 11, 15, 14, 13, 20, 18, 19, 17, 16};
        int k = 5;
        quickSelect(a, a.length - k + 1);
        System.out.println("第" + k + "大元素是：" + a[a.length - k]);
    }

    public static <T extends Comparable<? super T>> void quickSelect(T[] a, int k) {
        quickSelect(a, 0, a.length - 1, k);
    }

    private static <T extends Comparable<? super T>> void quickSelect(T[] a, int left, int right, int k) {
        if (left + CUTOFF <= right) {
            //三數中值分割法獲取樞紐元
            T pivot = median3(a, left, right);

            //開始分割序列
            int i = left, j = right - 1;
            for (; ; ) {
                while (a[++i].compareTo(pivot) < 0) {
                }
                while (a[--j].compareTo(pivot) > 0) {
                }
                if (i < j) {
                    swapReferences(a, i, j);
                } else {
                    break;
                }
            }
            //將樞紐元與位置i的元素交換位置
            swapReferences(a, i, right - 1);

            if (k <= i) {
                quickSelect(a, left, i - 1, k);
            } else if (k > i + 1) {
                quickSelect(a, i + 1, right, k);
            }
        } else {
            insertionSort(a, left, right);
        }
    }

    private static <T extends Comparable<? super T>> T median3(T[] a, int left, int right) {
        int center = (left + right) / 2;
        if (a[center].compareTo(a[left]) < 0) {

            swapReferences(a, left, center);
        }
        if (a[right].compareTo(a[left]) < 0) {
            swapReferences(a, left, right);
        }
        if (a[right].compareTo(a[center]) < 0) {
            swapReferences(a, center, right);
        }
        // 將樞紐元放置到right-1位置
        swapReferences(a, center, right - 1);
        return a[right - 1];
    }

    public static <T> void swapReferences(T[] a, int index1, int index2) {
        T tmp = a[index1];
        a[index1] = a[index2];
        a[index2] = tmp;
    }

    private static <T extends Comparable<? super T>> void insertionSort(T[] a, int left, int right) {
        for (int p = left + 1; p <= right; p++) {
            T tmp = a[p];
            int j;

            for (j = p; j > left && tmp.compareTo(a[j - 1]) < 0; j--) {
                a[j] = a[j - 1];
            }

            a[j] = tmp;
        }
    }
}

//輸出結果
//第5大元素是：16

由於我這裏是升序排序，因此求第K大，與求第N-k+1是同樣的。

• 最壞時間複雜度：與快速排序同樣，當一個子序列爲空時，最壞爲O(N²)。
• 平均時間複雜度：能夠看出，快速選擇每次只用遞歸一個子序列。平均時間複雜度爲O(N)。

4、總結

本篇詳述了 求top(K)問題的幾種解法，前兩種十分平凡普通，後兩種比較優一點，暫時給出求解中位數須要O(NlogN)時間。後面介紹使用快速選擇方法，每次只用遞歸一個子序列，能夠達到平均O(N)時間複雜度。