栈、队列、优先级队列面试通关：原理、模板与高频题套路

栈、队列、优先级队列这三块，基本是算法面试里绕不开的送分题，也是拉开差距的坎。很多人刷题时觉得单个知识点会了，可一到综合题就发懵，其实核心原因是没把这三类数据结构的底层机制吃透，也没归纳出高频题背后的固定套路。我花了大量时间把这三兄弟相关的题目整理成一套通关路径，下面直接把我踩过的坑、总结的模板和实战代码一次性拆给你，从基础原理到高频真题，再到面试场上怎么讲得清楚，一条龙全部覆盖。

这套内容适合正在准备算法面试、刷 LeetCode 的开发者，也适合学完数据结构但做题没思路的同学。看完之后你会发现，栈、队列、优先级队列的考题真没你想的那么杂，核心题型就那么几类，套路一旦掌握，剩下的就是熟练度问题。

1. 先搞懂三兄弟的本质：栈、队列、优先级队列到底在考什么

1.1 栈：LIFO 的“后悔药”机制

栈就是后进先出（Last In First Out）的线性表，和叠盘子一模一样，最后放上去的盘子最先被拿走。在编程里，栈只需要支持三个核心操作：push 压入、pop 弹出、top/peek 查看栈顶元素，再加一个 empty 判空。基于数组实现时，栈顶指针后移就是入栈，前移就是出栈，时间复杂度都是 O(1)，空间复杂度看数组大小。

很多人学栈时只记住了“先进后出”四个字，但不知道栈到底解决了什么本质问题。我的理解是，栈提供了一种“回退”能力。你在浏览器里点后退，就是从一个页面栈弹出；编辑器里的 Undo，也是把操作记录压进撤销栈；函数递归调用时系统会自动维护调用栈。算法题里凡是涉及到“匹配”“回退”“最近相关性”的，八成都能用栈来解。

面试里最常见的栈题套路有三个：括号匹配、单调栈、表达式求值。其中括号匹配是入门题，单调栈是高频进阶题，表达式求值则是综合性最强的一种。这三个套路我后面会一个一个拆开讲，每一个都有固定的模板可以套。

1.2 队列：FIFO 的“排队”机制

队列是先进先出（First In First Out）的线性表，和食堂排队一样，先来的人先打饭。核心操作是 enqueue 入队、dequeue 出队、front 查看队首元素。常见实现有普通队列、循环队列、双端队列（deque），以及带优先级的优先级队列。

算法题里拿到队列，首先要想到两个场景：一个是 BFS（广度优先搜索），因为 BFS 天然就是逐层扩散的，需要队列来维护“下一层要访问的节点”；另一个是滑动窗口类问题，尤其是需要快速获取窗口内最值的时候，双端队列非常能打。

需要特别注意的是，很多初学者会把队列和 Array、List 混着用，结果时间复杂度过不了关。比如在 Python 里用 list 的 pop(0) 移除队首，这是一个 O(n) 的操作，数据量一大必超时。正确的做法是用 collections.deque，它底层是双向链表实现，popleft() 和 append() 都是 O(1)。如果你在刷题时遇到超时，先检查一下是不是用了不合适的队列实现。

1.3 优先级队列：带权重的“插队”机制

优先级队列听起来高大上，其实本质就是一个“会自动排序的队列”。它的底层实现绝大多数是二叉堆（Binary Heap），常见的有最大堆和最小堆两种。在 Java 里对应 PriorityQueue，在 C++ 里对应 priority_queue，在 Python 里就是 heapq，默认是最小堆。

优先级队列的时间复杂度需要背熟：入堆和出堆都是 O(log n)，建堆是 O(n)，取最大值/最小值是 O(1)。它最强的场景是：你有一堆动态变化的数据，每次需要快速拿到最大或最小的那个。比如 TopK 问题、合并 K 个有序链表、任务调度贪心策略，这些题目如果不用堆，要么需要维护一个有序数组导致插入 O(n)，要么每次排序导致 O(n log n)，都不如堆高效。

