不靠谱的糖饼写括号匹配题的时候，很多人觉得只要会 std::stack<char> 就够用了。真正上手做"括号序列分解"这类问题时才发现，判断合法只是最外层的一层皮，序列里一旦混入杂质字符、需要输出具体的子串区间、还要在多个片段里找最优解，问题一下子就复杂了。这篇文章从一个具体的括号序列分解场景出发，把栈的应用从"能匹配"推进到"能定位、能切分、能输出最优结果"，完整走一遍轻量实现的过程。
我按标题把问题设定成了这样：输入一个由 (、) 和 ? 组成的字符串，其中 ? 是杂质字符，需要删除全部 ? 后，在连续区间内找到最长的合法括号子串并输出。这个设定不算复杂，但足够把栈的核心用法逼出来：栈里存什么、什么时候重置起点、怎么处理不匹配右括号、多个区间怎么比较。下面直接进入正题。
1. 先把问题边界划清楚：不是所有"括号题"都长一个样
1.1 括号相关的问题其实分了四层
很多初学者会把括号类问题一概而论，实际上难度和考法差别很大。我平时把它们分成四个层级：
- 合法判定：给一个只含括号的字符串，判断它是否合法。对应力扣的第20题，最基础的栈应用。
- 配对输出：不仅要判断合法，还要输出每一对左右括号的位置。栈里开始需要存索引。
- 最长合法子串：在原串里找一段连续、长度最长的合法括号区间。经典的"最长有效括号"题。
- 分解筛选：原始串里混入了杂质或者非法片段，需要先把串切开、再在每段里找最优合法子串并输出。
本文处理的就属于第四层。相比第三层，它多了一个"切分"动作，而这恰恰是工程里更常见的情形——真实数据永远不是干净的。括号匹配在编译器、IDE 高亮、配置文件解析里遇到的数据，几乎都带着各种噪声。
1.2 我采用的题目定义
因为原始输入里没有给出具体的输入输出约定，我按"括号序列分解"最常见的需求把它具象化成了这样：
给定一个由
(、)、?组成的字符串s，?视为必须剔除的杂质。要求删除全部?后，在剩余字符串的连续区间中，找到并输出最长的一个合法括号子串。如果不存在，输出空行。
打个比方：原始序列被 ? 切成了若干段，每一段内部再尝试找出合法括号子串，最后在所有候选段里取最长。这里强调一下，是"连续"的合法子串，不是把各个分散的合法片段拼接起来。拼接问题属于 DP 范畴，不是本文要讲的栈思想。
看一个直接例子：
| 输入 | 输出 |
|---|---|
)(()?))(?) |
() |
这个过程就是：先把串按 ? 分成两段，分别是 )(() 和 ))。第二段没有任何合法匹配，第一段里最长合法子串是从第2个字符开始的 ()，所以最终输出 ()。
1.3 合法括号序列的两条硬规则
不管问题怎么变，"合法括号序列"的定义是不变的，就两条：
- 左右括号的数量相等。
- 任意前缀中，左括号数量不少于右括号数量。
第一条保证整体配平，第二条保证任何一个右括号出现时，前面一定已经有了等待它的左括号。比如 )( 虽然左右数量相等，但第一个字符就是右括号，直接违反第二条，所以不合法。
为什么这两条规则够用？因为它们构成充要条件。数量相等保证不会留下未配对的括号，任意前缀左括号不少于右括号保证任何时刻右括号都能找到匹配对象，这两条叠起来恰好覆盖了"完全配对"的所有要求。后续代码里所有判断逻辑，本质上都在维护这两条规则。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 栈为什么是这个问题的天然答案：最近未匹配优先
2.1 括号匹配的本质是后进先出
想理解栈为什么适合处理括号，先想象一个括号串被扫描的过程。比如 (()())：
- 读入第一个
(，它不知道会和谁配对，先记下来。 - 读入第二个
(，它也不知道会和谁配对，先记下来。 - 读入第一个
)，它应该跟谁配对？直觉告诉我们，它跟最近的、尚未配对的左括号配对，也就是第二个(。 - 继续读入
(、)，配对的是这一对。 - 最后读入
)，配对的才是最开始的那个(。
这个过程天然就是"后进先出"：越晚出现的左括号，会越早被匹配。这就是 LIFO。栈这个数据结构恰好完美复刻了这个机制——把左括号依次压入栈，遇到右括号时从栈顶弹出最近的那个左括号完成配对。括号嵌套的层级越深，这个特性越明显。
2.2 用一条死胡同来理解入栈出栈
我在给朋友讲栈的时候常用一个类比：栈就像一条只能从入口进出的死胡同。车从入口开进去，后面的车会把前面的车堵住。要想让最早开进去的那辆车出来，必须先把后来进去的车全部倒出去。括号匹配也是这个道理：最内层的括号一定最先配对，处理完内层，外层才有可能配对。
这个类比还能帮你理解"栈顶"的含义——栈顶就是胡同口那辆车，是最近一个进入结构的数据。所有栈操作都只发生在栈顶，不会去动栈中间的元素。
2.3 一个容易踩的概念坑：此"栈"非"全栈"的"栈"
说到"栈"，有个题外话值得提醒一句。近两年"全栈工程师""技术栈""全栈项目"这些词特别热，很多人一听到"栈"就联想到前端后端，甚至把数据结构栈和全栈混为一谈。这完全是两个概念。
全栈的"栈"是"技术栈"的简称，指一个人或者一个项目使用的一整套技术体系，比如前端用 Vue、后端用 Spring、数据库用 MySQL，这套组合就是技术栈。数据结构里的"栈"是一个容器，只有后进先出这一个核心行为，跟前后端没有任何关系。
区分清楚这一点很有必要。刷题群里已经不止一次看到"栈不是全栈吗？怎么还要学 C++ 的 stack？"这种问题。下次面试官说"用栈实现一下"，别往前后端想。
3. 轻量实现拆解：手写一个栈完成分解与筛选
3.1 为什么不用 std::stack，而是手写数组栈
标题强调"轻量实现"，这个轻量主要体现在两方面：一是代码逻辑轻，二是运行开销轻。
用 C++ 的 std::stack 没什么问题，但有些场景下它不够顺手。std::stack 默认底层是 deque，你没法直接遍历栈里的元素，也没法方便地拿到栈顶下一个位置的元素。而在计算"当前合法区间的左边界"时，栈顶下一个位置恰恰是关键信息。如果只用 std::stack<char>，你至少还需要额外维护一个数组来记录括号位置，代码就变得不轻了。
所以我用了更直接的方式——数组模拟栈。一个数组、一个 top 指针，入栈就是 stk[++top] = i，出栈就是 top--，判空就是 top == -1。代码量最少，逻辑最透明，调试时还能直接把整个栈打出来看。在白板面试里也是最容易讲清楚的写法。
3.2 核心函数：在连续区间内寻找最长合法子串
我用 Python 写核心逻辑，因为它的语法接近伪代码，最容易看懂。你完全可以照着这个思路翻译成 C++、Java 或 Go。
python复制def longest_valid(s, l, r):
stk = [] # 只存左括号的索引位置
start = l # 当前候选合法区间的起点
best_l, best_r = -1, -1
best_len = 0
for i in range(l, r):
c = s[i]
if c == '(':
# 左括号无条件入栈，记录它的位置
stk.append(i)
else:
# 右括号：栈里有左括号就配一对
if stk:
stk.pop()
# 计算当前合法子串的左边界
# 栈空说明从 start 到现在这一整段都匹配上了
# 栈不空说明栈顶那个左括号还没配上，合法段从它后面开始
cur_l = start if not stk else stk[-1] + 1
cur_len = i - cur_l + 1
if cur_len > best_len:
best_len = cur_len
best_l, best_r = cur_l, i + 1
else:
# 栈空时遇到右括号，说明它是多余的
# 当前这一段到 i 这里已经不可能再合法了
# 下一个候选区间要从 i 的后面重新开始
start = i + 1
return best_l, best_r, best_len
这个函数是整篇文章的核心，值得多花点时间拆解。
3.3 栈里存索引，匹配成功才算长度
注意第7行的 stk.append(i)，这里存的是左括号的下标，不是左括号本身。这个是能否"算出长度"的关键。如果栈里只是存 ( 字符，弹出之后你只知道"配上了"，但不知道这对括号落在字符串的哪个位置，长度自然算不出来。
再看 cur_l 的计算逻辑，这是最容易写错的地方：
- 如果弹出之后栈为空，说明从
start到当前i之间所有括号都已经配对完毕，当前合法子串的左边界就是start。 - 如果弹出之后栈不为空，说明栈顶那个左括号还没有匹配，当前这段合法子串必须从栈顶左括号的下一个位置开始。
这个逻辑我当初第一次写时没转过来，直接用了 start，结果在 (()()) 这种嵌套结构里算出的长度全是错的。调试半天才意识到：栈顶未被匹配的左括号，是当前已经完成匹配的部分的左边界"墙"，合法子串只能从它后面开始。
你可以跑一下 longest_valid("(()())", 0, 6)，逐步打印栈的内容，就能看到长度从2到4再到6的完整变化过程。
3.4 遇到多余右括号：切分候选区间
第23到26行处理的是"栈空遇到右括号"的情况。此时这个右括号是多余的，因为左边没有待匹配的左括号。它意味着什么？意味着从 start 到 i 这一段，已经不可能再扩展成合法括号子串了，因为即使后面的括号能配平，这个多余的右括号也会破坏合法性。
所以正确的做法是：把 start 更新为 i + 1，把之前那段整体从候选里"切掉"。这个过程，就是标题里"分解"动作的本质——序列通过这种切分被拆成了若干个互不干扰的子区间，之后每个子区间独立找最长合法子串。
这一步如果漏掉，或者只是 continue 跳过，就会出现严重错误。比如字符串 )(，扫描到第二个字符 ( 时没有配对机会，但如果不重置 start，最后栈空时 cur_l 会错误地取成0，直接把 )( 这种非法串当成合法串算进去。这个问题在下一章还会详细展开。
3.5 外层切分：处理 ? 杂质字符
有了 longest_valid 这个基础函数，处理 ? 就简单了——在字符串里扫一遍，遇到 ? 就把之前收集到的连续区间交给 longest_valid 处理，然后从 ? 的下一个位置开启新区间。
python复制def solve(s):
n = len(s)
best_len = 0
best_l, best_r = -1, -1
seg = 0
for i in range(n + 1):
if i == n or s[i] == '?':
# 对 [seg, i) 这一段做括号分解
if i > seg:
l, r, length = longest_valid(s, seg, i)
if length > best_len:
best_len = length
best_l, best_r = l, r
# 跳过这个 '?'，从下一位置开始新的段
seg = i + 1
if best_l == -1:
return ""
return s[best_l:best_r]
这里有一个细节：循环条件写的是 range(n + 1)，多出来的最后一位 i == n 是为了处理字符串末尾恰好没有 ? 的情况，保证最后一段也能被切出来。这个"哨兵位"的习惯在区间切分类问题里很常见，能避免重复写一段处理尾巴的逻辑。
整个算法的时间复杂度是 O(n)。每个字符最多被压栈一次、弹栈一次，每段扫描也都是线性时间，外层 for 循环同样是线性遍历。空间复杂度 O(n)，因为最坏情况下字符串全是 (，栈要存下所有位置。
4. 实测中最容易翻车的四个细节
4.1 栈内元素选错，整个实现白写
第一个细节其实前面已经强调了，但值得单独拎出来再说一次：栈里绝对不能只存字符本身。我用过一版 std::stack<char> 的实现，样例过了，跑真实数据立刻出问题。原因很简单，你要输出的是子串，子串就一定有起点和终点，而终点就是当前扫描到的右括号位置，起点则需要从栈里取。栈里存的是字符，你只能知道"这里有个左括号"，却不知道它在哪儿，长度和起点全部无从谈起。
把栈内元素改成索引之后，代码反而更简洁了。因为栈顶索引本身不仅告诉你这个左括号的位置，还能通过 stk[-1] + 1 算出当前合法子串的左边界。一个数据同时承担了两个职责，这就是数据结构设计里常见的"用索引代替值"技巧。
4.2 多余右括号后不重置 start 的连锁错误
这是我踩得最深的一个坑。一开始我在遇到多余右括号时只是简单跳过，没有更新 start，结果在 )() 这个用例上输出了一整串非法结果。
复盘一下错误的执行过程：假设 start = 0，扫描 ) 时栈空，我什么都没做；扫描 ( 入栈；扫描 ) 弹出，此时栈空，cur_l = start = 0，总长度算成了3，返回 )()——一个明显非法的括号序列。
正确做法就是那句 start = i + 1。它的作用是把已经不可能合法的前缀整体丢弃。注意这里不是简单把 start 往后挪一位就完事，而是要挪到当前右括号的下一个位置，因为这个右括号本身也不能再参与匹配了。丢弃的不仅仅是它，还有它之前被污染的那一段。
4.3 空输出与边界条件的处理
当整个字符串里没有合法括号子串时，solve 返回空字符串。在实际项目或在线评测中，要特别留意输出形式：有些地方要求输出空行，有些地方要求不输出任何内容，还有的地方不允许有多余空格。
还有一个容易忽略的边界：字符串为空。如果输入直接是空串，外层循环里 i == n 且 i == seg，不会进入 longest_valid，最后 best_l 还是 -1，返回空串。这个流程是自洽的，但如果你在 if i > seg 这个判断里写反了方向，空串输入就很容易报错。
另外，如果字符串全是 ?，同样会被正确切分成若干个空段，最终返回空串。这一类"输入非空但结果为空"的场景，最考验边界处理是否严谨。
4.4 手写数组栈的细节维护
如果翻译成 C++ 或 Java 的手写数组栈，还有几个小坑。top 指针初始化为 -1，入栈先 ++top 再赋值，出栈直接 --top，判空看 top == -1。这个 -1 的初始值很容易被写成0，一旦写错，第一个 ( 会从下标1开始存，所有索引计算全部错位。
另外一个容易被忽略的点是，手写栈里存的是原字符串的下标，这些下标可能很大。如果字符串长度超过 int 范围，就要改用 long long 或 size_t 类型。竞赛题和工程里都有这类边界问题，虽然字符串超 2GB 的场景很罕见，但设计数据结构时提前想好类型是很重要的习惯。
5. 同一种栈思想还能往哪些场景延伸
5.1 从"找最长"到"求长度"：最长有效括号变体
本文实现的是"输出最长合法括号子串"，如果只要求返回长度，代码可以更短。力扣第32题最长有效括号就是这样一个变体，标准解法之一也正是"栈存索引"的技巧。
区别在于，那个题目往往要求你考虑"连续"这一特点，比本文多了一道坎。比如 ()(() 的最长有效括号长度是2，这个2是 () 的长度，不是拼接 () 和 () 的4。拼接问题之所以不能直接用栈，是因为这里断点在于多余的 (，它把前后分开了，而栈在处理这种断点时更新的逻辑和本文几乎一致——都是靠重置起点来切分区间。
5.2 单调栈：栈的进阶形态
如果顺着栈再往前走一步，就是单调栈。单调栈里的元素按照单调递增或递减的顺序排列，它解决的是"左右两边第一个比当前元素大/小的位置"这类问题。
单调栈和括号匹配在思想上是相通的：都是在处理"当前元素应该和谁配对"的问题，只是配对条件从"左括号配右括号"变成了"大于配小于"。经典应用包括柱状图最大矩形面积、接雨水、每日温度。这些题目看起来和括号毫无关系，但核心的"维护一个未决元素的栈，遇到新元素时决定是入栈还是出栈"完全是同一个套路。
5.3 括号之外：栈在日常软件里的身影
栈的应用范围比很多人想象中广得多。IDE 编辑器里的括号高亮，本质上就是一个实时运行的括号匹配器；编译器检查代码语法时，花括号、方括号的嵌套合法性判断也是同一个模型；HTML 和 XML 解析器里标签的嵌套闭合，同样是栈——读到开始标签入栈，读到结束标签出栈并判断是否匹配。
前端路由里的浏览器前进后退、编辑器里的 Undo/Redo，实现机制也是栈。一个存放历史记录，一个存放撤销操作，都是后进先出。理解了一个简单的括号匹配栈，再去看这些系统，你会觉得它们之间有一种共享的骨架。
就我个人而言，弄懂了"栈里存索引而不是值"这个细节之后，我对栈的理解上了一个台阶。之前写代码总是围着 stack<char> 转，遇到实际问题才发现，真正重要的是你往栈里放了什么信息，以及弹出后如何利用这些信息去推导位置关系。后面再做类似的区间类题目，我会先问自己三个问题：栈里放什么？什么情况下出栈？出栈后如何更新答案？这三个问题想清楚，代码基本就不会出大错了。