首页手记优先队列入门教程：基础概念与实现方法

优先队列入门教程：基础概念与实现方法

标签：

算法与数据结构

概述

优先队列是一种特殊的数据结构，其中元素根据优先级进行排序，高优先级的元素优先被处理。优先队列在操作系统、路径查找算法和调度算法等领域有着广泛的应用。本文将详细介绍优先队列的基础概念、实现方法以及应用场景。

优先队列入门教程：基础概念与实现方法

优先队列简介

优先队列的基本定义

优先队列（Priority Queue）是一种特殊的队列数据结构，其中的元素根据优先级进行排序。优先队列中的元素具有不同的优先级，高优先级的元素会优先于低优先级的元素被处理。优先队列中的元素可以是任意类型的数据，但必须能够被比较，以确定它们的优先级。

优先队列与普通队列的区别

普通队列是遵循先进先出（First-In-First-Out, FIFO）原则的数据结构，即最先加入队列的元素最先被移除。而优先队列则不同，它遵循的是优先级高的元素优先出队的原则。优先队列中元素的优先级可以是任意正整数或浮点数，也可以是任意可比较的对象。

优先队列的应用场景

优先队列在实际应用中非常广泛，例如：

任务调度：在操作系统中，优先队列被用来调度进程，优先级高的进程会优先于优先级低的进程执行。
路径查找算法：在最短路径问题中，优先队列可用于存储待处理的节点。
调度算法：在各种调度算法中，优先队列可以用于选择下一个要执行的任务或操作。
事件触发：在事件驱动的系统中，优先队列可以用来存储待处理的事件。

优先队列的实现方法

基于数组的实现

基于数组的优先队列是一种简单直接的实现方式。数组的索引可以表示队列中的元素，数组中每个元素存储的是一个独立的对象或值。通常采用一个额外的优先级数组来存储每个元素的优先级。当插入或删除元素时，优先级数组中的元素需要重新排序。

插入元素

函数 insert 接收一个元素和它的优先级，并将该元素插入到优先队列中。

def insert(heap, priority, element):
    heap.append((priority, element))
    heap.sort()
    return heap

删除元素

函数 delete 删除优先级最高的元素。

def delete(heap):
    if not heap:
        return None
    highest_priority_element = heap.pop(0)
    return highest_priority_element

基于链表的实现

基于链表的优先队列实现与基于数组的实现相似，只是使用链表来存储元素，而不是数组。链表中的每个节点包含一个元素和该元素的优先级。当插入或删除元素时，需要遍历链表以确保优先级顺序。

class PriorityQueueNode:
    def __init__(self, priority, element):
        self.priority = priority
        self.element = element
        self.next = None

class PriorityQueue:
    def __init__(self):
        self.head = None

    def insert(self, priority, element):
        new_node = PriorityQueueNode(priority, element)
        if not self.head or priority < self.head.priority:
            new_node.next = self.head
            self.head = new_node
        else:
            current = self.head
            while current.next and priority >= current.next.priority:
                current = current.next
            new_node.next = current.next
            current.next = new_node

    def delete(self):
        if not self.head:
            return None
        deleted_node = self.head
        self.head = self.head.next
        return deleted_node

基于二叉堆的实现

基于二叉堆的优先队列实现更为高效。二叉堆是一种特殊的完全二叉树，它满足堆的性质，即每个节点的值都大于或等于（或小于）其子节点的值。二叉堆可以是最大堆（每个节点的值大于或等于其子节点的值）或最小堆（每个节点的值小于或等于其子节点的值）。

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

    def insert(self, priority, element):
        self.heap.append((priority, element))
        self._bubble_up(len(self.heap) - 1)

    def _bubble_up(self, index):
        while index > 0:
            parent = (index - 1) // 2
            if self.heap[parent][0] < self.heap[index][0]:
                self.heap[parent], self.heap[index] = self.heap[index], self.heap[parent]
                index = parent
            else:
                break

    def delete(self):
        if not self.heap:
            return None
        max_value = self.heap[0]
        self.heap[0] = self.heap[-1]
        self.heap.pop()
        self._heapify(0)
        return max_value

    def _heapify(self, index):
        left = 2 * index + 1
        right = 2 * index + 2
        largest = index
        if left < len(self.heap) and self.heap[left][0] > self.heap[largest][0]:
            largest = left
        if right < len(self.heap) and self.heap[right][0] > self.heap[largest][0]:
            largest = right
        if largest != index:
            self.heap[index], self.heap[largest] = self.heap[largest], self.heap[index]
            self._heapify(largest)

优先队列的操作详解

插入元素

