【轻松掌握数据结构与算法】队列：先进先出的数据结构

本文链接：https://blog.youkuaiyun.com/Whoisbug/article/details/145085376

队列（Queue）是一种先进先出（FIFO, First In First Out）的数据结构，它只允许在一端进行插入操作，在另一端进行删除操作。队列在计算机科学中有着广泛的应用，例如任务调度、消息传递、缓冲区管理等。本文将详细介绍队列的基本概念、操作以及应用场景，并通过示例和图表来帮助你更好地理解队列。

队列的基本概念

队列是一种线性数据结构，它遵循先进先出的原则。队列的主要操作包括：

enqueue：将一个元素添加到队列的尾部。
dequeue：移除队列头部的元素并返回。
peek 或 front：返回队列头部的元素但不移除。
is_empty：检查队列是否为空。
size：返回队列中元素的数量。

队列的实现

队列可以通过数组或链表来实现。数组实现的队列具有固定的大小，而链表实现的队列可以动态扩展。

数组实现的队列

class Queue:
    def __init__(self, capacity):
        self.capacity = capacity
        self.queue = [None] * capacity
        self.front = 0
        self.rear = -1
        self.size = 0

    def enqueue(self, value):
        if self.size == self.capacity:
            raise Exception("Queue overflow")
        self.rear = (self.rear + 1) % self.capacity
        self.queue[self.rear] = value
        self.size += 1

    def dequeue(self):
        if self.size == 0:
            raise Exception("Queue underflow")
        value = self.queue[self.front]
        self.front = (self.front + 1) % self.capacity
        self.size -= 1
        return value

    def peek(self):
        if self.size == 0:
            return None
        return self.queue[self.front]

    def is_empty(self):
        return self.size == 0

    def size(self):
        return self.size

# 示例
queue = Queue(5)
queue.enqueue(1)  # 队列: [1]
queue.enqueue(2)  # 队列: [1, 2]
queue.enqueue(3)  # 队列: [1, 2, 3]
print(queue.peek())  # 输出: 1
print(queue.dequeue())  # 输出: 1, 队列: [2, 3]
print(queue.is_empty())  # 输出: False
print(queue.size())  # 输出: 2

链表实现的队列

class ListNode:
    def __init__(self, value=0, next=None):
        self.value = value
        self.next = next

class Queue:
    def __init__(self):
        self.head = None
        self.tail = None
        self.size = 0

    def enqueue(self, value):
        new_node = ListNode(value)
        if self.tail is None:
            self.head = self.tail = new_node
        else:
            self.tail.next = new_node
            self.tail = new_node
        self.size += 1

    def dequeue(self):
        if self.head is None:
            raise Exception("Queue underflow")
        value = self.head.value
        self.head = self.head.next
        if self.head is None:
            self.tail = None
        self.size -= 1
        return value

    def peek(self):
        if self.head is None:
            return None
        return self.head.value

    def is_empty(self):
        return self.head is None

    def size(self):
        return self.size

# 示例
queue = Queue()
queue.enqueue(1)  # 队列: [1]
queue.enqueue(2)  # 队列: [1, 2]
queue.enqueue(3)  # 队列: [1, 2, 3]
print(queue.peek())  # 输出: 1
print(queue.dequeue())  # 输出: 1, 队列: [2, 3]
print(queue.is_empty())  # 输出: False
print(queue.size())  # 输出: 2

队列的操作示意图

1. enqueue 操作

概念：将一个元素添加到队列的尾部。

示意图：

初始状态：
队尾               队头
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+

enqueue(1)
+---+---+---+---+
| 1 |   |   |   |
+---+---+---+---+

enqueue(2)
+---+---+---+---+
| 1 | 2 |   |   |
+---+---+---+---+

2. dequeue 操作

概念：移除队列头部的元素并返回。

示意图：

初始状态：
队尾               队头
+---+---+---+---+
| 1 | 2 | 3 |   |
+---+---+---+---+

dequeue()
+---+---+---+---+
|   | 2 | 3 |   |
+---+---+---+---+

