栈与队列：数据结构基础与应用解析-代码聚汇网

栈与队列：数据结构基础与应用解析

栈队列数据结构

|难度：普通|阅读约 21 分钟

1. 栈与队列基础概念解析

在计算机科学中，栈(Stack)和队列(Queue)是两种最基本也最重要的线性数据结构。它们看似简单，却在算法设计和系统实现中扮演着关键角色。理解它们的本质差异，是解决相关编程题目的第一步。

1.1 栈：后进先出的数据容器

栈遵循LIFO(Last In First Out)原则，就像我们日常生活中叠放的盘子——最后放上去的盘子总是最先被取用。从技术实现角度看，栈有两个核心操作：

push(入栈)：将元素添加到栈顶
pop(出栈)：移除并返回栈顶元素

栈的一个典型应用场景是函数调用。当程序执行函数调用时，系统会使用调用栈(call stack)来保存返回地址、参数和局部变量。例如在递归函数中，每次递归调用都会在栈上创建一个新的栈帧(stack frame)。

注意：栈空间通常有限，过度递归可能导致栈溢出(Stack Overflow)错误。这是递归算法需要特别注意的问题。

1.2 队列：先进先出的数据管道

队列则遵循FIFO(First In First Out)原则，类似于现实生活中的排队场景——先来的人先获得服务。队列的基本操作包括：

enqueue(入队)：在队尾添加元素
dequeue(出队)：移除并返回队首元素

队列在计算机系统中有广泛应用，如：

操作系统中的进程调度队列
网络数据包缓冲
打印任务队列
消息队列系统

1.3 核心差异对比

通过下表可以清晰看到两者的本质区别：

特性	栈	队列
操作原则	LIFO(后进先出)	FIFO(先进先出)
插入位置	栈顶	队尾
删除位置	栈顶	队首
典型应用	函数调用、表达式求值	任务调度、缓冲处理
时间复杂度	O(1)的push/pop	O(1)的enqueue/dequeue

理解这些基础概念后，我们就能更好地应对各种栈和队列相关的算法题目。在实际编程中，大多数语言都提供了内置的栈和队列实现，但在面试或算法竞赛中，我们通常需要从零开始实现它们。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 栈的经典应用场景与解题技巧

2.1 括号匹配问题

括号匹配是栈最典型的应用之一。给定一个只包含括号字符的字符串，判断括号是否有效匹配。例如"()[]{}"是有效的，而"(]"则是无效的。

解决思路：

初始化一个空栈
遍历字符串中的每个字符：
- 如果是左括号(如'('、'['、'{')，将其压入栈
- 如果是右括号，检查栈顶元素是否与之匹配
  - 匹配则弹出栈顶
  - 不匹配则返回false
最后检查栈是否为空

python复制def isValid(s: str) -> bool:
    stack = []
    mapping = {")": "(", "]": "[", "}": "{"}
    for char in s:
        if char in mapping:
            top_element = stack.pop() if stack else '#'
            if mapping[char] != top_element:
                return False
        else:
            stack.append(char)
    return not stack

实战技巧：使用字典存储括号匹配关系可以简化代码逻辑。注意处理栈为空时的边界情况。

2.2 表达式求值

栈在表达式求值中也有重要应用，特别是处理运算符优先级和中缀表达式转后缀表达式。以计算"3 + 5 * 2"为例：

创建两个栈：操作数栈和运算符栈
遍历表达式：
- 数字直接压入操作数栈
- 运算符与栈顶运算符比较优先级
  - 当前优先级≤栈顶优先级：弹出栈顶运算符进行计算
  - 否则压入运算符栈
最后清空运算符栈进行计算

