python中如何顺序表和单链表实现队列

在Python中，可以使用顺序表（基于列表）和单链表来实现队列。以下是两种实现方式的详细说明和代码示例：

---

一、顺序表（基于动态列表）实现队列

原理：使用Python列表模拟队列，入队时在列表尾部添加元素，出队时从列表头部移除元素。但频繁的头部操作会导致时间复杂度较高。

class ListQueue:
    def __init__(self):
        self.items = []  # 用列表存储元素
    
    def enqueue(self, item):
        """入队：添加到列表尾部（O(1)时间）"""
        self.items.append(item)
    
    def dequeue(self):
        """出队：移除列表头部元素（O(n)时间）"""
        if not self.is_empty():
            return self.items.pop(0)
        return None  # 队列为空时返回None
    
    def is_empty(self):
        """判断队列是否为空"""
        return len(self.items) == 0
    
    def size(self):
        """返回队列长度"""
        return len(self.items)

# 示例用法
q = ListQueue()
q.enqueue(1)
q.enqueue(2)
print(q.dequeue())  # 输出 1

缺点：pop(0)的时间复杂度为O(n)，数据量大时效率低。

---

二、单链表实现队列

原理：通过链表节点连接，维护头尾指针，实现高效入队和出队操作。

class Node:
    """链表节点类"""
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedListQueue:
    def __init__(self):
        self.head = None  # 头指针（出队端）
        self.tail = None  # 尾指针（入队端）
    
    def enqueue(self, data):
        """入队：在链表尾部添加节点（O(1)时间）"""
        new_node = Node(data)
        if self.tail is None:  # 队列为空时，头尾均指向新节点
            self.head = new_node
            self.tail = new_node
        else:
            self.tail.next = new_node  # 将新节点链接到尾部
            self.tail = new_node       # 更新尾指针
    
    def dequeue(self):
        """出队：移除链表头部节点（O(1)时间）"""
        if self.head is None:
            return None  # 队列为空时返回None
        data = self.head.data
        self.head = self.head.next     # 头指针后移
        if self.head is None:          # 如果队列已空，重置尾指针
            self.tail = None
        return data
    
    def is_empty(self):
        """判断队列是否为空"""
        return self.head is None
    
    def size(self):
        """返回队列长度（遍历链表）"""
        count = 0
        current = self.head
        while current:
            count += 1
            current = current.next
        return count

# 示例用法
q = LinkedListQueue()
q.enqueue(1)
q.enqueue(2)
print(q.dequeue())  # 输出 1

优点：入队和出队的时间复杂度均为O(1)，效率更高。

---

三、两种实现的对比

实现方式	时间复杂度	空间复杂度	适用场景
顺序表（列表）	入队O(1)，出队O(n)	O(n)	数据量较小的场景
单链表	入队O(1)，出队O(1)	O(n)	高频入队/出队操作

---

四、扩展：循环队列（顺序表优化）

若需顺序表的高效实现，可使用循环队列（固定容量）来避免频繁移动元素：

class CircularQueue:
    def __init__(self, capacity):
        self.capacity = capacity
        self.queue = [None] * capacity
        self.front = 0    # 队头指针
        self.rear = 0     # 队尾指针
        self.size = 0     # 当前元素数量
    
    def enqueue(self, item):
        if self.size == self.capacity:
            raise Exception("队列已满")
        self.queue[self.rear] = item
        self.rear = (self.rear + 1) % self.capacity
        self.size += 1
    
    def dequeue(self):
        if self.size == 0:
            raise Exception("队列为空")
        item = self.queue[self.front]
        self.front = (self.front + 1) % self.capacity
        self.size -= 1
        return item

特点：通过模运算实现环形存储，入队和出队均为O(1)时间，但需要预先分配固定容量。

根据具体需求选择合适的实现方式。