前言

在数据结构的学习中，栈和队列 是两种基础且重要的线性结构。它们的特点鲜明，应用场景广泛，是理解复杂数据结构（如树、图）和算法（如 DFS、BFS）的基础。本文将从概念、实现、应用场景等方面深入解析这两种结构，并对比它们的异同点。

一、栈：后进先出（LIFO）的线性结构

1. 1核心概念

定义：栈是一种只能在一端进行插入和删除操作的线性表，这一端称为栈顶（Top），另一端称为栈底（Bottom）。

特点：后进先出（Last In First Out，LIFO），即最后插入的元素最先被删除。

典型操作：

push()：向栈顶添加元素（入栈）。

pop()：从栈顶移除元素（出栈），并返回该元素。

peek()：查看栈顶元素但不删除。

isEmpty()：判断栈是否为空。

size()：返回栈中元素个数。

1.2 实现方式

方式一：顺序栈（用数组实现）

特点：利用数组的连续性存储元素，通过指针（索引）跟踪栈顶位置。

class Stack:
    def __init__(self):
        self.items = []  # 用列表模拟数组
    
    def push(self, item):
        self.items.append(item)  # 入栈操作
    
    def pop(self):
        if self.is_empty():
            raise IndexError("栈为空，无法出栈")
        return self.items.pop()  # 出栈操作，删除并返回栈顶元素
    
    def peek(self):
        if self.is_empty():
            raise IndexError("栈为空，无元素可查看")
        return self.items[-1]
    
    def is_empty(self):
        return len(self.items) == 0
    
    def size(self):
        return len(self.items)

方式二：链栈（用链表实现）

特点：用链表节点动态存储元素，栈顶为链表头节点，插入和删除操作时间复杂度均为 \(O(1)\)。

二、队列：先进先出（FIFO）的线性结构

2.1核心概念

定义：队列是一种 ** 只能在一端插入（队尾）、另一端删除（队头）** 的线性表。

特点：先进先出（First In First Out，FIFO），即最早插入的元素最先被删除。

典型操作：

enqueue()：向队尾添加元素（入队）。

dequeue()：从队头移除元素（出队），并返回该元素。

peek()：查看队头元素但不删除。

isEmpty()：判断队列是否为空。

size()：返回队列中元素个数。

2. 2实现方式

方式一：顺序队列（用数组实现）

class CircularQueue:
    def __init__(self, capacity):
        self.capacity = capacity
        self.items = [None] * capacity
        self.front = 0  # 队头指针（指向队头元素的前一个位置）
        self.rear = 0   # 队尾指针（指向队尾元素）
    
    def is_full(self):
        return (self.rear + 1) % self.capacity == self.front
    
    def is_empty(self):
        return self.front == self.rear
    
    def enqueue(self, item):
        if self.is_full():
            raise Exception("队列已满，无法入队")
        self.items[self.rear] = item
        self.rear = (self.rear + 1) % self.capacity  # 循环移动指针
    
    def dequeue(self):
        if self.is_empty():
            raise Exception("队列已空，无法出队")
        item = self.items[self.front]
        self.front = (self.front + 1) % self.capacity
        return item
    
    def peek(self):
        if self.is_empty():
            raise Exception("队列已空")
        return self.items[(self.front + 1) % self.capacity]

方式二：链队列（用链表实现）

特点：用链表存储元素，队头为链表头节点，队尾为链表尾节点，入队和出队操作时间复杂度均为 \(O(1)\)。

from collections import deque  # Python内置双端队列，可直接实现队列

# 用deque实现队列（队头左端，队尾右端）
queue = deque()
queue.append(1)   # 入队：enqueue(1)
queue.popleft()   # 出队：dequeue()，返回1

三、栈 vs 队列：核心对比

维度	栈（Stack）	队列（Queue）
数据访问	只能从栈顶操作（一端）	队头删除、队尾插入（两端）
逻辑特点	后进先出（LIFO）	先进先出（FIFO）
典型操作	push()、pop()、peek()	enqueue()、dequeue()、peek()
实现难点	顺序栈几乎无难点	顺序队列需处理循环队列问题
常见应用	递归、表达式求值、撤销操作	任务调度、BFS、消息队列

四、扩展：双端队列（Deque）

双端队列（Double-Ended Queue）是一种允许在两端进行插入和删除操作的数据结构，兼具栈和队列的特性。Python 的collections.deque模块提供了高效的双端队列实现，支持appendleft()、popleft()、append()、pop()等操作，适用于需要频繁两端操作的场景（如实现栈或队列的变种）。