插入操作通常涉及将新元素添加到优先队列中，并根据其优先级调整队列中的顺序。插入操作的时间复杂度取决于所选择的数据结构，例如基于数组的优先队列插入操作的时间复杂度为 O(n)，而基于二叉堆的优先队列插入操作的时间复杂度为 O(log n)。

删除元素

删除操作通常涉及从优先队列中移除具有最高优先级的元素。删除操作的时间复杂度同样取决于所选择的数据结构，例如基于数组的优先队列删除操作的时间复杂度为 O(n)，而基于二叉堆的优先队列删除操作的时间复杂度为 O(log n)。

访问优先元素

访问优先元素操作通常涉及返回具有最高优先级的元素，但不从优先队列中移除它。访问优先元素操作的时间复杂度通常为 O(1)，因为绝大多数实现都是通过直接访问优先队列的根节点或队列首元素来实现的。

优先队列在实际问题中的应用

最小生成树问题

最小生成树问题（Minimum Spanning Tree, MST）是图论中的一个重要问题，通常使用 Kruskal 算法和 Prim 算法来解决。其中，Prim 算法通常使用优先队列来存储待处理的边，优先队列中的每个元素是一个边，其优先级是边的权重。优先队列确保每次从优先队列中选择权重最小的边。

Kruskal 算法

Kruskal 算法通过不断地选择权重最小的边来构建最小生成树，直到树中的节点数等于图中的节点数。

def find(parent, i):
    if parent[i] == i:
        return i
    return find(parent, parent[i])

def union(parent, rank, x, y):
    xroot = find(parent, x)
    yroot = find(parent, y)
    if rank[xroot] < rank[yroot]:
        parent[xroot] = yroot
    elif rank[xroot] > rank[yroot]:
        parent[yroot] = xroot
    else:
        parent[yroot] = xroot
        rank[xroot] += 1

def kruskal(graph):
    result = []
    i = 0
    e = 0
    graph = sorted(graph, key=lambda item: item[2])
    parent = []
    rank = []
    for node in range(V):
        parent.append(node)
        rank.append(0)
    while e < V - 1 and i < len(graph):
        u, v, w = graph[i]
        i = i + 1
        x = find(parent, u)
        y = find(parent, v)
        if x != y:
            e = e + 1
            result.append([u, v, w])
            union(parent, rank, x, y)
    return result

Prim 算法

Prim 算法通过优先选择权重最小的边来构建最小生成树。

import heapq

def prim(graph, start):
    V = len(graph)
    dist = [float('inf')] * V
    dist[start] = 0
    visited = [False] * V
    min_heap = []
    for v, weight in enumerate(graph[start]):
        if weight > 0:
            heapq.heappush(min_heap, (weight, start, v))
    mst = []
    while min_heap:
        weight, u, v = heapq.heappop(min_heap)
        if not visited[v]:
            visited[v] = True
            mst.append((u, v, weight))
            for i, w in enumerate(graph[v]):
                if w > 0 and not visited[i]:
                    heapq.heappush(min_heap, (w, v, i))
    return mst

最短路径问题

最短路径问题（Shortest Path Problem）通常使用 Dijkstra 算法来解决。Dijkstra 算法也使用优先队列来存储待处理的节点，优先队列中的每个元素是一个节点，其优先级是到源节点的距离。优先队列确保每次从优先队列中选择距离源节点最近的节点。

import heapq

def dijkstra(graph, start):
    V = len(graph)
    dist = [float('inf')] * V
    dist[start] = 0
    min_heap = [(0, start)]
    visited = [False] * V
    while min_heap:
        current_dist, current_node = heapq.heappop(min_heap)
        if visited[current_node]:
            continue
        visited[current_node] = True
        for neighbor, weight in enumerate(graph[current_node]):
            if weight > 0 and dist[current_node] + weight < dist[neighbor]:
                dist[neighbor] = dist[current_node] + weight
                heapq.heappush(min_heap, (dist[neighbor], neighbor))
    return dist

任务调度

在任务调度中，优先队列被用来调度进程或任务。每个进程或任务具有不同的优先级，优先级高的任务会优先于优先级低的任务执行。优先队列可以确保高优先级任务优先执行。

class Process:
    def __init__(self, priority, name):
        self.priority = priority
        self.name = name

def execute_tasks(tasks):
    tasks.sort(key=lambda x: x.priority, reverse=True)
    for task in tasks:
        print(f'Executing task {task.name} with priority {task.priority}')

tasks = [
    Process(5, 'Task A'),
    Process(3, 'Task B'),
    Process(7, 'Task C'),
    Process(2, 'Task D')
]
execute_tasks(tasks)

优先队列的性能分析

时间复杂度分析

