LeetCode 496 下一个更大元素详解：单调栈解法与常见坑-代码聚汇网

LeetCode 496 下一个更大元素详解：单调栈解法与常见坑

lnstagram优选·2026-08-29·阅读 22 GEO检测（免费）

LeetCode 496下一个更大元素单调栈

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

LeetCode 496这道题，我前前后后给不少人讲过。每次讲到 Next Greater Element I，总会有人问：不就是两层循环暴力吗，为什么非要搞一种叫“单调栈”的东西？这个问题其实问得很好。暴力确实能过，但 LeetCode 考这道题，真正想让你练的就是单调栈这个思路。这篇题解我会把题目拆透、把两种常见写法的细节和区别讲清楚，再把我实际提交时踩过的坑一并列出来。

先说结论：这道题的最佳解法是用单调递减栈，配合哈希表做一次 O(n) 的预处理，之后查表拿到答案。整个过程不难，但前提是你真的理解“下一个更大元素”在遍历顺序里的含义，而不是死记模板。

1. 题目到底在问什么：初始条件里的三个隐藏信息

1.1 原题描述和示例回顾

LeetCode 496 的英文原名是 Next Greater Element I，中文一般叫“下一个更大元素 I”。题目给了两个数组 nums1 和 nums2，其中 nums1 是 nums2 的子集，也就是说 nums1 里的每个元素一定出现在 nums2 中。另外两个数组中的所有整数都是互不相同的。

要求对 nums1 中的每一个元素 x，找出 x 在 nums2 中的位置右侧第一个比它大的数。如果不存在，就返回 -1。最终返回一个和 nums1 等长的数组。

看两个官方示例：

示例 1：
输入：nums1 = [4,1,2]，nums2 = [1,3,4,2]
输出：[-1,3,-1]

解释起来是这样：数字 4 在 nums2 的位置右侧没有比它更大的数，所以是 -1。数字 1 在 nums2 中位置后面的第一个更大数字是 3。数字 2 已经在 nums2 的末尾，右边没有元素了，所以也是 -1。

示例 2：
输入：nums1 = [2,4]，nums2 = [1,2,3,4]
输出：[3,-1]

数字 2 右边第一个比它大的是 3，数字 4 右边没有更大的了，就返回 -1。

1.2 容易被忽略的三个约束条件

我建议大家读题时不要只盯着例子，约束条件才是真正决定解法边界的东西。这道题有三个约束非常关键：

第一，1 <= nums1.length <= nums2.length <= 1000。数据规模不大，意味着暴力 O(n*m) 在时间上是能跑完的，但 LeetCode 的测试用例里存在一些极端长度接近 1000 的情况，两层循环比较吃紧时会有很明显的等待感。面试场合直接写暴力，大概率会被追问优化方案。

第二，数组元素互不相同。这一点很多人一眼扫过就忘了，但它直接决定了一个核心决策——我们可以用哈希表 map<值, 下一个更大值> 来存储结果，而不用考虑多个相同值冲突的问题。正因为元素唯一，nums1 里的每个值都能快速定位到它在 nums2 中的状态。

第三，nums1 的所有整数都出现在 nums2 中。这个条件保证了我们不需要处理“在 nums2 中找不到某个元素”的情况，让哈希表查询必然命中，逻辑简单很多。

1.3 理解题意的一个小心机：关心的是值，不是位置

这道题虽然也涉及“位置”的概念，但最终输出的是“值”而不是下标。这和第二类“下一个更大元素”系列里的 739. Daily Temperatures 不同，739 要求返回距离天数，所以需要在下标层面计算差值；而 496 只需要拿到下一个更大元素本身。

所以我们的策略可以是：先完整遍历一遍 nums2，计算出每个元素的下一个更大元素，存在哈希表里，然后遍历 nums1 直接查表。这个思路非常朴素，但也是唯一不需要在每次查询时重新扫描 nums2 的做法。

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

2. 暴力解法不是不能用，但面试官想要的绝不止这个

2.1 暴力解法的完整代码和复杂度