我最初学优先级队列时有个误区，老想着用 sort 替代堆。但在动态数据下，sort 每次都要全量排序，而堆只需要调整部分节点，差距非常大。所以在面试中，只要发现题目有“动态维护最值”的需求，第一反应应该是优先级队列而不是排序。

2. 栈的高频考题：从括号到单调栈，套路就那几个

2.1 “括号匹配”类问题：最经典的栈入门

括号匹配系列是栈最经典的应用场景，LeetCode 20（有效的括号）属于必刷中的必刷。题目给你一个只包含 ()、[]、{} 的字符串，判断括号是否有效。解法思路非常直接：遍历字符串，遇到左括号就压入栈，遇到右括号就检查栈顶是否是对应的左括号，如果是就弹出，如果不是或者栈为空，说明无效。

python复制def isValid(s):
    stack = []
    pairs = {')': '(', ']': '[', '}': '{'}
    for ch in s:
        if ch in '([{':
            stack.append(ch)
        else:
            if not stack or stack[-1] != pairs[ch]:
                return False
            stack.pop()
    return not stack

这段代码有几个细节值得注意。第一，为什么用字典映射右括号到左括号？因为当遇到右括号时，需要立即判断栈顶是否匹配，用字典可以让代码更简洁。第二，为什么最后要 return not stack 而不是 return True？如果字符串是 "((" 这种只有左括号的输入，遍历完成后栈里还剩下元素，说明没有匹配完，必须判空。第三，当遇到右括号时，要先判断 not stack，否则访问 stack[-1] 会报 IndexError，这是最容易踩的坑。

再往上走一步就是 LeetCode 32（最长有效括号），难度直接从简单跳到困难。最自然的解法还是用栈，但栈里存的不是字符，而是下标。核心思路是始终保持栈底元素为“最后一个没有被匹配的右括号的下标”，每次遇到右括号时先弹出栈顶，如果栈为空则把当前右括号下标压入，否则计算当前下标减栈顶下标的差值，更新最大值。这个思路理解起来有点绕，但本质还是利用栈存储“待匹配的位置”，通过下标差来得到括号子串长度。

2.2 单调栈：用一个栈解决“下一个更大/更小元素”

单调栈是栈这个数据结构的进阶玩法，也是面试题里的重灾区，很多看着很难的题，模板一换就是单调栈。所谓单调栈，就是栈内元素保持单调递增或单调递减。以“下一个更大元素”为例，我们维护一个从栈底到栈顶递减的栈，遍历数组时，如果当前元素比栈顶元素大，就说明栈顶元素找到了“下一个更大元素”，此时弹出栈顶并记录答案，直到当前元素比栈顶小为止，再把当前元素入栈。

LeetCode 739（每日温度）就是最典型的单调栈入门题。数组代表每天温度，要求返回每一天需要等多少天才能等到更高的温度。暴力解法是两层循环 O(n^2)，面试官大概率不满意，用单调栈可以做到 O(n)。

python复制def dailyTemperatures(T):
    n = len(T)
    ans = [0] * n
    stack = []  # 存下标，维护递减栈
    for i in range(n):
        while stack and T[i] > T[stack[-1]]:
            idx = stack.pop()
            ans[idx] = i - idx
        stack.append(i)
    return ans

这段代码的核心在于，栈里存的是下标而不是温度值，因为需要计算天数差值。每次遇到比栈顶元素大的温度，就说明栈顶元素等到了“下一个更高温度”，直接出栈并计算答案。为什么是递减栈？因为你希望栈顶是当前尚未找到更高温度的元素，一旦出现更大的值，就要依次弹出并结算，这正好符合“从近到远排除”的顺序。

接下来是 LeetCode 84（柱状图中最大的矩形）和 LeetCode 42（接雨水），这两道都是单调栈的经典进阶题。84 的思路是在数组左右各加一个高度为 0 的哨兵，然后用单调递增栈计算每个柱子能向左右扩展的最大宽度，再乘上自己的高度，取最大值。接雨水的思路类似，用单调递减栈，当出现比栈顶高的柱子时，说明栈顶位置可以形成一个凹槽，此时弹出栈顶，计算两侧柱子高度差乘以宽度，累加雨水量。

