Python 数据结构 之 队列（Queue）

Python 中的队列（Queue）概述

队列是一种遵循先进先出（FIFO, First In First Out）原则的线性数据结构，这意味着最早进入队列的元素将最先被移除。常用于任务调度、缓冲区管理等场景。Python 提供了多种实现队列的方式，包括内置模块和第三方库。

---

Python中queue的主要类型

Python的queue模块

提供了几种常用的队列类型，每种类型都有其独特的特性和应用场景。

1. Queue

Queue是最基本的队列实现，适用于多线程编程。它提供了线程安全的操作，确保在多线程环境下数据的完整性和一致性。常用方法包括：

● put(item): 将item放入队列。

● get(): 从队列中移除并返回一个元素。如果队列为空，将阻塞等待直到有元素可用。

● empty(): 判断队列是否为空。

● full(): 判断队列是否已满（仅当设置了最大大小时有效）。

2. LifoQueue

LifoQueue（Last In First Out）是一种后进先出队列，类似于栈。它的应用场景包括需要逆序处理数据的场合。主要方法与Queue类似，但元素的出队顺序相反。

3. PriorityQueue

PriorityQueue是一种优先级队列，元素按照优先级顺序出队。在构造队列时，每个元素需要关联一个优先级值，通常是一个数字或元组。优先级最低的元素将最先被取出。这在任务调度、事件处理等场景中非常有用。

---

队列的核心操作

队列通常支持以下基本操作：

• 入队（Enqueue）：将元素添加到队列尾部。
• 出队（Dequeue）：移除并返回队列头部的元素。
• 查看队首（Peek）：返回队列头部的元素但不移除。
• 判断空（is_empty）：检查队列是否为空。
• 获取大小（size）：返回队列中元素的数量。

代码示例：

class Queue：
    def __init__(self, value):
        new_node = Node(value)
        self.first = new_node
        self.last = new_node
        self.length = 1

    # 打印队列
    def print_queue(self):
        temp = self.first
        while temp is not None:
            print(temp.value)
            temp = temp.next

    # 入队
    def enqueue(self, value):
        new_node = Node(value)
        if self.first is None:
            self.first = new_node
            self.last = new_node
        else:
            self.last.next = new_node
            self.last = new_node
        self.length += 1

    # 出队
    def dequeue(self):
        if self.length == 0:
            return None
        temp = self.first
        if self.length == 1:
            self.first = None
            self.last = None
        else:
            self.first = self.first.next
            temp.next = None
        self.length -= 1
        return temp


my_queue = Queue(1)
my_queue.enqueue(2)

my_queue.print_queue()

print(my_queue.dequeue())

---

Python 实现队列的三种方法

使用 list 实现队列

Python 的列表可以模拟队列，但效率较低（出队操作时间复杂度为 O(n)）。

queue = []
queue.append(1)  # 入队
queue.append(2)
item = queue.pop(0)  # 出队（效率低）
print(item)  # 输出: 1

使用 collections.deque 实现队列

deque 是双端队列，适合高效的队列操作（入队和出队时间复杂度均为 O(1)）。

from collections import deque
queue = deque()
queue.append(1)  # 入队
queue.append(2)
item = queue.popleft()  # 出队
print(item)  # 输出: 1

使用 queue.Queue 实现线程安全队列

queue.Queue 是线程安全的队列实现，适用于多线程编程。

from queue import Queue
q = Queue()
q.put(1)  # 入队
q.put(2)
item = q.get()  # 出队
print(item)  # 输出: 1

---

队列的应用场景

1. 多线程编程

在多线程编程中，queue常用于线程间通信。

例如，生产者-消费者模型中，生产者线程将数据放入队列，消费者线程从队列中取出数据进行处理。这种方式可以有效避免线程间的竞争条件，提高程序的并发性能。

from queue import Queue
import threading

def producer(q):
    for i in range(5):
        q.put(i)
        print(f"Produced: {i}")

def consumer(q):
    while True:
        item = q.get()
        if item is None:
            break
        print(f"Consumed: {item}")
        q.task_done()

q = Queue()
p = threading.Thread(target=producer, args=(q,))
c = threading.Thread(target=consumer, args=(q,))

p.start()
c.start()

p.join()
q.put(None)  # 通知消费者结束
c.join()

2. 任务调度

PriorityQueue可以用于实现任务调度系统。通过为每个任务分配优先级，确保高优先级的任务能够优先执行。这在操作系统调度、网络请求处理等场景中尤为重要。

from queue import PriorityQueue

def process_tasks():
    task_queue = PriorityQueue()
    
    # 添加任务，优先级值越低，优先级越高
    task_queue.put((1, 'High Priority Task'))
    task_queue.put((3, 'Low Priority Task'))
    task_queue.put((2, 'Medium Priority Task'))
    
    while not task_queue.empty():
        priority, task = task_queue.get()
        print(f"Processing task with priority {priority}: {task}")

process_tasks()

3. 广度优先搜索（BFS）

在图的遍历算法中，queue常用于实现广度优先搜索。通过将待访问的节点依次入队，并按顺序出队进行访问，可以保证按层次遍历图结构。

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    
    while queue:
        node = queue.popleft()
        if node in visited:
            continue
        visited.add(node)
        print(f"Visiting node: {node}")
        
        # 将相邻节点入队
        for neighbor in graph[node]:
            if neighbor not in visited:
                queue.append(neighbor)

# 示例图
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}

bfs(graph, 'A')

---

优先级队列（扩展）

如果需要按优先级出队，可以使用 heapq 模块或 queue.PriorityQueue。

import heapq
pq = []
heapq.heappush(pq, (2, "任务B"))  # (优先级, 任务)
heapq.heappush(pq, (1, "任务A"))
item = heapq.heappop(pq)  # 按优先级出队
print(item[1])  # 输出: "任务A"

---

注意事项

1. 单线程场景优先选择 deque，因性能更高。
2. 多线程场景必须使用 queue.Queue 避免竞争条件。
3. 避免用 list 直接实现队列，因出队操作效率低。

---

总结

Python中的queue模块提供了多种队列实现，每种类型都有其独特的应用场景。无论是多线程编程中的线程安全通信，还是任务调度中的优先级管理，亦或是图算法中的广度优先搜索，queue都发挥着不可或缺的作用。通过合理选择和使用队列，开发者可以编写出更加高效、可读性更强的程序。在实际开发中，深入理解queue的特性和应用场景，将有助于解决各种复杂的编程问题。