算法原理系列：優(yōu)先隊列

第一次總結(jié)這種動態(tài)的數(shù)據(jù)結(jié)構(gòu)，一如既往，看了大量的教程，上網(wǎng)搜優(yōu)先隊列原理，能出來一大堆，但不知道為什么怎么這么多人搞不清楚原理和實現(xiàn)的區(qū)別？非要把實現(xiàn)講成原理，今天就說說自己對優(yōu)先隊列的看法吧。

緣由

顧名思義，優(yōu)先隊列是對隊列的一種改進，隊列為先進先出的一種數(shù)據(jù)結(jié)構(gòu)，而優(yōu)先隊列則保持一條性質(zhì)：

在隊頭的原始始終保持優(yōu)先級最高。

優(yōu)先級最高，我們可以用一個數(shù)來衡量，所以簡單的想法就是時刻把持隊首的key元素最小（最小堆），或者key元素最大（最大堆）。

好了，開始構(gòu)建優(yōu)先隊列的結(jié)構(gòu)吧，現(xiàn)假定給你一堆數(shù)：

nums = [78, 82, 75, 35, 71, 23, 41, 42, 58, 8]

目標：
每次輸出最小值，并從nums中刪除該元素，直到nums的大小為0。

很簡單，最navie的做法，每次遍歷一遍數(shù)組，找出最小值，輸出，并且置為INF，防止下次繼續(xù)遍歷，代碼如下：

public static void main(String[] args) {int[] test = RandomUtil.randomSet(1, 100, 10);solve(test);}static final int INF = 1 << 30;private static void solve(int[] nums){for (int i = 0; i < nums.length; i++){int index = -1, min = INF;for (int j = 0; j < nums.length; j++){if (nums[j] != INF && nums[j] < min){index = j;min = nums[j];}}System.out.println(min);nums[index] = INF;}}

最簡單的做法，但時間復雜度爆表，依次輸出n個元素時，時間復雜度為O(n2)，找最小值操作也需要O(n)，此處有幾個非常別捏的地方，該算法無法解決數(shù)組的動態(tài)擴展，而且把使用過的元素變?yōu)镮NF，所以我們需要設(shè)計一種動態(tài)擴展的數(shù)據(jù)結(jié)構(gòu)來存儲不斷變動的nums，于是有了優(yōu)先隊列的數(shù)據(jù)結(jié)構(gòu)。

優(yōu)先隊列API如下：