这两道题我强烈建议你去手写一遍，光看代码是永远学不会的，因为你会卡在“左右哨兵为什么这么加”“宽度为什么是 i - stack[-1] - 1”这种细节上。写多了自然就懂了。单调栈的代码模板就一个 while 循环加一个 push，剩下的全是边界条件的处理。

2.3 表达式求值与栈模拟：逆波兰表达式和基本计算器

表达式求值是栈应用的另一个大家族，核心思路就是“先入栈的操作数，等遇到运算符再弹出计算”。LeetCode 150（逆波兰表达式求值）是最朴素的实现：遍历 tokens，如果是数字就压栈，如果是运算符就弹出两个数，计算完再压回栈，最终栈底元素就是结果。

python复制def evalRPN(tokens):
    stack = []
    for t in tokens:
        if t.lstrip('-').isdigit():
            stack.append(int(t))
        else:
            b = stack.pop()
            a = stack.pop()
            if t == '+':
                stack.append(a + b)
            elif t == '-':
                stack.append(a - b)
            elif t == '*':
                stack.append(a * b)
            else:
                stack.append(int(a / b))
    return stack[0]

这里有个大坑，Python 的除法如果直接用 // 在负数场景下会出问题，因为它是向下取整，而题目要求向零取整。正确的做法是用 int(a / b)，先做浮点除法再向零截断，或者用 math.trunc。我在实际写题时第一次就栽在这里：测试用例带上负数时结果不对，排查了半天才发现是 Python 整除特性导致的。

再往上一点是 LeetCode 224（基本计算器），题目只包含 +、-、括号、空格，但需要对括号内的表达式进行化简。解法核心是用一个 sign 变量记录当前数字前的符号，遇到括号时把括号内的符号状态压栈，等括号结束后再恢复。我总结的技巧是：数字用 num = num * 10 + int(ch) 来累加，空格直接跳过，遇到 ( 把当前结果 result 和当前符号 sign 压栈，遇到 ) 再恢复。这个模板背下来，基本计算器系列的题都能套。

3. 队列的高频考题：滑动窗口和 BFS 是两大常客

3.1 滑动窗口最大值：双端队列的经典应用

LeetCode 239（滑动窗口最大值）是我刷题过程中印象最深的一道题，因为它完美展示了“选对数据结构比会写算法更重要”。给你一个数组和一个滑动窗口大小 k，要求返回每个窗口内的最大值。暴力解法是每个窗口排序或扫描一次，复杂度 O(n*k)，数据一大直接超时。

正确的解法是用双端队列（deque），但队列里存的是数组下标，并且保持队首永远是当前窗口最大值的下标。具体逻辑是：遍历数组时，先把当前元素与队尾元素比较，如果队尾元素小于等于当前元素，就把队尾弹出，保证队列从队首到队尾递减；然后把当前下标入队；接着判断队首是否已经滑出窗口，如果 q[0] <= i - k 就弹出队首；最后当 i >= k-1 时，队首对应的值就是当前窗口最大值。

python复制from collections import deque

def maxSlidingWindow(nums, k):
    q = deque()
    res = []
    for i, x in enumerate(nums):
        while q and nums[q[-1]] <= x:
            q.pop()
        q.append(i)
        if q[0] <= i - k:
            q.popleft()
        if i >= k - 1:
            res.append(nums[q[0]])
    return res

为什么要用双端队列而不是普通队列？因为这里既需要从队尾弹出元素（剔除小的），又需要从队首弹出元素（剔除滑出窗口的），双端队列两头都能操作，正好契合需求。为什么队列里存下标而不是存值？因为窗口滑动时靠下标判断是否越界，纯存值没法判断窗口边界。这个题和单调栈有异曲同工之处，都是通过“维护一个局部单调序列”来快速取最值，区别只是一个用栈，一个用双端队列。

3.2 BFS：队列不只是线性结构，更是“同级遍历”利器

