优先级队列的python实现

目录

 

优先级队列

 

完整代码

---

优先级队列

优先级队列就是根据优先级的大小，每次都先推出最大的优先级，接着是次优先级，依次类推。。。。。

这个过程很像是最大堆排列，可以用堆来实现。但实现最大堆的时候，是只push一个元素进去，这个需要push两个元素（优先级和元素）。我们只要将优先级和元素组成一个tuple，就可以了。比较含多个元素的tuple，都是从tuple的第一个元素开始比较，如果比较第一个元素就可以了，就直接返回结果了，如果第一个元素都一样（相等），那就比较第二个元素。

【发现两个tuple的大小比较的方式是从第一个位置开始逐个进行比较，如果不等，则其比较的结果就是整个tuple比较的结果；如果相同，则继续下一个位置的比较】

PS:如果是（2，4，-8）和（2，4）比较呢？答案是前者大，因为前者元素多。

先初始化最大长度，和导入以前的最大堆。

class PriorityQueue(object):
    def __init__(self, maxsize):
        self.maxsize = maxsize
        self._maxheap = MaxHeap(maxsize)

定义填入操作，先将优先级和元素组成一个tuple，再把组成的tuple给加进去。

    def push(self, priority, value):
        entry = (priority, value)    # 注意这里把这个 tuple push进去，python 比较 tuple 从第一个开始比较
        self._maxheap.add(entry)

接着是弹出操作，如果是返回优先级的话，就把所有的都返回，否则，就只返回后一个。

    def pop(self, with_priority=False):
        entry = self._maxheap.extract()
        if with_priority:
            return entry
        else:
            return entry[1]

用heapq实现

实现一个优先级队列，每次pop的元素要是优先级高的元素，由于heapq.heapify(list)默认构建一个小顶堆，因此要将priority变为相反数再push，代码如下：

import heapq
class PriorityQueue(object):
    """实现一个优先级队列，每次pop优先级最高的元素"""
    def __init__(self):
        self._queue = []
        self._index = 0
    def push(self,item,priority):
        heapq.heappush(self._queue,(-priority,self._index,item))#将priority和index结合使用，在priority相同的时候比较index，pop先进入队列的元素
        self._index += 1
    def pop(self):
        return heapq.heappop(self._queue)[-1]
if __name__ == '__main__':
    pqueue = PriorityQueue()
    pqueue.push('d',4)
    pqueue.push('f',3)
    pqueue.push('a',6)
    pqueue.push('s',2)
    print(pqueue.pop())
    print(pqueue.pop())
    print(pqueue.pop())

 

完整代码

# -*- coding:utf-8 -*-

# 第二章拷贝的 Array 代码


class Array(object):

    def __init__(self, size=32):
        self._size = size
        self._items = [None] * size

    def __getitem__(self, index):
        return self._items[index]

    def __setitem__(self, index, value):
        self._items[index] = value

    def __len__(self):
        return self._size

    def clear(self, value=None):
        for i in range(len(self._items)):
            self._items[i] = value

    def __iter__(self):
        for item in self._items:
            yield item

#####################################################
# heap 实现
#####################################################


class MaxHeap(object):
    """
    Heaps:
    完全二叉树，最大堆的非叶子节点的值都比孩子大，最小堆的非叶子结点的值都比孩子小
    Heap包含两个属性，order property 和 shape property(a complete binary tree)，在插入
    一个新节点的时候，始终要保持这两个属性
    插入操作：保持堆属性和完全二叉树属性, sift-up 操作维持堆属性
    extract操作：只获取根节点数据，并把树最底层最右节点copy到根节点后，sift-down操作维持堆属性

    用数组实现heap，从根节点开始，从上往下从左到右给每个节点编号，则根据完全二叉树的
    性质，给定一个节点i， 其父亲和孩子节点的编号分别是:
        parent = (i-1) // 2
        left = 2 * i + 1
        rgiht = 2 * i + 2
    使用数组实现堆一方面效率更高，节省树节点的内存占用，一方面还可以避免复杂的指针操作，减少
    调试难度。

    """

    def __init__(self, maxsize=None):
        self.maxsize = maxsize
        self._elements = Array(maxsize)
        self._count = 0

    def __len__(self):
        return self._count

    def add(self, value):
        if self._count >= self.maxsize:
            raise Exception('full')
        self._elements[self._count] = value
        self._count += 1
        self._siftup(self._count-1)  # 维持堆的特性

    def _siftup(self, ndx):
        if ndx > 0:
            parent = int((ndx-1)/2)
            if self._elements[ndx] > self._elements[parent]:    # 如果插入的值大于 parent，一直交换
                self._elements[ndx], self._elements[parent] = self._elements[parent], self._elements[ndx]
                self._siftup(parent)    # 递归

    def extract(self):
        if self._count <= 0:
            raise Exception('empty')
        value = self._elements[0]    # 保存 root 值
        self._count -= 1
        self._elements[0] = self._elements[self._count]    # 最右下的节点放到root后siftDown
        self._siftdown(0)    # 维持堆特性
        return value

    def _siftdown(self, ndx):
        left = 2 * ndx + 1
        right = 2 * ndx + 2
        # determine which node contains the larger value
        largest = ndx
        if (left < self._count and     # 有左孩子
                self._elements[left] >= self._elements[largest] and
                self._elements[left] >= self._elements[right]):  # 原书这个地方没写实际上找的未必是largest
            largest = left
        elif right < self._count and self._elements[right] >= self._elements[largest]:
            largest = right
        if largest != ndx:
            self._elements[ndx], self._elements[largest] = self._elements[largest], self._elements[ndx]
            self._siftdown(largest)


class PriorityQueue(object):
    def __init__(self, maxsize):
        self.maxsize = maxsize
        self._maxheap = MaxHeap(maxsize)

    def push(self, priority, value):
        entry = (priority, value)    # 注意这里把这个 tuple push进去，python 比较 tuple 从第一个开始比较
        self._maxheap.add(entry)

    def pop(self, with_priority=False):
        entry = self._maxheap.extract()
        if with_priority:
            return entry
        else:
            return entry[1]

    def is_empty(self):
        return len(self._maxheap) == 0


def test_priority_queue():
    size = 5
    pq = PriorityQueue(size)
    pq.push(5, 'purple')
    pq.push(0, 'white')
    pq.push(3, 'orange')
    pq.push(1, 'black')

    res = []
    while not pq.is_empty():
        res.append(pq.pop())
    assert res == ['purple', 'orange', 'black', 'white']