8.5. heapq - 堆队列算法

源代码： Lib / heapq.py

该模块提供了堆队列算法的实现，也称为优先级队列算法。

堆是二叉树，每个父节点的值小于或等于其任何子节点。这个实现的数组基于以下特点：heap[k] <= heap[2*k+1] and heap[k] <= heap[2*k+2] 对于所有的 k, 从零开始计数 。为了比较，不存在的元素被认为是无限的。堆的有趣的属性是它的最小元素总是根，heap [0]。

下面的API与教科书堆算法在两个方面不同：（a）我们使用基于零的索引。这使得节点的索引和其子节点的索引之间的关系稍微不那么明显，但是更合适，因为Python使用基于零的索引。（b）我们的pop方法返回最小的项而不是最大的（在教科书中称为“最小堆”；因为它适合于就地排序，所以“最大堆”在文本中更常见）。

这两个使得可以将堆视为正常的Python列表而没有惊喜：heap [0]是最小的项，heap.sort()维持堆不变！

要创建堆，请使用初始化为[]的列表，或者您可以通过函数heapify()将填充列表转换为堆。

提供以下功能：

heapq.heappush(heap, item)

将值item推到heap上，保持堆不变。

heapq.heappop(heap)

从heap中弹出并返回最小的项，保持堆不变。如果堆为空，则会引发IndexError。要访问最小的项，不需要弹出它，请使用heap [0]。

heapq.heappushpop(heap, item)

在堆上按项，然后弹出并返回堆中的最小项。组合操作比heappush()运行更有效，随后单独调用heappop()。

heapq.heapify(x)

在线性时间内，将列表x放入堆中。

heapq.heapreplace(heap, item)

从堆中弹出并返回最小的项，并推送新的项。堆大小不变。如果堆为空，则会引发IndexError。

这一步操作比heappop()和heappush()更有效，并且在使用固定大小的堆时可能更合适。pop / push组合总是从堆中返回一个元素，并用item替换它。

返回的值可能大于添加的项。如果不需要，请考虑使用heappushpop()。它的push / pop组合返回两个值中的较小值，在堆上留下较大的值。

该模块还提供了基于堆的三个通用功能。

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

将多个排序的输入合并到单个排序的输出（例如，合并来自多个日志文件的带时间戳的条目）。在排序后的值上返回iterator。

与sorted(itertools.chain(*iterables))类似，但返回一个可迭代，不会一次将数据拉入内存，并假设每个输入流已经排序（最小到最大）。

有两个可选参数，必须指定为关键字参数。

键指定一个参数的key function，用于从每个输入元素提取比较键。默认值为None（直接比较元素）。

reverse是一个布尔值。如果设置为True，则输入元素将合并，如同每次比较都反转一样。

在3.5版中已更改：添加了可选的键和反向参数。

heapq.nlargest(n, iterable, key=None)

返回可迭代定义的数据集中n最大元素的列表。key, if provided, specifies a function of one argument that is used to extract a comparison key from each element in the iterable: key=str.lower Equivalent to: sorted(iterable, key=key, reverse=True)[:n]

heapq.nsmallest(n, iterable, key=None)

返回可迭代定义的数据集中n最小元素的列表。key, if provided, specifies a function of one argument that is used to extract a comparison key from each element in the iterable: key=str.lower Equivalent to: sorted(iterable, key=key)[:n]

后两个函数对于较小的n值表现最好。对于较大的值，使用sorted()函数更为有效。此外，当n==1时，使用内建min()和max()函数更为有效。如果需要重复使用这些函数，请考虑将iterable转换为实际堆。

8.5.1.基本示例

可以通过将所有值推送到堆上，然后一次一个地弹出最小值来实现堆栈：

>>> def heapsort(iterable):
...     h = []
...     for value in iterable:
...         heappush(h, value)
...     return [heappop(h) for i in range(len(h))]
...
>>> heapsort([1, 3, 5, 7, 9, 2, 4, 6, 8, 0])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

这类似于sorted(iterable)，但与sorted()不同，此实现不稳定。

堆元素可以是元组。这对于在正在跟踪的主记录旁边分配比较值（例如任务优先级）很有用：

>>> h = []
>>> heappush(h, (5, 'write code'))
>>> heappush(h, (7, 'release product'))
>>> heappush(h, (1, 'write spec'))
>>> heappush(h, (3, 'create tests'))
>>> heappop(h)
(1, 'write spec')

8.5.2.优先级队列实现注释

优先级队列通常用于堆，并且它提出了几个实现挑战：

  • 排序稳定性：如何使两个具有相同优先级的任务按照它们最初添加的顺序返回？
  • 如果优先级相等且任务没有默认比较顺序，则（优先级，任务）对的元组比较中断。
  • 如果任务的优先级改变，你如何将它移动到堆中的新位置？
  • 或者，如果一个挂起的任务需要被删除，你如何找到它并将其从队列中删除？

