数据结构 | 队列 | 问题1

什么是队列？

队列是一种基于先进先出（FIFO）原则的数据结构。与栈不同的是，队列是在两端进行操作的，其中添加操作称为入队，删除操作称为出队。新元素都是被添加在队列的末尾，老元素都是被删除在队列的开头。队列常常用于实现缓存、广度优先搜索等算法。

队列的实现

队列有多种实现方法，包括数组实现、链表实现和循环队列实现等。

数组实现队列

数组实现队列是最简单、也最易理解的一种实现方式。具体实现方法是通过一个数组来存储队列中的元素，并使用两个指针来记录队列的开头和结尾的位置。

class ArrayQueue:
    def __init__(self, capacity):
        self.capacity = capacity
        self.queue = [None] * self.capacity
        self.head = 0  # 指向队列的第一项
        self.tail = 0  # 指向队列的最后一项

    def is_empty(self):
        return self.head == self.tail

    def is_full(self):
        return (self.tail + 1) % self.capacity == self.head

    def enqueue(self, val):
        if not self.is_full():
            self.queue[self.tail] = val
            self.tail = (self.tail + 1) % self.capacity
            return True
        return False

    def dequeue(self):
        if not self.is_empty():
            val = self.queue[self.head]
            self.head = (self.head + 1) % self.capacity
            return val
        return None

链表实现队列

链表实现队列是一种基于链表的实现方法，其实现原理与数组实现类似。不同之处在于，链表实现可以动态分配内存，从而更加灵活。另外，链表实现可以在头部、中间或尾部添加或删除元素。

class LinkedNode:
    def __init__(self, val):
        self.val = val
        self.next = None


class LinkedQueue:
    def __init__(self):
        self.head = None
        self.tail = None

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

    def enqueue(self, val):
        node = LinkedNode(val)
        if self.tail is None:
            self.head, self.tail = node, node
        else:
            self.tail.next = node
            self.tail = node
        return True

    def dequeue(self):
        if not self.is_empty():
            val = self.head.val
            self.head = self.head.next
            if self.head is None:
                self.tail = None
            return val
        return None

循环队列实现队列

循环队列是一种基于数组实现的队列。它可以规避数组实现队列的一个重要缺陷：当队列的头部指针超过数组的结尾时，需要将头部指针重新置为0；同理，当队列的尾部指针超过数组的结尾时，需要将尾部指针重新置为0。

class CircularQueue:
    def __init__(self, capacity):
        self.capacity = capacity
        self.queue = [None] * self.capacity
        self.head = 0  # 指向队列的第一项
        self.tail = 0  # 指向队列的最后一项

    def is_empty(self):
        return self.head == self.tail

    def is_full(self):
        return (self.tail + 1) % self.capacity == self.head

    def enqueue(self, val):
        if not self.is_full():
            self.queue[self.tail] = val
            self.tail = (self.tail + 1) % self.capacity
            return True
        return False

    def dequeue(self):
        if not self.is_empty():
            val = self.queue[self.head]
            self.head = (self.head + 1) % self.capacity
            return val
        return None

问题1：设计循环队列的底层数据结构

需求：设计循环队列的底层数据结构，包括定义变量、初始化、判空、判满、入队、出队等基本操作。

实现：

class MyCircularQueue:
    def __init__(self, k: int):
        self.Q = [0] * k  # 存储队列的数组
        self.front = 0  # 指向队列的第一项
        self.rear = 0  # 指向队列的最后一项
        self.size = 0  # 队列中的元素个数
        self.k = k  # 队列的容量

    def is_empty(self) -> bool:
        return self.size == 0

    def is_full(self) -> bool:
        return self.size == self.k

    def en_queue(self, value: int) -> bool:
        if self.is_full():
            return False
        self.size += 1
        self.Q[self.rear] = value
        self.rear = (self.rear + 1) % self.k
        return True

    def de_queue(self) -> bool:
        if self.is_empty():
            return False
        self.size -= 1
        self.front = (self.front + 1) % self.k
        return True

    def front(self) -> int:
        if self.is_empty():
            return -1
        return self.Q[self.front]

    def rear(self) -> int:
        if self.is_empty():
            return -1
        return self.Q[(self.rear - 1 + self.k) % self.k]

总结

队列是一种常用的数据结构，常用于实现缓存、广度优先搜索等算法。常见的队列实现方法包括数组实现、链表实现和循环队列实现。本文重点介绍了循环队列的底层数据结构设计，并提供了一个示例实现。