heapq
¶
Heap queue algorithm (a.k.a. priority queue).
Heaps are arrays for which a[k] <= a[2*k+1] and a[k] <= a[2*k+2] for all k, counting elements from 0. For the sake of comparison, non-existing elements are considered to be infinite. The interesting property of a heap is that a[0] is always its smallest element.
Usage:
heap = [] # creates an empty heap heappush(heap, item) # pushes a new item on the heap item = heappop(heap) # pops the smallest item from the heap item = heap[0] # smallest item on the heap without popping it heapify(x) # transforms list into a heap, in-place, in linear time item = heapreplace(heap, item) # pops and returns smallest item, and adds
# new item; the heap size is unchanged
Our API differs from textbook heap algorithms as follows:
- We use 0-based indexing. This makes the relationship between the index for a node and the indexes for its children slightly less obvious, but is more suitable since Python uses 0-based indexing.
- Our heappop() method returns the smallest item, not the largest.
These two make it possible to view the heap as a regular Python list without surprises: heap[0] is the smallest item, and heap.sort() maintains the heap invariant!
Functions¶
cmp_lt (x, y) |
|
heapify |
Transform list into a heap, in-place, in O(len(heap)) time. |
heappop |
Pop the smallest item off the heap, maintaining the heap invariant. |
heappush ((heap, ...) |
|
heappushpop ((heap, ...) |
from the heap. The combined action runs more efficiently than |
heapreplace ((heap, ...) |
This is more efficient than heappop() followed by heappush(), and can be more appropriate when using a fixed-size heap. |
merge (*iterables) |
Merge multiple sorted inputs into a single sorted output. |
nlargest (n, iterable[, key]) |
Find the n largest elements in a dataset. |
nsmallest (n, iterable[, key]) |
Find the n smallest elements in a dataset. |
tee |
tee(iterable, n=2) –> tuple of n independent iterators. |
Classes¶
chain |
chain(*iterables) –> chain object |
count |
count(start=0, step=1) –> count object |
imap |
imap(func, *iterables) –> imap object |
islice |
islice(iterable, [start,] stop [, step]) –> islice object |
itemgetter |
itemgetter(item, ...) –> itemgetter object |
izip |
izip(iter1 [,iter2 [...]]) –> izip object |