前两个挑战的解决方案是将条目存储为包括优先级，条目计数和任务的3元素列表。条目计数用作tie-breaker，以便按照添加的顺序返回具有相同优先级的两个任务。由于没有两个条目计数是相同的，元组比较将永远不会尝试直接比较两个任务。

其余的挑战包括找到一个待完成的任务，改变其优先级或完全删除它。可以使用指向队列中的条目的字典来完成查找任务。

删除条目或更改其优先级更加困难，因为它会破坏堆结构不变式。因此，一个可能的解决方案是将该条目标记为已删除，并添加具有修改的优先级的新条目：

pq = []                         # list of entries arranged in a heap
entry_finder = {}               # mapping of tasks to entries
REMOVED = '<removed-task>'      # placeholder for a removed task
counter = itertools.count()     # unique sequence count

def add_task(task, priority=0):
    'Add a new task or update the priority of an existing task'
    if task in entry_finder:
        remove_task(task)
    count = next(counter)
    entry = [priority, count, task]
    entry_finder[task] = entry
    heappush(pq, entry)

def remove_task(task):
    'Mark an existing task as REMOVED.  Raise KeyError if not found.'
    entry = entry_finder.pop(task)
    entry[-1] = REMOVED

def pop_task():
    'Remove and return the lowest priority task. Raise KeyError if empty.'
    while pq:
        priority, count, task = heappop(pq)
        if task is not REMOVED:
            del entry_finder[task]
            return task
    raise KeyError('pop from an empty priority queue')

8.5.3.理论

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. 为了比较，不存在的元素被认为是无限的。堆的有趣属性是a[0]始终是其最小的元素。

上面奇怪的不变式意味着是一个有效的内存表示为比赛。下面的数字是k，而不是a[k]：

                               0

              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

在上面的树中，每个单元k顶在2*k+1和2*k+2。在一个通常的二进制比赛，我们看到在体育，每个单元格是两个单元格的冠军，它顶部，我们可以跟踪赢家在树上查看所有的对手/他有。然而，在这样的比赛的许多计算机应用中，我们不需要追踪获胜者的历史。为了提高内存的效率，当一个优胜者被提升时，我们尝试用更低级别的其他东西取代它，规则变成一个单元格和它上面的两个单元格包含三个不同的项目，但顶部单元格“胜利”在两个顶端的细胞。

如果这个堆不变量在任何时候都受到保护，索引0显然是总赢家。去除它并找到“下一个”获胜者的最简单的算法方法是将一些失败者（让我们说上面的图中的单元格30）移动到0位置，然后沿着树来渗透这个新的0，交换值，直到不变量重新建立。这显然是对树中项目总数的对数。通过遍历所有项，你得到一个O（n log n）排序。

这种类型的一个很好的功能是，你可以有效地插入新的项目，而排序进行，只要插入的项目不比你提取的最后第0个元素“更好”。这在模拟上下文中尤其有用，其中树保存所有传入的事件，并且“赢”条件意味着最小的调度时间。当事件计划其他事件以供执行时，它们将被调度到将来，以便他们可以轻松地进入堆。所以，堆是一个很好的结构实现调度器（这是我用于我的MIDI音序器:-)。

已经广泛地研究了用于实现调度器的各种结构，并且堆是有益的，因为它们合理地快，速度几乎恒定，并且最坏情况与平均情况没有太多不同。然而，有其他表示，整体更有效，但最坏的情况可能是可怕的。

堆在大磁盘排序中也非常有用。你很可能都知道一个大排序意味着生成“运行”（它是预排序的序列，其大小通常与CPU内存量相关），然后是这些运行的合并遍，这些合并通常非常巧妙组织了[1]。非常重要的是，初始排序产生尽可能长的运行。比赛是一个很好的方式来实现。如果使用所有可用的内存来举办锦标赛，你可以替换和渗透到适合当前运行的项目，你会产生的运行是随机输入的内存大小的两倍，对输入进行模糊排序会更好。

此外，如果您输出磁盘上的第0项，并获得一个可能不适合当前比赛的输入（因为值“胜过”最后一个输出值），它不能适合堆，所以大小堆减少。释放的内存可以立即被巧妙地重用，用于逐步构建第二个堆，它以与第一个堆融化的速率完全相同的速度增长。当第一个堆完全消失时，您切换堆并开始新的运行。聪明而相当有效！

总之，堆是有用的内存结构要知道。我在几个应用程序中使用它们，我认为保存一个'heap'模块是很好的。:-)

脚注

[1]当今的磁盘平衡算法比现在更烦人，这是磁盘搜索能力的结果。在不能寻找的设备，如大磁带驱动器，故事是完全不同的，一个人必须非常聪明，以确保（提前）每个磁带运动将是最有效的可能（也就是说，最好参与“进行“合并）。一些磁带甚至能够向后读，这也用于避免重绕时间。相信我，真正好的磁带类别是相当壮观的看！从任何时候，排序一直是一个伟大的艺术！:-)