抛开单调栈不谈，拿到这道题最先想到的解法一定是模拟。对于 nums1 中的每个元素 x，先在 nums2 中找到 x 的下标 pos，然后从 pos + 1 开始向后扫描，找到第一个大于 x 的值就停止。

C++ 实现如下：

cpp复制class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        vector<int> res;
        for (int x : nums1) {
            int pos = 0;
            while (nums2[pos] != x) {
                ++pos;
            }
            int ans = -1;
            for (int j = pos + 1; j < nums2.size(); ++j) {
                if (nums2[j] > x) {
                    ans = nums2[j];
                    break;
                }
            }
            res.push_back(ans);
        }
        return res;
    }
};

时间复杂度是 O(n*m)，n 是 nums1 的长度，m 是 nums2 的长度。空间复杂度是 O(1)，只用了一个结果数组。单看数据范围 1000 觉得无所谓，但如果把 nums2 长度放大到 10^5，这个解法就会立刻超时，所以它不是一个可扩展的方案。

2.2 暴力慢在哪：重复扫描是原罪

暴力最浪费的地方在于：每次为 nums1 中的一个数查找时，都要把 nums2 从目标位置到结尾扫一遍。而 nums1 里有多个元素的时候，后面的扫描动作完全是无状态、不共享的。

举个例子，nums2 = [5, 4, 3, 2, 1, 6]。扫描元素 5 时，需要依次看 4, 3, 2, 1 最后发现 6。扫描元素 4 时，又得看 3, 2, 1, 6。这些重复比较完全可以通过一次遍历提前把所有答案算出来。

这就是单调栈的切入点：用空间换时间，把每个元素右侧第一个更大的元素在一次遍历中全部算好。

2.3 什么时候可以继续用暴力

如果你的应用场景是静态数组、长度很小、且只查询一次，暴力其实完全够用，代码还更不容易出 bug。LeetCode 刷题阶段，我建议仍然把单调栈的写法练熟，因为后面 503、739、1019 这些题的解法核心都是单调栈，把 496 吃透相当于给一整类题打了底子。

我也遇到过一些初学者问我：能不能先把 nums2 中每个元素的位置记录到哈希表，比如 posOf[value] = index，然后查询时直接定位到下标再往后扫。这种优化确实比每次从头找下标要快一点，但复杂度仍然是 O(n*m)，因为“往后扫”这个动作没有被消除。它只能算暴力的小优化，不是质的提升。

3. 单调栈是常规操作：从右往左一次遍历就完成预处理

3.1 单调栈的生活类比和核心性质

在讲代码之前，我习惯用一个生活场景来比喻单调栈的运作逻辑。想象你在排队，每个人想找到自己右边第一个比自己高的人。如果从队尾往队头看，队伍里保持身材递增序列的人才有机会成为别人的“下一个更高者”，那些又矮又站在末尾的人，很快就会因为挡不住后面的人而被移出候选队列。

在这个场景里，栈就是候选项的集合，而且栈内元素从顶到底保持严格递减。为什么是递减？因为我们找的是“下一个更大元素”，所以栈顶必须是当前元素右侧最近的那个候选较大值；所有比当前元素小的栈元素都不可能成为当前元素或更左侧元素的“下一个更大元素”，可以直接丢弃。

这个丢弃动作体现的是数学上的单调性：如果 a < b，并且 b 出现在 a 的左侧，那么对于 a 左侧的元素而言，如果 b 不是它们的答案，那 a 更不可能是，因为 a 比 b 还矮。所以保留较高元素、移除较矮元素是安全的。

3.2 从右往左的完整算法步骤

具体操作分四步：

从 nums2 的最后一个元素开始向左遍历。
维护一个栈，栈中存放“已经遍历过的元素中，右侧候选的更大值”。
每当遇到一个新元素 x，先把栈中所有小于等于 x 的元素弹出，因为它们在 x 左侧的视野里完全失效。
弹出结束后，如果栈为空，说明 x 右侧没有比它更大的元素，记录 -1；否则记录栈顶元素作为答案。然后把 x 自己压入栈。

用代码写出来特别简短：

cpp复制class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int, int> nxt;
        stack<int> st;
        for (int i = nums2.size() - 1; i >= 0; --i) {
            while (!st.empty() && st.top() <= nums2[i]) {
                st.pop();
            }
            nxt[nums2[i]] = st.empty() ? -1 : st.top();
            st.push(nums2[i]);
        }
        vector<int> res;
        for (int x : nums1) {
            res.push_back(nxt[x]);
        }
        return res;
    }
};

这个写法有六个要点值得注意：

栈里的元素出现位置一定在当前元素右边。
栈顶是“右侧最近的可能更大值”。
while 循环保证了栈的单调性，而不是只弹一次。
弹出的元素不会影响左侧元素的答案，因为当前元素比它们更高且更靠左。
哈希表的 key 是元素值，value 是下一个更大元素值。
最后查表时，nums1 的顺序不需要调整，直接按原顺序输出即可。

3.3 手动模拟一遍示例，你会彻底理解

拿 nums2 = [1,3,4,2] 来模拟：

i=3，x=2。栈空，nxt[2] = -1，压入 2。栈：[2]。
i=2，x=4。栈顶 2 <= 4，弹出。栈空，nxt[4] = -1，压入 4。栈：[4]。
i=1，x=3。栈顶 4 > 3，不弹出。nxt[3] = 4，压入 3。栈：[4,3]。
i=0，x=1。栈顶 3 > 1，不弹出。nxt[1] = 3，压入 1。栈：[4,3,1]。

最后哈希表的状态是：{2: -1, 4: -1, 3: 4, 1: 3}，遍历 nums1 = [4,1,2] 得到 [-1,3,-1]，和预期完全一致。

整个过程每个元素最多入栈一次、出栈一次，所以预处理的时间复杂度是 O(m)，m 是 nums2 长度，后查询是 O(n)，整体 O(m+n)。空间复杂度 O(m)，用来存放哈希表和栈。

3.4 为什么栈内元素从顶到底要严格递减

这个问题值得单独说。如果我们允许栈内存在相邻的相等元素，那么查找“下一个更大”时会把等于自己的元素也算进去，题目要求是严格大于，所以等于的情况不能作为结果。在弹栈条件里使用 st.top() <= nums2[i]，就是为了把相等元素也弹掉，保证栈内严格递减。

严格递减带来的另一个好处是：栈顶元素一定大于栈中它下面的元素。这样每个元素找答案的时候，只需要看栈顶，如果栈顶不够大，它下面的元素更不可能够大。这正是单调栈能保持 O(1) 摊销查找的关键。

4. 换一条遍历方向：从左往右的思路上手更容易出 bug

4.1 从左往右的思路和代码

从右往左的写法是“边维护边查询”，逻辑直接。从左往右则是“延迟结算”：当你遍历到一个新元素 num 时，栈里所有比 num 小的元素，它们的“下一个更大元素”就是 num，所以可以依次弹出并记录答案，最后把 num 压入栈。

Python 实现如下：

python复制class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        nxt = {}
        stack = []
        for num in nums2:
            while stack and stack[-1] < num:
                nxt[stack.pop()] = num
            stack.append(num)
        # 栈中剩余元素没有更大的下一个元素
        return [nxt.get(x, -1) for x in nums1]

注意这里弹栈条件是 stack[-1] < num，也就是只处理严格小于的情况。如果当前 num 和栈顶相等，不弹出也不记录，因为相等不是“更大”。

4.2 两种方向的本质对比

我用表格来对比两个方向的异同，方便记忆：

维度	从右往左	从左往右
遍历顺序	从后向前	从前向后
查询时机	遇到元素时直接查栈顶	遇到更大元素时才结算先前元素
栈内元素含义	当前元素右侧候选项	尚未找到答案的左侧元素
弹栈条件	`栈顶 <= 当前`	`栈顶 < 当前`
栈的性质	严格单调递减（从顶到底）	严格单调递减（从顶到底）
原理解释难度	更直观	稍微绕一点，但对面试官展示理解深度更好

两者本质上没什么高下之分，只是视角不同。从右往左像“提前知道答案备查”；从左往右像“遇到大数就处理掉一堆积累的小数”。

4.3 面试时如果被追问“从左往右怎么写”

面试时，面试官很可能在你写出从右往左的版本后追问一句：“能不能换个方向，不用逆序遍历也能解？”这时候千万别慌，把上面从左往右的做法写出来就好。

但我要提醒一个容易翻车的地方：从左往右的版本中，如果处理完循环后栈里还有剩余元素，说明这些元素右侧没有更大的数，它们的答案就是 -1。在 Python 里用 nxt.get(x, -1) 可以优雅处理；在 C++ 里就需要对哈希表提前做默认值处理，或者等循环结束后遍历栈中剩余元素补上 -1，否则查表时会出现“找不到 key”的问题。

我在最初写 C++ 从左往右版本时，就是忘了处理栈里剩余元素，导致 nums1 里最后一个元素找不到 key，输出了一堆 0。这个坑并不是很隐蔽，但容易在紧张时忽略。

5. 提交记录里的真实教训：这些边界条件才是拿满分的分水岭

5.1 数组为空和长度极短的情况

题目约束规定了 nums1 和 nums2 至少有一个元素，但如果你用的是从左往右的写法，当 nums2 只有 1 个元素时，比如 nums2 = [5]，栈处理完就结束了。此时 nums1 也只能是 [5]，查询到的结果是 -1，这个逻辑必须成立。

而从右往左的写法天然支持空数组，因为循环体一次都不执行，哈希表为空，查询时返回空结果数组。但如果你的代码里用了数组下标访问而不是迭代器，遇到空 nums2 就可能越界。所以建议统一用范围 for 循环遍历，不要手动维护下标。

5.2 相等元素不会破坏唯一性，但不能当作答案

虽然题目说元素互不相同，但你仍可能在变式题中遇到相等元素，例如循环数组 503 题就可以有重复。在 496 中虽然用不到，但单调栈的弹栈条件里写 <= 还是 < 会直接影响行为。

如果写 while (!st.empty() && st.top() < nums2[i])，那么当栈顶等于当前元素时不会弹出，随后记录答案时会把相等元素当作“更大元素”记录下来，这是典型的逻辑错误。实际刷题时我建议一律写 < 当前 或者 <= 当前 之前想清楚语义再动手。

5.3 用值做哈希表的 key 还是用下标

496 因为元素唯一，用值做 key 完全没有问题。但如果题目允许重复，那用值做 key 就会导致后出现的相同数值覆盖先前的记录，答案出错。这种情况下，哈希表的 key 应该用下标，而不是值。

有一个很典型的变式题是 739. Daily Temperatures，它需要用下标差来算天数，所以栈里存下标，答案数组按下标写入。对应地，在 496 里如果栈里存下标，代码会变成这样：

cpp复制class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int, int> nxt;
        stack<int> st; // 存下标
        for (int i = nums2.size() - 1; i >= 0; --i) {
            while (!st.empty() && nums2[st.top()] <= nums2[i]) {
                st.pop();
            }
            nxt[nums2[i]] = st.empty() ? -1 : nums2[st.top()];
            st.push(i);
        }
        vector<int> res;
        for (int x : nums1) {
            res.push_back(nxt[x]);
        }
        return res;
    }
};

两种写法本身都对，但存值方式更简洁。建议初学阶段用值的方式即可，理解透彻后再看下标版本，这样对后面 739 才有更平滑的过渡。

5.4 我实际提交时遇到的一个隐蔽错误

有一次我在修改代码时，把 while 写成了 if，导致弹栈只执行一次。表面上遇到一些用例能通过，但一旦出现 nums2 = [1, 3, 1, 2]，查找元素 1 的答案时就会出错。

模拟一下：从右往左写，如果弹栈条件用 if，在 i=1 处 x=3 时，栈顶是 1，弹出 1 后栈里还有 [2]，但 if 只执行一次，于是栈顶变成 2，2 也小于 3，却没有被弹出，最后记录 nxt[3] = 2。如果 nums1 里恰好包含 3，返回结果就是 2，而不是正确答案 -1。这类问题很容易在真实测试用例中暴露，做题时一定要在脑内多跑几个连续逆序、连续递增的例子。

5.5 复杂度之外的性能细节

虽然哈希表能提供 O(1) 查询，但在 LeetCode 的测试环境下，unordered_map 的哈希开销并不小。如果你追求极致性能，可以考虑用一个足够大的静态数组做映射，因为数值范围在 0 到 10^4 以内，开一个长度为 10001 的数组即可，索引直接作为键。

这种优化对 496 来说是可行的，但对大规模数据不一定适用。虽然平时刷题不必追求极致性能，但了解这类技巧对面试聊起来很有帮助，至少能体现你清楚哈希表并不是唯一选择。

6. 从496到739再到556：Next Greater Element整个家族的答题模板

6.1 503. Next Greater Element II：循环数组怎么处理

这道题是 496 的直接升级版，数组变成一个环，要求每个元素的下一个更大元素。常见的处理方法是把原数组重复一遍拼接到末尾，或者用取模的方式模拟循环。核心还是单调栈，只是需要遍历两倍长度的数组。

在我自己的刷题节奏中，通常把 496 当作单调栈的入门题，503 当作巩固题。做 503 时要注意，栈内存的是下标而不是值，因为环形数组里相同的值可能代表不同位置，用值做记录会出错。

6.2 739. Daily Temperatures：答案从“值”变成“距离”

739 的题干和 496 很像：给一组每日温度，求每个温度之后经过几天才会遇到更高的温度。区别就是最后返回的是下标差，而不是温度值。因为要求距离，所以单调栈里必须存下标；当遇到更高温度时，用当前下标减去栈顶下标，就是等待天数。

理解 496 之后，739 的代码改动很小，我通常在 20 分钟内能写完并提交通过。这类题目能帮你下意识确认“单调栈存储的到底是值还是下标”这个关键问题。

6.3 556. Next Greater Element III：字符串和排列

556 表面上是找下一个更大元素，实际上是在考察“下一个排列”的算法。它给你一个正整数 n，要求找到一个比 n 大的最小整数，并且这个整数的各个数位是原数数位的重新排列。解法是先转字符串，然后从右向左找第一个下降点，再交换并反转后半段。

这道题和单调栈的关联不大，但名字里有 Next Greater Element，很多人会误以为要用单调栈，实际上它更接近经典的全排列工具题。我建议刷题时把它作为一个独立的专题来整理，不要和 496 强行混在一起。

6.4 1019. Next Greater Node In Linked List：链表形态下的单调栈

1019 是把数组换成了链表，做法是把链表转成数组，然后继续用从右往左的单调栈。这个题目适合用来检验你到底是背模板还是理解原理：如果你理解了单调栈依赖的是线性顺序，那么不管是数组、链表还是环形结构，本质都是一样的。

6.5 一个统一的答题模板

我把自己对单调栈题的总结浓缩成一个小模板：

确定遍历顺序：从右往左适合直接查询，从左往右适合延迟结算。
确定栈里存什么：存值还是下标，取决于最终答案是否需要下标差。
确定弹栈条件：小于等于还是小于，取决于你追求严格大于还是大于等于。
确定答案记录位置：从右往左是遇到元素就记录；从左往右是弹出时记录。

这个模板套用到 496、503、739、1019 都行。你在刷下一道题前，可以先自己用这个模板过一遍思路，再去看题解，收获会大得多。

我自己的刷题习惯是每道题做完后，在代码注释里写一行“这题用的是什么遍历方向、栈里存什么、弹栈条件是什么”，方便日后复习时一眼回忆起核心。LeetCode 周赛和日常刷题结合着来，很快就能把单调栈从“好像懂了”变成“真的会用”。