在原來基礎上增加了算法E。
一、引言
這就是類似求Top(K)問題,什么意思呢?怎么在無序數組中找到第幾(K)大元素?我們這里不考慮海量數據,能裝入內存。
二、普通算法
算法A:
將數組中的元素升序排序,找到數組下標k-1的元素即可。這是大家最容易想到的方法,如果使用簡單排序算法,時間復雜度為O(n^2)。
算法B:
- 第一步:初始化長度為K的一個數組,先讀入K個元素,將元素降序排序(升序也可以),這時候第K大元素就在最后一個。
- 第二步:讀入下一個元素就與已排序的第K大元素比較,如果大於,則將當前的第K大元素刪掉,並將此元素放到前K-1個正確的位置上(這里就是簡單的插入排序了。不了解插入排序的朋友可以看這里圖解選擇排序與插入排序)。
- 時間復雜度:第一步采用普通排序算法時間復雜度是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:
算法思想:將數據讀入一個數組,對數組進行buildHeap(我們這里構建大頂堆),之后對堆進行K次deleteMax操作,第K次的結果就是我們需要的值。(因為是大頂堆,所以數據從大到小排了序,堆排序以后會詳細說)。
現在我們來解決上節遺留的問題,為什么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)。
什么叫滿二叉樹?滿二叉樹是完全填滿的二叉樹,最后一層都是填滿的,如圖中所示。完全二叉樹,是除最后一層以外都是填滿的,最后一層外也必須從左到右依次填入,就是上一篇中說的堆的結構。滿二叉樹一定是完全二叉樹,完全二叉樹不一定是滿二叉樹。
證明定理:
容易看出,滿二叉樹中,高度為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:
- 算法思想:我們采用算法B的思想,只是我們這里構建一個節點數為K的小頂堆,只要下一個數比根節點大,就刪除根節點,並將這個數進行下濾操作。所以算法最終的第K大數就是根節點的數。
- 時間復雜度:對K個數進行buildHeap是O(k),最壞情況下假設剩下的N-k個數都要進入堆中進行下濾操作,總的需要O(k+(N-k)logk)。如果K為N/2,則需要O(NlogN)。
算法E:快速選擇
參考快速排序及其優化,使用快速排序的思想,進行一點點改動。
- 算法思想:
- 如果S中元素個數是1,那么k=1並將S中的元素返回。如果正在使用小數組的截止方法且|S|<=CUTOFF,則將S排序並返回第K個最大元素
- 選取一個S中的元素v,稱之為樞紐元(pivot);
- 將S-{v}(S中除了樞紐元中的其余元素)划分為兩個不相交的集合S1和S2,S1集合中的所有元素小於等於樞紐元v,S2中的所有元素大於等於樞紐元;
- 如果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 = {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(N2)。
- 平均時間復雜度:可以看出,快速選擇每次只用遞歸一個子序列。平均時間復雜度為O(N)。
四、總結
本篇詳述了 求top(K)問題的幾種解法,前兩種十分平凡普通,后兩種比較優一點,暫時給出求解中位數需要O(NlogN)時間。后面介紹使用快速選擇方法,每次只用遞歸一個子序列,可以達到平均O(N)時間復雜度。