使用二叉堆的优先级队列

介绍

优先级队列是一种数据结构，它支持两个基本操作：插入元素和取出最小（或最大）元素。优先级队列与普通队列的区别在于，元素的添加顺序并不重要，重要的是元素的优先级大小。

二叉堆是优先级队列的一种实现方式。二叉堆是一种完整二叉树（即除了最后一层，其他层都是满的，最后一层从左到右依次填满），并且满足父节点的优先级总是大于或等于两个子节点的优先级。

二叉堆可以使用数组来实现，数组的第一个元素被视为根节点，下一层的元素从左到右填充，最后一层的元素从左到右填充，从而节省了空间。

实现

以下是使用Python语言实现二叉堆优先级队列的示例代码：

class MinHeapPriorityQueue:
    def __init__(self):
        self.heap = []

    def __len__(self):
        return len(self.heap)

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

    def add(self, key, value):
        self.heap.append((key, value))
        self._sift_up(len(self.heap) - 1)

    def min(self):
        if self.is_empty():
            raise Exception("Priority queue is empty")
        key, value = self.heap[0]
        return key, value

    def remove_min(self):
        if self.is_empty():
            raise Exception("Priority queue is empty")
        key, value = self.heap[0]
        self._swap(0, len(self.heap) - 1)
        self.heap.pop()
        self._sift_down(0)
        return key, value

    def _parent(self, index):
        return (index - 1) // 2

    def _left_child(self, index):
        return 2 * index + 1

    def _right_child(self, index):
        return 2 * index + 2

    def _sift_up(self, index):
        while index > 0:
            parent = self._parent(index)
            if self.heap[parent][0] > self.heap[index][0]:
                self._swap(parent, index)
            else:
                break
            index = parent

    def _sift_down(self, index):
        while self._left_child(index) < len(self.heap):
            left = self._left_child(index)
            right = self._right_child(index) if self._right_child(index) < len(self.heap) else None
            if right and self.heap[right][0] < self.heap[left][0]:
                smallest = right
            else:
                smallest = left
            if self.heap[index][0] > self.heap[smallest][0]:
                self._swap(index, smallest)
            else:
                break
            index = smallest

    def _swap(self, i, j):
        self.heap[i], self.heap[j] = self.heap[j], self.heap[i]

API

MinHeapPriorityQueue()

创建一个空的二叉堆优先级队列。

add(key, value)

将键值对添加到优先级队列中。

remove_min()

删除最小的元素并返回其键值对。

min()

返回最小元素的键值对，但不会将其从优先级队列中删除。

is_empty()

如果优先级队列为空，则返回True，否则返回False。

len()

返回优先级队列元素的数量。

总结

二叉堆优先级队列提供了一种经济高效的方式来维护具有优先级的元素集合。在Python中，可以使用自定义类和堆模块来实现优先级队列，但是使用二叉堆提供了更灵活和控制的选项。通过使用上述的API，可以轻松地创建、添加、移除最小值和查询最小值等操作。