python复制def evaluateExpression(expression):
    def applyOp(a, b, op):
        if op == '+': return a + b
        if op == '-': return a - b
        if op == '*': return a * b
        if op == '/': return a // b
    
    values = []
    ops = []
    i = 0
    while i < len(expression):
        if expression[i] == ' ':
            i += 1
            continue
        elif expression[i] == '(':
            ops.append(expression[i])
        elif expression[i].isdigit():
            val = 0
            while i < len(expression) and expression[i].isdigit():
                val = val * 10 + int(expression[i])
                i += 1
            values.append(val)
            continue
        elif expression[i] == ')':
            while len(ops) != 0 and ops[-1] != '(':
                val2 = values.pop()
                val1 = values.pop()
                op = ops.pop()
                values.append(applyOp(val1, val2, op))
            ops.pop()  # 弹出左括号
        else:
            while (len(ops) != 0 and
                   precedence(ops[-1]) >= precedence(expression[i])):
                val2 = values.pop()
                val1 = values.pop()
                op = ops.pop()
                values.append(applyOp(val1, val2, op))
            ops.append(expression[i])
        i += 1
    
    while len(ops) != 0:
        val2 = values.pop()
        val1 = values.pop()
        op = ops.pop()
        values.append(applyOp(val1, val2, op))
    
    return values[-1]

2.3 单调栈的应用

单调栈是一种特殊的栈结构，其中的元素保持单调递增或递减的顺序。它在解决"下一个更大元素"、"柱状图中最大矩形"等问题时非常高效。

以"每日温度"问题为例：给定每日温度列表，返回需要等待多少天才能有更高温度的天数列表。

解法：

初始化一个空栈和结果数组
反向遍历温度数组
对于每个温度，弹出栈中所有比当前温度小的元素
如果栈不为空，栈顶元素就是第一个更高温度的天数
将当前温度索引入栈

python复制def dailyTemperatures(T):
    stack = []
    result = [0] * len(T)
    for i in range(len(T)-1, -1, -1):
        while stack and T[i] >= T[stack[-1]]:
            stack.pop()
        if stack:
            result[i] = stack[-1] - i
        stack.append(i)
    return result

经验分享：单调栈问题通常需要反向遍历数组，这样可以利用栈的LIFO特性找到"下一个"符合条件的元素。这类问题的时间复杂度通常是O(n)，因为每个元素最多入栈和出栈一次。

3. 队列的高级应用与变种

3.1 广度优先搜索(BFS)中的队列应用

队列是BFS算法的核心数据结构。在树或图的遍历中，BFS使用队列来保证按照层级顺序访问节点。以二叉树层序遍历为例：

python复制from collections import deque

def levelOrder(root):
    if not root:
        return []
    queue = deque([root])
    result = []
    while queue:
        level_size = len(queue)
        current_level = []
        for _ in range(level_size):
            node = queue.popleft()
            current_level.append(node.val)
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        result.append(current_level)
    return result

性能提示：在Python中，使用collections.deque比list实现队列更高效，因为deque的popleft()操作是O(1)时间复杂度，而list的pop(0)是O(n)。

3.2 优先队列与堆实现

优先队列是一种特殊的队列，其中元素按照优先级出队，而非插入顺序。它通常使用堆(Heap)数据结构实现。以"前K个高频元素"问题为例：

python复制import heapq
from collections import Counter

def topKFrequent(nums, k):
    count = Counter(nums)
    return heapq.nlargest(k, count.keys(), key=count.get)

堆的实现细节：

最小堆：父节点值≤子节点值
最大堆：父节点值≥子节点值
插入操作O(log n)
取出最值操作O(log n)

3.3 双端队列(Deque)与滑动窗口

双端队列允许在两端进行插入和删除操作，非常适合解决滑动窗口类问题。以"滑动窗口最大值"为例：

python复制from collections import deque

def maxSlidingWindow(nums, k):
    dq = deque()
    result = []
    for i in range(len(nums)):
        while dq and nums[i] >= nums[dq[-1]]:
            dq.pop()
        dq.append(i)
        if dq[0] == i - k:
            dq.popleft()
        if i >= k - 1:
            result.append(nums[dq[0]])
    return result

算法要点：

维护一个存储可能成为窗口最大值的索引的双端队列
新元素比队尾元素大时，弹出队尾元素
检查队首元素是否还在窗口范围内
当窗口形成后，队首元素即为当前窗口最大值

调试技巧：在处理滑动窗口问题时，建议先在纸上画出窗口移动过程，标注队列中元素的变化，这样能更直观地理解算法逻辑。

4. 栈与队列的综合应用与面试题精解

4.1 用队列实现栈