BFS 广度优先搜索是队列在算法里最核心的应用场景。二叉树的层序遍历（LeetCode 102）就是最直观的入门题：根节点入队，每次弹出当前层的所有节点，同时把下一层的子节点入队，直到队列为空。模板非常固定，背下来基本可以解决一大半的 BFS 题：

python复制def levelOrder(root):
    if not root:
        return []
    from collections import deque
    q = deque([root])
    res = []
    while q:
        level = []
        for _ in range(len(q)):
            node = q.popleft()
            level.append(node.val)
            if node.left:
                q.append(node.left)
            if node.right:
                q.append(node.right)
        res.append(level)
    return res

BFS 的一个核心技巧是“按层处理”，也就是在每一轮 while 循环开始前先记录当前队列长度 len(q)，然后只处理这一层固定数量的节点，否则你会发现不同层的节点全混在一起了。理解了这个技巧之后，像二叉树的右视图、二叉树的锯齿形层序遍历这类变体题，都可以套用同样的框架。

另一个常考队列的场景是拓扑排序，对应题号是 LeetCode 207（课程表）和 210（课程表 II）。思路是用入度表记录每个节点的前驱数量，先把入度为 0 的节点入队，然后不断出队并把它指向的节点入度减 1，如果某个节点入度变成 0 就入队。最终队列弹出的顺序就是一个合法的拓扑序列，如果弹出的节点数不等于总节点数，说明图中存在环。这个算法本质就是队列 + 入度统计，很多同学觉得图很难，其实套上 BFS 的壳之后就没那么可怕了。

3.3 手写循环队列：考察你对数组和取模的理解

循环队列是队列实现层面的经典题目，LeetCode 622 就是让手写一个循环队列。它考的不是什么高深算法，而是你能否用数组实现一个高效的、假溢出问题的队列。普通队列在数组里出队后，前面的空间就没法再用了，循环队列通过“取模回绕”让数组空间循环复用。

设计时需要用 front 和 rear 两个指针，再加一个 size 记录实际元素个数。入队时先把值写到 rear 位置，然后 rear = (rear + 1) % capacity；出队时 front = (front + 1) % capacity。关键点是判空和判满。如果用 size 变量，判空就是 size == 0，判满就是 size == capacity，这是最不容易出错的方案。有些实现会刻意让 rear 占一个空位来区分空和满，但我觉得用 size 更直观，面试时也更容易解释清楚。

取 Rear 时有个容易踩的坑：rear 指向的是下一个空位，而不是最后一个元素的位置，所以要取 rear - 1，而且还要加上 capacity 再取模，防止 rear 为 0 时出现负数下标。这个细节我第一次写的时候漏了，直接导致取队尾元素报错。循环队列的代码不到 50 行，我建议每一个人都手写一遍，面试官很喜欢考这种考察基本功的题，写没写过一眼就能看出来。

4. 优先级队列的高频考题：TopK、合并、贪心调度

4.1 TopK 问题：小顶堆永远是主角

TopK 问题是优先级队列最典型的应用场景，LeetCode 347（前 K 个高频元素）是所有解法中最能展示堆优势的题。给定一个数组，返回出现频率最高的前 k 个元素。先统计频率，需要遍历一遍数组；然后用一个小顶堆维护当前出现频率最高的 k 个元素，当堆里元素超过 k 个时，弹出堆顶（也就是频率最小的），这样堆里剩下的就是前 k 个高频元素。

python复制import heapq
from collections import Counter

def topKFrequent(nums, k):
    counter = Counter(nums)
    heap = []
    for num, freq in counter.items():
        heapq.heappush(heap, (freq, num))
        if len(heap) > k:
            heapq.heappop(heap)
    return [num for _, num in heap]

初学者会有一个疑问：我要找的是“最大的 k 个”，为什么不直接用大顶堆把所有元素都丢进去再弹出 k 个？原因是内存和效率。如果数据规模非常大，比如上亿个元素，全部建堆需要 O(n) 的空间，而维护一个大小为 k 的小顶堆只需要 O(k) 的空间，这个差距是巨大的。在时间上，小顶堆处理的复杂度是 O(n log k)，而全量堆排是 O(n log n)，k 远小于 n 时差距也很明显。

