队列数组和链表的实现

队列 Queue

队列也是一种约束型数据结构，它跟栈的功能正好相反，遵循“先进先出，后进后出”原则，从它的名字我们就可以看出来。

队列的应用

队列在计算机中是一种朴素直观的设计应用，在各个领域都可以看见其身影。比如我们的 HTTP 请求，在服务器资源不足的情况下，它会天然的形成队列，先进先访问；再比如多线程软件，众多线程在资源不足的情况下也是按照队列的方式等待的。

队列的实现

数组的实现

from typing import Optional


class ArrayQueue:
    def __init__(self, capacity: int):
        self.items: list = [None] * capacity
        self.capacity = capacity
        self.head = 0
        self.tail = 0

    # 入队
    def enqueue(self, item: str) -> bool:
        if self.tail == self.capacity:
            return False
        self.items[self.tail] = item
        self.tail += 1
        return True

    # 出队
    def dequeue(self) -> Optional[str]:
        if self.head == self.tail:
            return None
        item = self.items[self.head]
        self.head += 1
        return item

    def __repr__(self) -> str:
        return str(self.items[self.head:self.tail])


if __name__ == "__main__":
    q = ArrayQueue(5)
    for i in range(5):
        q.enqueue(str(i))
    print(q)

    for _ in range(3):
        q.dequeue()
    print(q)

链表的实现

from typing import Optional


class ListNode:
    def __init__(self, data: str, next=None):
        self.data = data
        self.next = next


class LinkedQueue:
    def __init__(self):
        self.head: Optional[ListNode] = None
        self.tail: Optional[ListNode] = None

    # 入队
    def enqueue(self, value: str):
        new_node = ListNode(value)
        if self.tail:
            self.tail.next = new_node
        else:
            self.head = new_node
        self.tail = new_node

    # 出队
    def dequeue(self) -> Optional[str]:
        if self.head:
            value = self.head.data
            self.head = self.head.next
            if not self.head:
                self.tail = None
            return value

    def __repr__(self) -> str:
        values = []
        p: ListNode = self.head
        while p:
            values.append(p.data)
            p = p.next
        return "->".join(values)


if __name__ == "__main__":
    q = LinkedQueue()
    for i in range(5):
        q.enqueue(str(i))
    print(q)

    for _ in range(3):
        q.dequeue()
    print(q)

个人观点

栈和队列这种约束型的数据结构（按照它的严格约束型定义，不存在中间插入、删除和查询的功能），采用链表实现更加合理一点，无论是从动态拓展，还是开辟内存空间的角度来讲。另外数组在实现队列的过程中，随着队头和队尾的前移不能回退，使得它就像一次性的，这看上去也是一大弊端。