栈与队列：LeetCode经典题解与实战技巧

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

在算法与数据结构的世界里，栈(Stack)和队列(Queue)是两种最基础也最重要的线性数据结构。它们看似简单，却在LeetCode题目中扮演着关键角色。理解它们的本质差异，是解决相关问题的第一步。

栈遵循LIFO(Last In First Out)原则，就像我们日常叠放的盘子——最后放上去的盘子总是最先被取用。这种特性使得栈特别适合处理需要"回退"操作的场景，比如函数调用栈、括号匹配、浏览器前进后退等。栈的核心操作只有两个：push(压栈)和pop(弹栈)，时间复杂度都是O(1)。

队列则遵循FIFO(First In First Out)原则，如同现实中的排队——先来的人先获得服务。这种特性让队列天然适合任务调度、消息处理等场景。队列的基本操作包括enqueue(入队)和dequeue(出队)，同样保持O(1)的时间效率。

关键区别：栈是"后来居上"，队列是"先到先得"。这个根本差异决定了它们在算法问题中的不同应用场景。

2. LeetCode经典栈问题实战

2.1 有效的括号（#20）

这是栈结构的"Hello World"级问题。给定一个只包含括号字符的字符串，判断括号是否有效匹配。栈的LIFO特性在这里大显身手：

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

这个解法巧妙地利用字典建立括号映射关系，当遇到右括号时，检查栈顶是否匹配对应的左括号。注意边界条件的处理——空栈时pop会出错，需要特殊处理。

实战技巧：Python中可以用列表直接模拟栈，但要注意pop(0)是O(n)操作，不符合栈的规范用法。正确的栈操作应始终在列表末尾进行。

2.2 逆波兰表达式求值（#150）

逆波兰表示法（后缀表达式）的计算是栈的经典应用。与常规的中缀表达式不同，它不需要括号就能明确运算顺序：

code复制输入: tokens = ["2","1","+","3","*"]
输出: 9
解释: ((2 + 1) * 3) = 9

解法步骤：

1. 初始化空栈
2. 遍历token：
   • 遇到数字：压栈
   • 遇到运算符：弹出栈顶两个数字运算，结果压栈
3. 最后栈中剩余元素即为结果

python复制def evalRPN(tokens):
    stack = []
    ops = {
        '+': lambda a, b: a + b,
        '-': lambda a, b: a - b,
        '*': lambda a, b: a * b,
        '/': lambda a, b: int(a / b)  # 题目要求的除法方式
    }
    for token in tokens:
        if token in ops:
            b = stack.pop()
            a = stack.pop()
            stack.append(ops[token](a, b))
        else:
            stack.append(int(token))
    return stack[0]

易错点：注意除法的处理方式不是简单的//，而需要先常规除法再取整。同时操作数顺序很重要，先弹出的是右操作数。

3. 队列的典型应用场景

3.1 滑动窗口最大值（#239）

这是队列应用的标杆题目，要求在数组的滑动窗口中找到最大值。暴力解法O(nk)效率太低，使用双端队列(Deque)可以优化到O(n)：

python复制from collections import deque

def maxSlidingWindow(nums, k):
    q = deque()
    result = []
    for i, num in enumerate(nums):
        while q and nums[q[-1]] < num:
            q.pop()  # 移除比当前小的元素
        q.append(i)
        if q[0] == i - k:  # 移除超出窗口的元素
            q.popleft()
        if i >= k - 1:
            result.append(nums[q[0]])
    return result

这个解法维护一个单调递减队列，队首始终是当前窗口最大值。关键在于及时移除：

1. 窗口外的过期元素
2. 不可能成为最大值的较小元素

性能对比：暴力解法在10^5规模数据下会超时，而单调队列解法轻松应对。这是算法面试的常考点。

3.2 用栈实现队列（#232）与用队列实现栈（#225）

这两道题考察对数据结构本质的理解。看似简单的题目，却难倒了不少面试者。

用栈实现队列需要两个栈(inStack和outStack)：

• push时直接压入inStack
• pop/peek时如果outStack为空，则将inStack元素全部弹出压入outStack

python复制class MyQueue:
    def __init__(self):
        self.in_stack = []
        self.out_stack = []

    def push(self, x):
        self.in_stack.append(x)

    def pop(self):
        self.peek()
        return self.out_stack.pop()

    def peek(self):
        if not self.out_stack:
            while self.in_stack:
                self.out_stack.append(self.in_stack.pop())
        return self.out_stack[-1]

    def empty(self):
        return not self.in_stack and not self.out_stack

用队列实现栈也有两种思路：

1. 双队列法：一个队列为主队列，另一个辅助队列用于倒腾元素
2. 单队列法：每次push后循环n-1次，将队首元素移到队尾

python复制from collections import deque

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

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

    def pop(self):
        return self.q.popleft()

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

    def empty(self):
        return not self.q

复杂度分析：用栈实现队列的均摊时间复杂度是O(1)，而用队列实现栈的push操作是O(n)。这是由数据结构本质差异决定的。

4. 进阶应用与解题技巧

4.1 单调栈的魔力

单调栈是解决"下一个更大元素"类问题的利器。以#496下一个更大元素I为例：

python复制def nextGreaterElement(nums1, nums2):
    stack = []
    mapping = {}
    for num in nums2:
        while stack and num > stack[-1]:
            mapping[stack.pop()] = num
        stack.append(num)
    return [mapping.get(num, -1) for num in nums1]

这个解法维护一个单调递减栈，当遇到比栈顶大的元素时，就找到了栈顶元素的下一个更大元素。

单调栈的典型应用场景：

• 柱状图中最大矩形(#84)
• 每日温度(#739)
• 接雨水(#42)

经验之谈：遇到"寻找左边/右边第一个比当前大/小的元素"这类描述，优先考虑单调栈解法。

4.2 优先队列的应用

虽然严格来说优先队列(PriorityQueue/Heap)不属于基础队列，但在LeetCode中常与队列问题结合出现。比如#347前K个高频元素：

python复制import heapq
from collections import Counter

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

Python的heapq模块实现了最小堆，要获取最大的k个元素可以使用nlargest方法。更标准的解法是维护一个大小为k的最小堆：

python复制def topKFrequent(nums, k):
    count = Counter(nums)
    heap = []
    for num, freq in count.items():
        if len(heap) < k:
            heapq.heappush(heap, (freq, num))
        else:
            if freq > heap[0][0]:
                heapq.heappop(heap)
                heapq.heappush(heap, (freq, num))
    return [num for freq, num in heap]

性能对比：当k远小于n时，堆解法O(nlogk)比排序O(nlogn)更高效。这是处理TopK问题的标准思路。

4.3 设计循环队列(#622)

循环队列可以避免普通队列在出队时的数据搬移，提高空间利用率。关键点：

• 使用数组实现
• 维护head和tail指针
• 区分队列满和队列空的判断条件

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

    def enQueue(self, value):
        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):
        if self.isEmpty():
            return False
        self.head = (self.head + 1) % self.capacity
        self.size -= 1
        return True

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

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

    def isEmpty(self):
        return self.size == 0

    def isFull(self):
        return self.size == self.capacity

设计要点：循环队列的关键是取模运算实现指针循环，以及通过size变量简化满/空判断。这是系统设计中的基础组件。