public class PriorityQueue<Key extends Comparable<Key>> {Key[] array;int N = 0; //記錄插入元素個數(shù)int SIZE; //當N>SIZE時，可以動態(tài)擴展@SuppressWarnings("unchecked")public PriorityQueue(int SIZE){this.SIZE = SIZE;array = (Key[]) new Comparable[SIZE];} public void offer(Key key){}public Key poll(){return null;}public Key peek(){return null;}public boolean isEmpty(){return false;} }

有了這樣的API，我們就可以把nums中的元素全部offer進去，而當想要輸出最小值時，直接poll出來即可，非常方便，想用就用，所以改進的做法如下：

public static void main(String[] args) {int[] test = RandomUtil.randomSet(1, 100, 10);PriorityQueue<Integer> queue = new PriorityQueue<>(10);for (int i = 0; i < test.length; i++){queue.offer(test[i]);}while (!queue.isEmpty())System.out.println(queue.poll());}

同樣能夠最大不斷輸出最小值，且支持動態(tài)加入元素，是不是高級很多。所以該問題就轉(zhuǎn)變成了設(shè)計優(yōu)先隊列的API了。

API設(shè)計

開始吧，在《算法》書中介紹了初級優(yōu)先隊列的實現(xiàn)，一種是基于stack操作的無序惰性算法，核心思想是，把所有的元素壓入棧中，不管它們的順序，只有當我需要最小值時，用O(n)的算法實現(xiàn)求最小，輸出。惰性源于盡量滿足插入常數(shù)級，不到迫不得已不去使用O(n)的操作。

另外一種IDEA是在插入時就保持元素的有序，這樣在取的操作，我們可以簡單的移動一個指針來不斷輸出最小值，所以為了【維持插入的有序】操作，有了時間復雜度為O(n)的插入算法，而在取最小時，可以O(1)。

這是書中提到的兩個初級實現(xiàn)，可以說它們沒有什么特別的地方，想到也是理所當然的事，接下來就是實現(xiàn)細節(jié)的事了，我直接給出數(shù)組有序的版本（未實現(xiàn)動態(tài)擴展，感興趣的可以自己實現(xiàn)下）。

代碼如下：

/*** * @author DemonSong* * 實現(xiàn)基于插入排序的優(yōu)先隊列* * 插入元素 O(n)* 刪除元素 O(n)** @param <T>*/ public class PriorityQueue<T extends Comparable<T>> {T[] array;int N = 0;int SIZE;@SuppressWarnings("unchecked")public PriorityQueue(int SIZE){this.SIZE = SIZE;array = (T[]) new Comparable[SIZE];}public void offer(T key){if (N == 0){array[N++] = key;return;}int i = 0;while (i < N && key.compareTo(array[i]) > 0) i++;if (i == N){array[N++] = key;return;}rightShift(i);array[i] = key;}private void rightShift(int insert){N++;for (int i = N-1; i >= insert+1; --i){array[i] = array[i-1];}}public T poll(){if (this.isEmpty()) return null;T ele = array[0];leftShift();return ele;}private void leftShift(){for (int i = 1; i < N; i++){array[i-1] = array[i]; }array[N-1] = null;N--;}public T peek(){return array[0];}public boolean isEmpty(){return N == 0;}@Overridepublic String toString() {if (this.isEmpty())return "[]";StringBuilder sb = new StringBuilder();sb.append('[');for (int i = 0; i < N; i++){sb.append(array[i]+", ");}String res = sb.toString().substring(0, sb.length()-2);return res + "]";}public static void main(String[] args) {int[] test = RandomUtil.randomSet(1, 100, 10);PriorityQueue<Integer> queue = new PriorityQueue<>(10);for (int i = 0; i < test.length; i++){queue.offer(test[i]);}while (!queue.isEmpty())System.out.println(queue.poll());} }

對代碼感興趣的可以研究下細節(jié)，注意，為了實現(xiàn)簡單，我的poll操作還是O(n)，并不是達不到O(1).

堆原理

怎么說呢，上述初級實現(xiàn)中有一個array數(shù)組，它的結(jié)構(gòu)相當?shù)图?#xff0c;這也是為什么offer操作是O(n)的時間復雜度，假設(shè)你把nums一堆數(shù)offer進去，該數(shù)組在計算機看來是這樣子的：

nums = [12, 16, 37, 41, 51, 55, 56, 74, 77, 84]queue的視角： 12 -> 16 -> 37 -> 41 -> 51 -> 55 -> 56 -> 74 -> 77 ->84

可以想象，這個關(guān)系是有多么的強，我只需要開頭的最小值，結(jié)果你卻維護了整個數(shù)組的有序，而為了維護整個數(shù)組的有序，我又是rightShift，又是比較的，這耗費了多少操作？

所以歸根結(jié)底的原因在于，取最小的操作不值得維護整體的有序性，比如，我們換個視角來看問題，如下：

堆的視角：12 -> 16 -> 41 -> 74-> 37 -> 51 -> 77-> 55 -> 84-> 56該結(jié)構(gòu)相當零活，在第一層的一定是最小的，而第二層的元素一定比第三層元素小，符合這種結(jié)構(gòu)的解唯一么？如下：12 -> 37 -> 41 -> 74-> 16 -> 55 -> 77-> 51 -> 84-> 56同樣符合，是吧？

在這里，我們可以得到一個有趣的猜想，一種數(shù)據(jù)結(jié)構(gòu)出現(xiàn)的結(jié)果越不“唯一”，維護該結(jié)構(gòu)所需要的消耗越小。

那么現(xiàn)在問題來了，動態(tài)加入一個元素后，如下：

queue.offer(19);12 -> 37 -> 41 -> 74-> 16 -> 55 -> 77-> 51 -> 84-> 56

怎么加，加哪里，該如何維護？想想，如果維護的是一個樹結(jié)構(gòu)，假設(shè)從根結(jié)點開始插入該元素，因為19>12，所以必然放入下一層，但放入37還是16這個結(jié)點下？無所謂，你可以放入任何一個結(jié)點的子樹中，關(guān)鍵來了！！！這就少維護了一半的關(guān)系！每次對半坎，所以說樹結(jié)構(gòu)高級的原因就在于，有些操作在判斷時，都會去掉一半元素，這就好比原本規(guī)模大小為n的問題，一下子遞歸為n2的子問題，那自然而然遞歸深度只有log2n了，是吧？

所以加入一個元素如下：

