python-优先级队列

本文详细介绍了最大堆的数据结构实现,并基于此构建了一个优先级队列。通过具体的Python代码,展示了如何进行元素的添加与提取,维持堆的最大特性。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

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

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(self._items):
            self._items[i] = value

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


'''
    初始化堆结构
'''
class MaxHeap(object):
    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')
        #将插入的值value给数组最后一值
        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]:
                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._elements[0] = self._elements[self._count]
        self._siftdown(0)
        return value

    def _siftdown(self,ndx):
        #获取左右孩子节点的下标
        left = 2 * ndx + 1
        right = 2 * ndx + 2
        #默认ndx为最大
        largest = ndx

        if(left < self._count and   #有左孩子
            self._elements[left] >= self._elements[largest] and
            self._elements[left] >= self._elements[right]):     #左孩子 > 右孩子
            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)


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']


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

    def push(self,priority,value):
        entry = (priority,value)    #push a tuple
        self._maxheap.add(entry)

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

    def is_empty(self):
        return len(self._maxheap) == 0
<think>好的,用户问的是Python中的优先级队列是什么。首先,我需要确定优先级队列的基本概念。优先级队列是一种数据结构,其中每个元素都有一个优先级,出队时按优先级最高的顺序处理。Python中通常用heapq模块或者queue.PriorityQueue类来实现。 接下来,我需要解释这两种方法的不同。heapq是一个模块,提供了基于列表的堆操作,需要手动处理元素的插入和弹出,而PriorityQueue是线程安全的类,内部使用heapq,封装了锁机制,适用于多线程环境。 然后,要给出具体的代码示例。对于heapq,通常使用heappush和heappop方法。需要注意的是,heapq默认是小根堆,所以如果要实现大根堆,可以将元素取负数存储。对于PriorityQueue,则是通过put和get方法来操作,同样默认是小根堆。 还需要提到元素可以是元组,其中第一个元素是优先级,这样在插入时会自动根据优先级排序。如果有相同优先级的元素,可能需要处理比较问题,比如添加次级比较条件,或者在元素类型中定义__lt__方法。 另外,可能的问题点包括线程安全、堆的结构是否正确维护等。例如,使用heapq时直接操作列表可能导致堆结构破坏,必须用提供的方法。而PriorityQueue在并发环境下更安全,但可能有性能开销。 最后,用户可能想知道应用场景,比如任务调度、Dijkstra算法等需要按优先级处理的情况。同时,可能的相关问题会涉及具体实现细节、线程安全、性能比较,以及如何自定义比较函数等。</think>中的优先级队列(Priority Queue)是一种数据结构,允许元素按优先级顺序出队。Python通过`heapq`模块和`queue.PriorityQueue`类提供实现。 ### 实现方式 #### 1. 使用`heapq`模块(基于列表的堆) ```python import heapq # 创建空堆 heap = [] # 插入元素(元组格式:优先级在前) heapq.heappush(heap, (2, "code")) heapq.heappush(heap, (1, "eat")) heapq.heappush(heap, (3, "sleep")) # 弹出最小优先级元素 while heap: print(heapq.heappop(heap)) # 输出 (1, 'eat') → (2, 'code') → (3, 'sleep') ``` #### 2. 使用`queue.PriorityQueue`(线程安全) ```python from queue import PriorityQueue pq = PriorityQueue() pq.put((2, "code")) pq.put((1, "eat")) pq.put((3, "sleep")) while not pq.empty(): print(pq.get()) # 输出顺序同上 ``` ### 特性说明 - **排序规则**:默认按元组第一个元素升序排列(最小堆) - **同优先级处理**:当优先级相同时,按第二个元素的自然顺序排序 - **大根堆实现**:插入负数实现降序排列 ```python # 大根堆示例 heapq.heappush(heap, (-5, "task1")) heapq.heappush(heap, (-3, "task2")) ``` ### 自定义对象排序 ```python class Task: def __init__(self, priority, name): self.priority = priority self.name = name def __lt__(self, other): return self.priority < other.priority heapq.heappush(heap, Task(2, "low")) heapq.heappush(heap, Task(1, "urgent")) ``` ### 应用场景 - 任务调度系统 - 路径搜索算法(如Dijkstra) - 事件驱动模拟 - Huffman编码
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值