还有一个隐藏考点：Python 的 heapq 默认就是小顶堆，但是如果你在堆里放元组 (freq, num)，它会先比较 freq，再比较 num。这通常没问题，但如果你想在 C++ 或 Java 里自定义比较器，就特别容易写反。我见过太多人在面试时把 comparator 传反方向，导致结果完全反了。每次用优先级队列之前，一定要先确认自己的堆是大顶还是小顶、比较器方向是否正确。

4.2 合并 K 个有序链表：优先级队列的天然场景

LeetCode 23（合并 K 个升序链表）又是一道优先级队列的经典题。暴力的做法是每次从 K 个链表的头节点中找出最小的那个，取出来接到结果链表后面，但每取一个节点都要扫描一次 K 个头节点，复杂度 O(nk)。用堆优化之后，把 K 个头节点都丢进小顶堆，每次弹出最小的节点，然后把该节点的 next 节点入堆，复杂度降为 O(n log k)。

python复制def mergeKLists(lists):
    heap = []
    for i, node in enumerate(lists):
        if node:
            heapq.heappush(heap, (node.val, i, node))
    dummy = ListNode(0)
    cur = dummy
    while heap:
        val, i, node = heapq.heappop(heap)
        cur.next = node
        cur = node
        if node.next:
            heapq.heappush(heap, (node.next.val, i, node.next))
    return dummy.next

这段代码里有一个很容易被忽略的细节：堆里存的是三元组 (val, i, node)，其中 i 是链表的索引。为什么不能只存 (val, node)？因为 Python 的 heapq 在比较元组时，如果 val 相等，就会接着比较 node，而两个 ListNode 对象之间是不能直接比较大小的，这时会直接抛 TypeError。加上一个唯一的索引 i 就能保证元组永远不会走到比较 ListNode 的那一步，这个技巧在 Java 里同样适用，经常通过把对象包装成带 id 的类来解决。

合并 K 个有序数组的思路和链表完全一致，只是把链表节点的 next 指针换成数组下标加 1。这类题一旦掌握，基本就等于拿到了所有“多路归并类”题目的通用解。

4.3 贪心调度类：任务调度器和 IPO

优先级队列在贪心策略中经常扮演“动态取最值”的角色。LeetCode 621（任务调度器）是一个非常经典的题：给一堆任务和冷却时间 n，相同任务之间至少间隔 n 个单位时间，求最少需要多少时间完成任务。这题有一个非常巧妙的公式解法：找到出现次数最多的任务，设它的次数为 max_count，有 max_num 个任务达到这个次数，那么最少时间就是 max(len(tasks), (max_count - 1) * (n + 1) + max_num)。

这个公式的本质是把出现次数最多的任务当作“骨架”，在每个骨架任务之间插入冷却任务，最后再把同频率的多个任务数量加上去。用堆模拟也可以做，但公式法的代码非常短：

python复制def leastInterval(tasks, n):
    cnt = Counter(tasks)
    max_count = max(cnt.values())
    max_num = sum(1 for v in cnt.values() if v == max_count)
    return max(len(tasks), (max_count - 1) * (n + 1) + max_num)

另一个经典的贪心 + 堆场景是 LeetCode 502（IPO），题目给定了启动资金 w、项目利润 profits 和项目资本 capital，你最多可以做 k 个项目，求最终最大资金。思路是先把所有项目按启动资本从小到大排序，放进小顶堆；然后循环 k 轮，每轮把所有资本小于等于当前资金 w 的项目全部弹出，再放进一个按利润排序的大顶堆，每次选利润最高的一个项目做。这个过程里的两个堆，一个负责筛选“能做的项目”，一个负责选择“利润最高的项目”，分工非常明确。

这类题的核心就是一个思想：把所有“当前可选”的选项放进一个按某个指标排序的堆里，每次取堆顶。你只要抓住这个思想，遇到类似题就先问自己三个问题：什么时候把选项加入堆？按什么指标排序？每次取堆顶之后需要维护什么？