12 -> 19(37) -> 41 -> 74-> 16 -> 55 -> 77-> 51 -> 84-> 56

這是堆原理的另一個關(guān)鍵步驟，我們知道了19比37來的小，所以它不可能再進入下一層，那37怎么辦？第二層已經(jīng)容不下它了，所以它必須下一層找出入。這里需要注意一個堆的性質(zhì)，16結(jié)點的子樹和37結(jié)點的子樹是不相關(guān)的，它們各自維護一層層的關(guān)系，所以37沒必要和16去判斷。

ok，到這堆的原理已經(jīng)講完了，真正的兩個精髓被我們找到了。

• 維護一個相對較弱的層級結(jié)構(gòu)而非很強關(guān)系的有序結(jié)構(gòu)，前者的維護成本要小很多。
• 維護插入元素時，隨機挑選某個子結(jié)點進行沉降，遇到比它大的結(jié)點，把該結(jié)點的元素代入到下一層，直到葉子結(jié)點。

好了，接下來的優(yōu)先隊列的實現(xiàn)都是細節(jié)問題了，比如為什么用數(shù)組去維護二叉堆？
答：數(shù)組就不能維護二叉堆么？隊首元素從下標1開始，所以當某個父結(jié)點為k時，左子結(jié)點為2k，右子結(jié)點為2k+1。同樣的，已知子結(jié)點k，父結(jié)點為k/2。

為什么插入是從數(shù)組尾部開始？
答：我也想從頭部開始插啊，但頭部開插，我要寫個隨機算法來隨機選擇某個子結(jié)點？而且即使實現(xiàn)了，你這葉子結(jié)點的生長性也太隨機了吧？隨機的結(jié)果必然導致父子結(jié)點的k求法失效。

尾插的好處是什么？
答：每次都是嚴格的擴展完全二叉堆，這還不夠好么？所以剛才是沉降操作，反過來自然有了上浮操作。

刪除了頭元素該怎么辦？
答：現(xiàn)在是不是就可以頭插了？畢竟沒有元素在頭，這個位置必須有元素可以替代，為了保證二叉堆的嚴格性，那肯定也是從最后一個元素取嘛，ok了，優(yōu)先隊列的設(shè)計完畢了。然后，再看看圖吧，這些操作本來就是自然而然產(chǎn)生的。

上浮操作：

下沉操作：

再來看看具體實現(xiàn)吧，建議親自實現(xiàn)一遍，敲的時候就不要抄了，腦子過一遍，印象深刻。代碼如下：

import java.util.Comparator; import com.daimens.algorithm.utils.RandomUtil;public class PriorityQueue<Key extends Comparable<Key>> {Key[] array;int N = 0;int SIZE;private Comparator<? super Key> comparator;public PriorityQueue(int SIZE){this.SIZE = SIZE;array = (Key[]) new Comparable[SIZE+1];}public PriorityQueue(int SIZE, Comparator<? super Key> comparator){this(SIZE);this.comparator = comparator;}public void offer(Key key){array[++N] = key;swin(N);}private void swin(int k){while (k > 1 && less(k, k / 2)){swap(k, k / 2);k = k / 2;}}private boolean less(int i, int j){if (comparator != null) return comparator.compare(array[i], array[j]) < 0;else return array[i].compareTo(array[j]) < 0;}private void swap(int i, int j){Key tmp = array[i];array[i] = array[j];array[j] = tmp;}public Key poll(){Key key= array[1];swap(1, N);array[N] = null;N--;sink(1);return key;}private void sink(int k){while (2*k <= N){int j = 2 * k;if (j < N && less(j+1, j)) j++;if(!less(j, k)) break;swap(k, j);k = j;}}public Key peek(){return array[1];}public boolean isEmpty(){return N == 0;}@Overridepublic String toString() {if (this.isEmpty())return "[]";StringBuilder sb = new StringBuilder();sb.append('[');for (int i = 1; i <= N; i++){sb.append(array[i]+", ");}String res = sb.toString().substring(0, sb.length()-2);return res + "]";}public static void main(String[] args) {int[] test = RandomUtil.randomSet(1, 100, 10);PriorityQueue<Integer> queue = new PriorityQueue<>(10, (a, b) -> (b-a));for (int i = 0; i < test.length; i++){queue.offer(test[i]);}while (!queue.isEmpty()){System.out.println(queue.poll());}} }

總結(jié)

以上是生活随笔為你收集整理的算法原理系列：优先队列的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。