数据结构与算法-05队列

队列

队列（Queue）是一种线性数据结构，它的特点是只能在一端进行插入操作，在另一端进行删除操作，这一端被称为队尾（Rear），另一端被称为队头（Front）。队列的插入操作称为入队（Enqueue），删除操作称为出队（Dequeue）。

队列的特点是先进先出（First In First Out，FIFO），也就是最先入队的元素最先出队，而最后入队的元素最后出队。队列的应用非常广泛，例如任务调度、消息传递、缓存等。

队列可以用数组或链表实现。用数组实现的队列称为顺序队列（Sequential Queue），用链表实现的队列称为链式队列（Linked Queue）。

顺序队列的实现比较简单，只需要一个数组和两个指针来表示队列即可。队头指针指向队头元素的位置，队尾指针指向队尾元素的下一个位置，入队操作将元素插入到队尾指针指向的位置，队尾指针加1；出队操作将队头指针加1，返回队头元素。

顺序队列的缺点是当队列满时无法再插入元素，即使队列中有空闲位置。为了解决这个问题，可以使用循环队列（Circular Queue），即将队列的头尾相连，形成一个环。

链式队列的实现也比较简单，只需要一个链表和两个指针来表示队列即可。队头指针指向链表的头节点，队尾指针指向链表的尾节点，入队操作将元素插入到链表的尾部，队尾指针指向新的尾节点；出队操作将链表的头节点删除，队头指针指向新的头节点。

队列的实现

class Queue(object):
    def __init__(self):
        self.__list = []

    def enqueue(self, item):
        self.__list.append(item)

    def dequeue(self):
        return self.__list.pop(0)

    def is_empty():
        return self.__list == []

    def size():
        return len(self.__list)

if __name__ == '__main__':
    q = Queue()
    q.enqueue(1)

双端队列的实现

class Dqueue(object):
    def __init__(self):
        self.__list = []

    def add_front(self, item):
        self.__list.insert(0, item)

    def add_rear(item):
        self.__list.append(item)

    def pop_front(self):
        return self.__list.pop(0)

    def pop_rear(self):
        return self.__list.pop()

    def is_empty():
        return self.__list == []

    def size():
        return len(self.__list)

if __name__ == '__main__':
    d = Dqueue()

优先级队列

优先级队列（Priority Queue）是一种特殊的队列，它的元素带有优先级。在优先级队列中，元素按照优先级从高到低排序，优先级相同的元素按照插入顺序排序。优先级队列的出队操作总是返回优先级最高的元素。

优先级队列的应用非常广泛，例如任务调度、事件处理、路由算法等。

优先级队列可以用堆（Heap）实现，堆是一种完全二叉树，满足堆序性质：对于每个节点，它的优先级大于等于（或小于等于）它的子节点的优先级。堆可以用数组实现，数组中的元素按照完全二叉树的顺序存储。

Python中的heapq模块提供了堆的实现，可以用它来实现优先级队列。heapq模块提供了一些函数，例如heappush、heappop、heapify等，可以用来插入元素、删除元素、构建堆等操作。

以下是Python实现一个优先级队列的示例代码：

import heapq

class PriorityQueue:
    def __init__(self):
        self.heap = []
        self.index = 0

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

    def put(self, item, priority):
        heapq.heappush(self.heap, (priority, self.index, item))
        self.index += 1

    def get(self):
        if self.is_empty():
            raise Exception("Queue is empty")
        _, _, item = heapq.heappop(self.heap)
        return item

这个优先级队列使用一个堆来存储元素，每个元素是一个三元组，包括优先级、插入顺序和元素本身。优先级越高的元素排在堆的前面，插入顺序相同的元素按照优先级排序。你可以根据自己的需求对这个示例代码进行修改和扩展。

Python中的queue

Python3中的queue模块提供了多种队列实现，包括FIFO队列、LIFO队列、优先级队列等。这些队列都是线程安全的，可以在多线程环境下使用。

FIFO队列（先进先出队列）：使用queue.Queue类实现，支持多线程环境下的并发操作。

import queue

q = queue.Queue()
q.put(1)
q.put(2)
q.put(3)
print(q.get())  # 1
print(q.get())  # 2
print(q.get())  # 3

LIFO队列（后进先出队列）：使用queue.LifoQueue类实现，支持多线程环境下的并发操作。

import queue

q = queue.LifoQueue()
q.put(1)
q.put(2)
q.put(3)
print(q.get())  # 3
print(q.get())  # 2
print(q.get())  # 1

优先级队列：使用queue.PriorityQueue类实现，支持多线程环境下的并发操作。元素按照优先级从小到大排序，优先级相同的元素按照插入顺序排序。

import queue

q = queue.PriorityQueue()
q.put((3, "apple"))
q.put((1, "banana"))
q.put((2, "orange"))
print(q.get())  # (1, 'banana')
print(q.get())  # (2, 'orange')
print(q.get())  # (3, 'apple')

除了以上三种队列实现，queue模块还提供了其他一些队列实现，例如使用deque双端队列实现的队列、使用heapq模块实现的堆队列等。你可以根据自己的需求选择合适的队列实现。