插入操作：基于数组的优先队列插入操作的时间复杂度为 O(n)，基于链表的优先队列插入操作的时间复杂度为 O(n)，基于二叉堆的优先队列插入操作的时间复杂度为 O(log n)。
删除操作：基于数组的优先队列删除操作的时间复杂度为 O(n)，基于链表的优先队列删除操作的时间复杂度为 O(n)，基于二叉堆的优先队列删除操作的时间复杂度为 O(log n)。
访问优先元素：访问优先元素操作的时间复杂度通常为 O(1)。

空间复杂度分析

基于数组的优先队列：空间复杂度为 O(n)，其中 n 为优先队列中的元素数量。
基于链表的优先队列：空间复杂度为 O(n)，其中 n 为优先队列中的元素数量。
基于二叉堆的优先队列：空间复杂度为 O(n)，其中 n 为优先队列中的元素数量。

不同实现方式的优缺点比较

基于数组的优先队列：
- 优点：实现简单。
- 缺点：插入和删除操作的时间复杂度较高，不适合大规模数据。
基于链表的优先队列：
- 优点：支持动态插入和删除，实现简单。
- 缺点：插入和删除操作的时间复杂度较高，空间利用率低。
基于二叉堆的优先队列：
- 优点：插入和删除操作的时间复杂度较低，适合大规模数据。
- 缺点：实现较为复杂，需要维护堆的性质。

实践练习与项目建议

编写一个简单的优先队列实现

根据上文介绍的不同实现方法，尝试编写一个简单的优先队列实现。可以选择基于数组、链表或二叉堆的实现方式。

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

    def insert(self, priority, element):
        self.heap.append((priority, element))
        self._bubble_up(len(self.heap) - 1)

    def _bubble_up(self, index):
        while index > 0:
            parent = (index - 1) // 2
            if self.heap[parent][0] < self.heap[index][0]:
                self.heap[parent], self.heap[index] = self.heap[index], self.heap[parent]
                index = parent
            else:
                break

    def delete(self):
        if not self.heap:
            return None
        max_value = self.heap[0]
        self.heap[0] = self.heap[-1]
        self.heap.pop()
        self._heapify(0)
        return max_value

    def _heapify(self, index):
        left = 2 * index + 1
        right = 2 * index + 2
        largest = index
        if left < len(self.heap) and self.heap[left][0] > self.heap[largest][0]:
            largest = left
        if right < len(self.heap) and self.heap[right][0] > self.heap[largest][0]:
            largest = right
        if largest != index:
            self.heap[index], self.heap[largest] = self.heap[largest], self.heap[index]
            self._heapify(largest)

应用优先队列解决实际问题

应用优先队列解决实际问题，例如最小生成树问题、最短路径问题或任务调度问题。尝试编写代码来解决这些问题，确保代码能够正确地使用优先队列来处理数据。

class Process:
    def __init__(self, priority, name):
        self.priority = priority
        self.name = name

def execute_tasks(tasks):
    tasks.sort(key=lambda x: x.priority, reverse=True)
    for task in tasks:
        print(f'Executing task {task.name} with priority {task.priority}')

tasks = [
    Process(5, 'Task A'),
    Process(3, 'Task B'),
    Process(7, 'Task C'),
    Process(2, 'Task D')
]
execute_tasks(tasks)

进一步探讨与学习方向

优先队列是一个重要的数据结构，可以用于解决许多实际问题。进一步学习可以探索更多高级数据结构，如红黑树、B 树等，了解它们在不同场景下的应用。此外，还可以学习其他算法，如动态规划、贪心算法等，这些算法常常需要利用优先队列来优化其性能。

通过编写代码来实现优先队列的不同变体，并将其应用于实际问题，可以加深对优先队列的理解。还可以尝试编写更复杂的算法，例如 K 最近邻算法（K-Nearest Neighbor, KNN）或图的连通性问题，这些算法也经常使用优先队列来优化其性能。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

UYOU

手记
篇

粉丝

86

获赞与收藏

459

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30809 345

网络编程入门教程

20个小节 12721 239

Pandas 入门教程

25个小节 18600 342

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

优先队列入门教程：基础概念与实现方法

优先队列的基本定义

优先队列与普通队列的区别

优先队列的应用场景

基于数组的实现

插入元素

删除元素

基于链表的实现

基于二叉堆的实现

插入元素

删除元素

访问优先元素

最小生成树问题

Kruskal 算法

Prim 算法

最短路径问题

任务调度

时间复杂度分析

空间复杂度分析

不同实现方式的优缺点比较

编写一个简单的优先队列实现

应用优先队列解决实际问题

进一步探讨与学习方向

阅读免费教程