这是一个经典的面试问题，要求使用队列的基本操作来实现栈的功能。关键在于如何利用队列的FIFO特性模拟栈的LIFO特性。

解法一：使用两个队列，push操作O(1)，pop操作O(n)

python复制from collections import deque

class MyStack:
    def __init__(self):
        self.q1 = deque()
        self.q2 = deque()
        self._top = None

    def push(self, x: int) -> None:
        self.q1.append(x)
        self._top = x

    def pop(self) -> int:
        while len(self.q1) > 1:
            self._top = self.q1.popleft()
            self.q2.append(self._top)
        result = self.q1.popleft()
        self.q1, self.q2 = self.q2, self.q1
        return result

    def top(self) -> int:
        return self._top

    def empty(self) -> bool:
        return len(self.q1) == 0

解法二：使用单个队列，push操作O(n)，pop操作O(1)

python复制class MyStack:
    def __init__(self):
        self.q = deque()

    def push(self, x: int) -> None:
        self.q.append(x)
        for _ in range(len(self.q) - 1):
            self.q.append(self.q.popleft())

    def pop(self) -> int:
        return self.q.popleft()

    def top(self) -> int:
        return self.q[0]

    def empty(self) -> bool:
        return len(self.q) == 0

4.2 用栈实现队列

同样经典的问题，要求使用栈实现队列的FIFO特性。关键在于使用两个栈来反转元素顺序。

python复制class MyQueue:
    def __init__(self):
        self.stack1 = []
        self.stack2 = []

    def push(self, x: int) -> None:
        self.stack1.append(x)

    def pop(self) -> int:
        self.peek()
        return self.stack2.pop()

    def peek(self) -> int:
        if not self.stack2:
            while self.stack1:
                self.stack2.append(self.stack1.pop())
        return self.stack2[-1]

    def empty(self) -> bool:
        return not self.stack1 and not self.stack2

复杂度分析：摊还时间复杂度分析显示，每个元素最多被压入和弹出每个栈各一次，因此操作的平均时间复杂度为O(1)。

4.3 最小栈问题

设计一个支持push、pop、top操作，并能在常数时间内检索到最小元素的栈。

解法：使用辅助栈存储最小值

python复制class MinStack:
    def __init__(self):
        self.stack = []
        self.min_stack = []

    def push(self, val: int) -> None:
        self.stack.append(val)
        if not self.min_stack or val <= self.min_stack[-1]:
            self.min_stack.append(val)

    def pop(self) -> None:
        if self.stack.pop() == self.min_stack[-1]:
            self.min_stack.pop()

    def top(self) -> int:
        return self.stack[-1]

    def getMin(self) -> int:
        return self.min_stack[-1]

4.4 循环队列实现

循环队列是一种线性数据结构，其操作基于FIFO原则，并且队尾连接在队首形成一个循环。它能更有效地利用存储空间。

python复制class CircularQueue:
    def __init__(self, k: int):
        self.queue = [None] * k
        self.head = 0
        self.tail = -1
        self.size = 0
        self.capacity = k

    def enQueue(self, value: int) -> bool:
        if self.isFull():
            return False
        self.tail = (self.tail + 1) % self.capacity
        self.queue[self.tail] = value
        self.size += 1
        return True

    def deQueue(self) -> bool:
        if self.isEmpty():
            return False
        self.head = (self.head + 1) % self.capacity
        self.size -= 1
        return True

    def Front(self) -> int:
        if self.isEmpty():
            return -1
        return self.queue[self.head]

    def Rear(self) -> int:
        if self.isEmpty():
            return -1
        return self.queue[self.tail]

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

    def isFull(self) -> bool:
        return self.size == self.capacity

边界条件：循环队列实现中最容易出错的是判断队列空和满的条件。常见解决方案是：

使用size变量记录当前元素数量

或者浪费一个存储单元来区分空和满的状态

在实际面试中，栈和队列相关的问题往往考察候选人对基础数据结构的理解程度以及将理论应用于实际问题的能力。我建议在准备面试时，不仅要掌握这些数据结构的标准实现，还要理解它们在不同场景下的变种和应用。通过大量练习，你会逐渐培养出对这类问题的直觉，能够快速识别问题背后的数据结构需求。