c++ 优先队列_用Python实现优先级队列的3种方法

微信公众号：冰咖啡与狗

1. 什么是优先级队列？

优先级队列是一种容器型数据结构，它能管理一队记录，并按照排序字段（例如一个数字类型的权重值）为其排序。由于是排序的，所以在优先级队列中你可以快速获取到最大的和最小的值。

可以认为优先级队列是一种修改过的普通队列：普通队列依据记录插入的时间来获取下一个记录，而优先级队列依据优先级来获取下一个记录，优先级取决于排序字段的值。

优先级队列常用来解决调度问题，比如给紧急的任务更高的优先级。以操作系统的任务调度为例：高优先级的任务（比如实时游戏）应该先于低优先级的任务（比如后台下载软件更新）执行。

在 Python 中，内置的标准库提供了两种实现优先队列的数据结构，分别是 heapq 模块和 PriorityQueue 模块，接下来本文将对如何利用这两个数据结构实现优先级队列进行介绍，包括高优先级队列、低优先级队列，以及面向对象的优先级队列。这两种数据结构，其本质都是利用了堆的数据结构来实现优先队列，因此最后会利用列表来实现一个堆排序，然后在实现优先级队列。

先简单介绍 heap（堆）的概念。堆，是对于每一个父节点上的值都小于或等于子节点的值的二叉树。此外，一个堆必须是一个完整的二叉树，除了最底层，其他每一级必须是被完整填充的。因此，堆的最重要的一个特点就是：首项 heap[0] 总是最小的一项。

2. heapq 模块

heapq 是一个二叉堆的实现，其内部使用内置的 list 对象，对于列表中的每一个元素，其满足 a[k] <= a[2*k+1] and a[k] <= a[2*k+2] ，因此，该方法默认的是一个最小堆，a[0] 为队列中的最小元素。

2.1. 最小优先队列实现

由于 heapq 模块默认的就是最小堆结构，所以可以直接利用其中的函数操作来实现最小优先队列的功能。

def smallest_queue(arr):
    """
    默认为最小优先队列
    """
    print("原数组：{0}".format(arr))
    # 将给定的列表转化为最小堆，线性时间
    heapq.heapify(arr)
    print("最小堆数组：{0}".format(arr))

    # 插入元素
    heapq.heappush(arr, 5)
    print("插入新元素后：{0}".format(arr))

    # 弹出最小元素
    item0 = heapq.heappop(arr)
    print("弹出的元素后：{0}".format(arr))

    # 返回最小元素
    item1 = arr[0]
    print("获取最小元素的值：{0}".format(item1))

    # 弹出最小元素，并插入一个新的元素，相当于先 heappop, 再 heappush
    item2 = heapq.heapreplace(arr, -2)
    print("弹出的元素为：{0}".format(item2))
    print("现在的堆结构为：{0}".format(arr))

2.2. 最大优先队列的实现

除了最小堆以外，最大堆也是我们常用的一种数据结构，利用 heapq 模块可以实现最大堆的一些简单操作。

def largest_queue(arr):
    """
    最大优先队列的实现

    阅读 heapq 模块的源代码可以发现，其内置了最大优先队列的实现函数和操作函数，但没有内置新插入元素的函数
    """
    print("原数组：{0}".format(arr))
    # 将给定的列表转化为最大堆，线性时间
    heapq._heapify_max(arr)
    print("最大堆数组：{0}".format(arr))

    # 弹出最大元素
    item0 = heapq._heappop_max(arr)
    print("弹出的元素为：{0}".format(item0))
    print("弹出的元素后：{0}".format(arr))

    # 弹出最大元素，并插入一个新的元素
    item1 = heapq._heapreplace_max(arr, 9)
    print("弹出的元素为：{0}".format(item1))
    print("现在的堆结构为：{0}".format(arr))

2.3. 复杂结构的优先队列

在现实场景中，我们在使用优先队列时往往不是针对简单的数组进行优先排列，而是对元组、列表或者字典等一个个复杂的对象进行优先排列。下面以元组为例，其在构建优先队列时，默认是以第一个元素来进行排列，当第一个元素相同时，则开始比较第二个。字符串的比较从首字母开始进行比较。

