python學習筆記之heapq內置模塊

heapq內置模塊位於./Anaconda3/Lib/heapq.py，提供基於堆的優先排序算法

堆的邏輯結構就是完全二叉樹，並且二叉樹中父節點的值小於等於該節點的所有子節點的值。這種實現可以使用 heap[k] <= heap[2k+1] 並且 heap[k] <= heap[2k+2] （其中 k 為索引，從 0 開始計數）的形式體現，對於堆來說，最小元素即為根元素 heap[0]。

1.初始化

可以通過 list 對 heap 進行初始化，或者通過 api 中的 heapify 將已知的 list 轉化為 heap 對象。

2. heapq.py中提供的函數方法

heapq.heappush(heap, item)

heapq.heappop(heap)：返回 root 節點，即 heap 中最小的元素。

heapq.heapreplace(heap,item): python3中heappushpop的更高效版。

heapq.heappushpop(heap, item)：向 heap 中加入 item 元素，並返回 heap 中最小元素。

heapq.heapify(x)：Transform list into a heap, in-place, in O(len(x)) time

heapq.merge(*iterables, key=None, reverse=False)

heapq.nlargest(n, iterable, key=None)：返回可枚舉對象中的 n 個最大值，並返回一個結果集 list，key 為對該結果集的操作。

heapq.nsmallest(n, iterable, key=None)：同上相反

heapq._heappop_max(heap): Maxheap version of a heappop

heapq._heapreplace_max(heap,item)：Maxheap version of a heappop followed by a heappush.

heapq._heapify_max(x)：Transform list into a maxheap, in-place, in O(len(x)) time

heapq._siftdown(heap,startpos,pos)： Follow the path to the root, moving parents down until finding a place

heapq._siftup(heap,pos)：Bubble up the smaller child until hitting a leaf

heapq._siftdown_max(heap,startpos,pos)：Maxheap variant of _siftdown

heapq._siftup_max(heap,pos)：Maxheap variant of _siftup

 

3. 舉例

import heapq
def heapsort(iterable):
    h = []
    for i in iterable:
        heapq.heappush(h, i)
    return [heapq.heappop(h) for i in range(len(h))]

# method 1: sort to list
s = [3, 5, 1, 2, 4, 6, 0, 1]
print(heapsort(s))
'''
[0, 1, 1, 2, 3, 4, 5, 6]
'''

# method 2: use key to find price_min
portfolio = [{'name': 'IBM', 'shares': 100, 'price': 91.1},
             {'name': 'AAPL', 'shares': 50, 'price': 543.22},
             {'name': 'FB', 'shares': 200, 'price': 21.09},
             {'name': 'HPQ', 'shares': 35, 'price': 31.75},
             {'name': 'YHOO', 'shares': 45, 'price': 16.35},
             {'name': 'ACME', 'shares': 75, 'price': 115.65}]
cheap = heapq.nsmallest(1, portfolio, key=lambda s:s['price'])
print(cheap)
'''
[{'name': 'YHOO', 'shares': 45, 'price': 16.35}]
'''

# method 3: use while to push min element
def heapilize_list(x):
    n = len(x)
    # 獲取存在子節點的節點 index 列表，並對每個節點單元進行最小堆處理
    for i in reversed(range(n // 2)):
        raiseup_node(x, i)

def put_down_node(heap, startpos, pos):
    current_item = heap[pos]
    # 判斷單元中最小子節點與父節點的大小
    while pos > startpos:
        parent_pos = (pos - 1) >> 1
        parent_item = heap[parent_pos]
        if current_item < parent_item:
            heap[pos] = parent_item
            pos = parent_pos
            continue
        break
    heap[pos] = current_item

def raiseup_node(heap, pos):
    heap_len = len(heap)
    start_pos = pos
    current_item = heap[pos]
    left_child_pos = pos * 2 + 1
    while left_child_pos < heap_len:
        right_child_pos = left_child_pos + 1
        # 將這個單元中的最小子節點元素與父節點元素進行位置調換
        if right_child_pos < heap_len and not heap[left_child_pos] < heap[right_child_pos]:
            left_child_pos = right_child_pos
        heap[pos] = heap[left_child_pos]
        pos = left_child_pos
        left_child_pos = pos * 2 + 1
    heap[pos] = current_item
    put_down_node(heap, start_pos, pos)

p = [4, 6, 2, 10, 1]
heapilize_list(p)
print(p)
'''
[1, 4, 2, 10, 6]
'''

 

參看 Python學習之heapq內置模塊詳解