dequeue()
+---+---+---+---+
|   |   | 3 |   |
+---+---+---+---+

3. peek 操作

概念：返回队列头部的元素但不移除。

示意图：

初始状态：
队尾               队头
+---+---+---+---+
| 1 | 2 | 3 |   |
+---+---+---+---+

peek()
返回 1

4. is_empty 操作

概念：检查队列是否为空。

示意图：

初始状态：
队尾               队头
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+

is_empty()
返回 True

enqueue(1)
+---+---+---+---+
| 1 |   |   |   |
+---+---+---+---+

is_empty()
返回 False

5. size 操作

概念：返回队列中元素的数量。

示意图：

初始状态：
队尾               队头
+---+---+---+---+
| 1 | 2 | 3 |   |
+---+---+---+---+

size()
返回 3

队列的应用场景

队列在许多计算机科学问题中都有广泛的应用。以下是一些常见的应用场景和详细的示例。

1. 任务调度

任务调度是操作系统中的一个重要功能，它使用队列来管理进程的执行顺序。以下是一个简单的任务调度示例，展示如何使用队列来管理任务。

class Task:
    def __init__(self, id, name):
        self.id = id
        self.name = name

class TaskScheduler:
    def __init__(self):
        self.queue = Queue()

    def add_task(self, task):
        self.queue.enqueue(task)

    def run_task(self):
        if self.queue.is_empty():
            print("No tasks to run")
            return
        task = self.queue.dequeue()
        print(f"Running task: {task.name} (ID: {task.id})")

# 示例
scheduler = TaskScheduler()
scheduler.add_task(Task(1, "Task 1"))
scheduler.add_task(Task(2, "Task 2"))
scheduler.add_task(Task(3, "Task 3"))

scheduler.run_task()  # 输出: Running task: Task 1 (ID: 1)
scheduler.run_task()  # 输出: Running task: Task 2 (ID: 2)
scheduler.run_task()  # 输出: Running task: Task 3 (ID: 3)

2. 消息传递

消息传递系统使用队列来管理消息的发送和接收。以下是一个简单的消息传递示例，展示如何使用队列来管理消息。

class Message:
    def __init__(self, id, content):
        self.id = id
        self.content = content

class MessageQueue:
    def __init__(self):
        self.queue = Queue()

    def send_message(self, message):
        self.queue.enqueue(message)

    def receive_message(self):
        if self.queue.is_empty():
            print("No messages to receive")
            return
        message = self.queue.dequeue()
        print(f"Received message: {message.content} (ID: {message.id})")

# 示例
message_queue = MessageQueue()
message_queue.send_message(Message(1, "Hello"))
message_queue.send_message(Message(2, "World"))

message_queue.receive_message()  # 输出: Received message: Hello (ID: 1)
message_queue.receive_message()  # 输出: Received message: World (ID: 2)

3. 缓冲区管理

缓冲区管理是计算机系统中的一个重要功能，它使用队列来管理数据的读写操作。以下是一个简单的缓冲区管理示例，展示如何使用队列来管理缓冲区。

class Buffer:
    def __init__(self, capacity):
        self.queue = Queue(capacity)

    def write(self, data):
        if self.queue.is_full():
            print("Buffer is full, cannot write")
            return
        self.queue.enqueue(data)
        print(f"Written data: {data}")

    def read(self):
        if self.queue.is_empty():
            print("Buffer is empty, cannot read")
            return
        data = self.queue.dequeue()
        print(f"Read data: {data}")
        return data

# 示例
buffer = Buffer(3)
buffer.write(1)  # 输出: Written data: 1
buffer.write(2)  # 输出: Written data: 2
buffer.write(3)  # 输出: Written data: 3
buffer.write(4)  # 输出: Buffer is full, cannot write

buffer.read()  # 输出: Read data: 1
buffer.read()  # 输出: Read data: 2
buffer.read()  # 输出: Read data: 3
buffer.read()  # 输出: Buffer is empty, cannot read