def object_queue():
    """
    针对对象结构的优先队列
    """
    q = []
    heapq.heappush(q, (2, 'code'))
    heapq.heappush(q, (1, 'eat'))
    heapq.heappush(q, (3, 'sleep'))
    heapq.heappush(q, (2, 'play'))
    heapq.heappush(q, (3, "debug"))
    q1 = [x for x in q]
    while q:
        next_item = heapq.heappop(q)
        print(next_item)
# ---- result -----
# (1, 'eat')
# (2, 'code')
# (2, 'play')
# (3, 'debug')
# (3, 'sleep')

    # 返回最小的 n 个元素，相当于 sorted(iterable, key=key)[:n]
    n_smallest = heapq.nsmallest(3, q1, key=lambda x: x[0])
    print("最小的3个元素：{0}".format(n_smallest))
    # 返回最大的 n 个元素，相当于 sorted(iterable, key=key, reverse=True)[:n]
    n_largest = heapq.nlargest(3, q1, key=lambda x: x[1])
    print("最大的3个元素：{0}".format(n_largest))

3. PriorityQueue 模块

该模块定义的优先级队列，其内部使用了 heapq 模块，所以它的时间复杂度和heapq是相同的。

当一个对象的所有元素都是可比较的时，默认情况下是根据队列中的对象的第一个元素进行排序，越小的优先级越高，排在越前面。当第一个元素相同时，依次比较后续的元素的大小来进行排序。

由于 PriorityQueue 是继承自 Queue 类，所以很多函数的用法可以直接参照于 Queue 类中的函数。

from queue import PriorityQueue as PQ
pq = PQ()
pq.put((1, 'a'))
pq.put((2, 'c'))
pq.put((2, 'b'))
pq.put((2, 'b'))
print(pq.queue) # [(1, 'a'), (2, 'b'), (2, 'b'), (2, 'c')]
item0 = pq.get() # (1, 'a')
print(pq.queue) # [(2, 'b'), (2, 'b'), (2, 'c')]

print(pq.qsize()) # 优先队列的尺寸

while not pq.empty():
    print(pq.get())

与 heapq 模块不同的是， PriorityQueue 是基于类实现的，其提供的操作是同步的，提供锁操作，支持并发的生产者和消费者。

4. 实现自己的优先队列

在面向对象的编程过程中，我们通常是将一些单独的函数或变量组合成一个对象，然后在进行优先级排列。例如我们现在有很多种汽车，汽车有名字和价格，以及一些操作方法。当我们对汽车对象来按照价格进行优先级排列时，由于自定义的对象是不可比较的，所以在进行优先级排列时会报错。因此对于那些自定义的对象，我们需要重写优先级队列的方法来进行实现。

由于 PriorityQueue 也是基于 heapq 实现的，所以我们自定义的优先级队列可以直接基于 heapq 模块来实现。

import heapq

class My_PriorityQueue(object):
    def __init__(self):
        self._queue = []
        self._index = 0

    def push(self, item, priority):
        """
        队列由 (priority, index, item) 形式组成
        priority 增加 "-" 号是因为 heappush 默认是最小堆
        index 是为了当两个对象的优先级一致时，按照插入顺序排列
        """
        heapq.heappush(self._queue, (-priority, self._index, item))
        self._index += 1

    def pop(self):
        """
        弹出优先级最高的对象
        """
        return heapq.heappop(self._queue)[-1]

    def qsize(self):
        return len(self._queue)

    def empty(self):
        return True if not self._queue else False

class Car(object):
    def __init__(self, name, value):
        self.name = name
        self.value = value

    def __repr__(self):
        return "{0} -- {1}".format(self.name, self.value)

if __name__ == "__main__":
    car1 = Car("BMW", 45)
    car2 = Car("Maybach", 145)
    car3 = Car("Bugatti", 85)
    car4 = Car("Cadillac", 78)
    car5 = Car("Maserati", 85)
    pq = My_PriorityQueue()
    pq.push(car1, car1.value)
    pq.push(car2, car2.value)
    pq.push(car3, car3.value)
    pq.push(car4, car4.value)
    pq.push(car5, car5.value)
    print("队列大小：{0}".format(pq.qsize()))
    # 弹出元素
    while not pq.empty():
        print(pq.pop())

5. 源码文件

• heapq 模块实现优先队列
• PriorityQueue 模块实现优先队列
• 自定义优先级队列