面試題:求第K大元素(topK)[增強版]



在原來基礎上增加了算法E

一、引言

​ 這就是類似求Top(K)問題,什么意思呢?怎么在無序數組中找到第幾(K)大元素?我們這里不考慮海量數據,能裝入內存。

二、普通算法

算法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對應的值就是中位數。

三、較好算法

算法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)。

定理:包含2h+1-1個節點、高為h的理想二叉樹(滿二叉樹)的節點的高度的和是2h+1-1-(h+1)。

  1. 什么叫滿二叉樹?滿二叉樹是完全填滿的二叉樹,最后一層都是填滿的,如圖中所示。完全二叉樹,是除最后一層以外都是填滿的,最后一層外也必須從左到右依次填入,就是上一篇中說的堆的結構。滿二叉樹一定是完全二叉樹,完全二叉樹不一定是滿二叉樹。

  2. 證明定理:

    容易看出,滿二叉樹中,高度為h上,有1個節點;高度h-1上2個節點,高度h-2上有2^2個節點及一般在高度h-i上的2i個節點組成。

方程兩邊乘以2得到:

兩式相減得到:

所以定理得證。因為堆由完全二叉樹構成,所以堆的節點數在2h和2h+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中除了樞紐元中的其余元素)划分為兩個不相交的集合S1和S2,S1集合中的所有元素小於等於樞紐元v,S2中的所有元素大於等於樞紐元;
  4. 如果k<=|S1|,那么第k個最大元必然在S1中。這時,我們返回quickSelect(S1,k)。如果k=1+|S1|,那么樞紐元就是第k個最大元,我們直接返回樞紐元。否則,這第k個最大元一定在S2中,它就是S2中的第(k-|S1|-1)個最大元。我們進行一次遞歸調用並返回quickSelect(S2,k-|S1|-1)。
  • java實現:
public class QuickSelect {
    /**
     * 截止范圍
     */

    private static final int CUTOFF = 5;

    public static void main(String[] args) {
        Integer[] a = {814963527012111514132018191716};
        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>> 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(N2)。
  • 平均時間復雜度:可以看出,快速選擇每次只用遞歸一個子序列。平均時間復雜度為O(N)。

四、總結

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


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM