優先佇列的二叉堆實現
在前面的章節裡我們學習了“先進先出”（FIFO）的資料結構：佇列（Queue）。佇列有一種變體叫做“優先佇列”（Priority Queue）。優先佇列的出隊（Dequeue）操作和佇列一樣，都是從隊首出隊。但在優先佇列的內部，元素的次序卻是由“優先順序”來決定：高優先順序的元素排在隊首，而低優先順序的元素則排在後面。這樣，優先佇列的入隊（Enqueue）操作就比較複雜，需要將元素根據優先順序儘量排到佇列前面。我們將會發現，對於下一節要學的圖演算法中的優先佇列是很有用的資料結構。
我們很自然地會想到用排序演算法和佇列的方法來實現優先佇列。但是，在列表裡插入一個元素的時間複雜度是O(n)，對列表進行排序的時間複雜度是O(nlogn)。我們可以用別的方法來降低時間複雜度。一個實現優先佇列的經典方法便是採用二叉堆（Binary Heap）。二叉堆能將優先佇列的入隊和出隊複雜度都保持在O(logn)。
二叉堆的有趣之處在於，其邏輯結構上像二叉樹，卻是用非巢狀的列表來實現。二叉堆有兩種：鍵值總是最小的排在隊首稱為“最小堆（min heap）”，反之，鍵值總是最大的排在隊首稱為“最大堆（max heap）”。在這一節裡我們使用最小堆。
二叉堆的操作
二叉堆的基本操作定義如下：
BinaryHeap()：建立一個空的二叉堆物件insert(k)：將新元素加入到堆中findMin()：返回堆中的最小項，最小項仍保留在堆中delMin()：返回堆中的最小項，同時從堆中刪除isEmpty()：返回堆是否為空size()：返回堆中節點的個數buildHeap(list)：從一個包含節點的列表裡建立新堆
下面所示程式碼是二叉堆的示例。可以看到無論我們以哪種順序把元素新增到堆裡，每次都是移除最小的元素。我們接下來要來實現這個過程。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
from pythonds.trees.binheap import BinHeap bh = BinHeap() bh.insert(5) bh.insert(7) bh.insert(3) bh.insert(11) print(bh.delMin()) print(bh.delMin()) print(bh.delMin()) print(bh.delMin()) |
二叉堆結構性質
為了更好地實現堆，我們採用二叉樹。我們必須始終保持二叉樹的“平衡”，就要使操作始終保持在對數數量級上。平衡的二叉樹根節點的左右子樹的子節點個數相同。在堆的實現中，我們採用“完全二叉樹”的結構來近似地實現“平衡”。完全二叉樹，指每個內部節點樹均達到最大值，除了最後一層可以只缺少右邊的若干節點。圖 1 所示是一個完全二叉樹。
圖 1：完全二叉樹
有意思的是我們用單個列表就能實現完全樹。我們不需要使用節點，引用或巢狀列表。因為對於完全二叉樹，如果節點在列表中的下標為 p，那麼其左子節點下標為 2p，右節點為 2p+1。當我們要找任何節點的父節點時，可以直接使用 python 的整除。如果節點在列表中下標為n，那麼父節點下標為n//2.圖 2 所示是一個完全二叉樹和樹的列表表示法。注意父節點與子節點之間 2p 與 2p+1 的關係。完全樹的列表表示法結合了完全二叉樹的特性，使我們能夠使用簡單的數學方法高效地遍歷一棵完全樹。這也使我們能高效實現二叉堆。
堆次序的性質
我們在堆裡儲存元素的方法依賴於堆的次序。所謂堆次序，是指堆中任何一個節點 x，其父節點 p 的鍵值均小於或等於 x 的鍵值。圖 2 所示是具備堆次序性質的完全二叉樹。
圖 2：完全樹和它的列表表示法
二叉堆操作的實現
接下來我們來構造二叉堆。因為可以採用一個列表儲存堆的資料，建構函式只需要初始化一個列表和一個currentSize來表示堆當前的大小。Listing 1 所示的是構造二叉堆的 python 程式碼。注意到二叉堆的heaplist並沒有用到，但為了後面程式碼可以方便地使用整除，我們仍然保留它。
Listing 1
|
1 2 3 4 |
class BinHeap: def __init__(self): self.heapList = [0] self.currentSize = 0 |
我們接下來要實現的是insert方法。首先，為了滿足“完全二叉樹”的性質，新鍵值應該新增到列表的末尾。然而新鍵值簡單地新增在列表末尾，顯然無法滿足堆次序。但我們可以通過比較父節點和新加入的元素的方法來重新滿足堆次序。如果新加入的元素比父節點要小，可以與父節點互換位置。圖 3 所示的是一系列交換操作來使新加入元素“上浮”到正確的位置。
圖 3：新節點“上浮”到其正確位置
當我們讓一個元素“上浮”時，我們要保證新節點與父節點以及其他兄弟節點之間的堆次序。當然，如果新節點非常小，我們仍然需要將它交換到其他層。事實上，我們需要不斷交換，直到到達樹的頂端。Listing 2 所示的是“上浮”方法，它把一個新節點“上浮”到其正確位置來滿足堆次序。這裡很好地體現了我們之前在headlist中沒有用到的元素 0 的重要性。這樣只需要做簡單的整除，將當前節點的下標除以 2，我們就能計算出任何節點的父節點。
在Listing 3 中，我們已經可以寫出insert方法的程式碼。insert裡面很大一部分工作是由percUp函式完成的。當樹新增新節點時，呼叫percUp就可以將新節點放到正確的位置上。
Listing 2
|
1 2 3 4 5 6 7 |
def percUp(self,i): while i // 2 > 0: if self.heapList[i] < self.heapList[i // 2]: tmp = self.heapList[i // 2] self.heapList[i // 2] = self.heapList[i] self.heapList[i] = tmp i = i // 2 |
Listing 3
|
1 2 3 4 |
def insert(self,k): self.heapList.append(k) self.currentSize = self.currentSize + 1 self.percUp(self.currentSize) |
我們已經寫好了insert方法，那再來看看delMin方法。堆次序要求根節點是樹中最小的元素，因此很容易找到最小項。比較困難的是移走根節點的元素後如何保持堆結構和堆次序，我們可以分兩步走。首先，用最後一個節點來代替根節點。移走最後一個節點保持了堆結構的性質。這麼簡單的替換，還是會破壞堆次序。那麼第二步，將新節點“下沉”來恢復堆次序。圖 4 所示的是一系列交換操作來使新節點“下沉”到正確的位置。
圖 4：替換後的根節點下沉
為了保持堆次序，我們需將新的根節點沿著一條路徑“下沉”，直到比兩個子節點都小。在選擇下沉路徑時，如果新根節點比子節點大，那麼選擇較小的子節點與之交換。Listing 4 所示的是新節點下沉所需的percDown和minChild方法的程式碼。
Listing 4
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
def percDown(self,i): while (i * 2) <= self.currentSize: mc = self.minChild(i) if self.heapList[i] > self.heapList[mc]: tmp = self.heapList[i] self.heapList[i] = self.heapList[mc] self.heapList[mc] = tmp i = mc def minChild(self,i): if i * 2 + 1 > self.currentSize: return i * 2 else: if self.heapList[i*2] < self.heapList[i*2+1]: return i * 2 else: return i * 2 + 1 |
Listing 5 所示的是delMin操作的程式碼。可以看到比較麻煩的地方由一個輔助函式來處理，即percDown。
Listing 5
|
1 2 3 4 5 6 7 |
def delMin(self): retval = self.heapList[1] self.heapList[1] = self.heapList[self.currentSize] self.currentSize = self.currentSize - 1 self.heapList.pop() self.percDown(1) return retval |
關於二叉堆的最後一部分便是找到從無序列表生成一個“堆”的方法。我們首先想到的是，將無序列表中的每個元素依次插入到堆中。對於一個排好序的列表，我們可以用二分搜尋找到合適的位置，然後在下一個位置插入這個鍵值到堆中，時間複雜度為O(logn)。另外插入一個元素到列表中需要將列表的一些其他元素移動，為新節點騰出位置，時間複雜度為O(n)。因此用insert方法的總開銷是O(nlogn)。其實我們能直接將整個列表生成堆，將總開銷控制在O(n)。Listing 6 所示的是生成堆的操作。
Listing 6
|
1 2 3 4 5 6 7 |
def buildHeap(self,alist): i = len(alist) // 2 self.currentSize = len(alist) self.heapList = [0] + alist[:] while (i > 0): self.percDown(i) i = i - 1 |
圖 5：將列表[ 9, 6, 5, 2, 3]生成一個二叉堆
圖 5 所示的是利用buildHeap方法將最開始的樹[ 9, 6, 5, 2, 3]中的節點移動到正確的位置時所做的交換操作。儘管我們從樹中間開始，然後回溯到根節點，但percDown方法保證了最大子節點總是“下沉”。因為堆是完全二叉樹，任何在中間的節點都是葉節點，因此沒有子節點。注意，當i=1時，我們從根節點開始下沉，這就需要進行大量的交換操作。可以看到，圖 5 最右邊的兩顆樹，首先 9 從根節點的位置移走，移到下一層級之後，percDown進一步檢查它此時的子節點，保證它下降到不能再下降為止，即下降到正確的位置。然後進行第二次交換，9 和 3 的交換。由於 9 已經移到了樹最底層的層級，便無法進一步交換了。比較一下列表表示法和圖 5 所示的樹表示法進行的一系列交換還是很有幫助的。
|
1 2 3 |
i = 2 [0, 9, 5, 6, 2, 3] i = 1 [0, 9, 2, 6, 5, 3] i = 0 [0, 2, 3, 6, 5, 9] |
下列所示的程式碼是完全二叉堆的實現。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 |
class BinHeap: def __init__(self): self.heapList = [0] self.currentSize = 0 def percUp(self,i): while i // 2 > 0: if self.heapList[i] < self.heapList[i // 2]: tmp = self.heapList[i // 2] self.heapList[i // 2] = self.heapList[i] self.heapList[i] = tmp i = i // 2 def insert(self,k): self.heapList.append(k) self.currentSize = self.currentSize + 1 self.percUp(self.currentSize) def percDown(self,i): while (i * 2) <= self.currentSize: mc = self.minChild(i) if self.heapList[i] > self.heapList[mc]: tmp = self.heapList[i] self.heapList[i] = self.heapList[mc] self.heapList[mc] = tmp i = mc def minChild(self,i): if i * 2 + 1 > self.currentSize: return i * 2 else: if self.heapList[i*2] < self.heapList[i*2+1]: return i * 2 else: return i * 2 + 1 def delMin(self): retval = self.heapList[1] self.heapList[1] = self.heapList[self.currentSize] self.currentSize = self.currentSize - 1 self.heapList.pop() self.percDown(1) return retval def buildHeap(self,alist): i = len(alist) // 2 self.currentSize = len(alist) self.heapList = [0] + alist[:] while (i > 0): self.percDown(i) i = i - 1 bh = BinHeap() bh.buildHeap([9,5,6,2,3]) print(bh.delMin()) print(bh.delMin()) print(bh.delMin()) print(bh.delMin()) print(bh.delMin()) |
能在O(n)的開銷下能生成二叉堆看起來有點不可思議，其證明超出了本書的範圍。但是，要理解用O(n)的開銷能生成堆的關鍵是因為logn因子基於樹的高度。而對於buildHeap裡的許多操作，樹的高度比logn要小。