5. 实战避坑与刷题路线建议

5.1 高频易错点清单

栈、队列、优先级队列的题目虽然套路化，但几个常见坑足以让你在面试现场翻车。下面这些我全踩过，每一条都是我当时的真实教训，整理成了一张速查表：

你以为写完代码就完事了？面试的时候光写正确还不够，面试官会追问，比如问“为什么时间复杂度是 O(n)”“你这单调栈的栈里为什么存下标”“如果数据流是海量的你怎么处理”。这些问题考察的是你对数据结构和算法的本质理解，而不是背代码。我建议每刷完一道题，都要能自己回答这三个问题：暴力解是什么、数据结构优化在哪里、还有没有更好的方案。

5.2 面试中如何讲解这类题

面试时讲解排序题最大的误区是“上来就讲最优解”。面试官其实更想看到你从暴力解法开始分析，然后逐步推导到优化解法。以滑动窗口最大值为例，你可以先讲：暴力解法每个窗口扫描一次找到最大值，复杂度 O(nk)；然后想到用堆优化，但堆的删除操作比较麻烦；最后发现双端队列可以在 O(n) 时间内解决。这个过程比直接甩出最优解更能体现你的思考深度。

讲解单调栈题时，有一个表达技巧很加分：先把单调栈的定义和价值讲清楚，告诉面试官“我维护了一个从栈底到栈顶严格递减的栈，当新元素大于栈顶时，说明栈顶元素遇到了它的下一个更大值，所以弹出并记录答案”。这种表述既展示了数据结构理解，又展示了算法推导过程，面试官听起来会很顺畅。

还要注意代码规范。面试手写代码时，变量名要清晰，边界条件要写出来，循环里避免出现魔法数字。我在面试时见过不少候选人代码逻辑没问题，但因为变量名全是 a、b、c，导致面试官无法快速理解你每一步的思路，最终在沟通分上吃亏。

5.3 推荐刷题顺序（含题号）

如果让我给你一条不会走弯路的刷题路线，我会建议按下面的顺序来：

第一步，栈的入门题：LeetCode 20（有效的括号）、155（最小栈）、150（逆波兰表达式求值）。这几道题可以帮你彻底理解栈的 LIFO 特性。

第二步，单调栈专题：LeetCode 739（每日温度）、496（下一个更大元素 I）、84（柱状图中最大的矩形）、42（接雨水）。前两道是入门，后两道是进阶，如果后两道能独立写出来，单调栈基本就过关了。

第三步，队列与 BFS 专题：LeetCode 102（二叉树的层序遍历）、107（层序遍历 II）、199（二叉树的右视图）、207（课程表）。先把 BFS 模板背熟，再套到图上。

第四步，优先级队列专题：LeetCode 215（数组中的第 K 个最大元素）、347（前 K 个高频元素）、23（合并 K 个升序链表）、295（数据流的中位数）。其中 295 是双堆经典题，建议放到最后挑战。

第五步，综合应用：LeetCode 239（滑动窗口最大值）、621（任务调度器）、502（IPO）。这些题会把单调栈、双端队列、优先级队列和贪心思想结合起来，属于面试高分段题目。

我的经验是，每个专题的题目不要只刷一遍，至少隔一周再重新做一次。第一次做是学思路，第二次做是巩固套路，第三次做是训练手速和代码准确度。我见过太多人刷题像看小说，觉得看懂题解就是会了，结果一到面试白板写代码就卡壳，一切归零。

还有一个个人心得：遇到不会的题，先别急着看题解，给自己 20 分钟时间思考，多想几个角度，哪怕想不出来也比直接看答案效果好得多。很多类似题都是“换汤不换药”，只要你把上面几个专题的核心套路吃透，哪怕遇到新题，也能很快定位到该用哪种数据结构。栈、队列、优先级队列这三块题型之间是层层递进的，从线性结构到动态最值，你走过的每一步都会在后面的题里派上用场。