大厂算法面试里有道高频 Hard 题,卡住了不少人:在一个未排序数组里找缺失的最小正整数,还强制要求 O(n) 时间 + O(1) 空间。排序?不行。HashSet?也不行。这篇文章用 LeetCode 41 把「原地哈希」讲透,原理、代码、踩坑、追问全都有,看完就能直接作答。
一、题目:一道卡住不少人的 Hard 题
先看题目(LeetCode 41,缺失的第一个正数,Hard 难度):
给定一个未排序的整数数组
nums,找出其中没有出现的最小的正整数。 要求:时间复杂度 O(n),空间复杂度 O(1)。
示例:
输入: [1, 2, 0] 输出: 3
输入: [3, 4, -1, 1] 输出: 2
输入: [7, 8, 9, 11, 12] 输出: 1
这道题在字节、腾讯等大厂的面试中出镜率极高,属于必刷级别。它看着平平无奇,却被标成 Hard,难就难在两条硬约束把你最顺手的路全堵死了:想排序,时间超标;想开哈希表,空间超标。逼着你"螺蛳壳里做道场"。
它其实不考什么高深的算法模型,考的是你对数组特性的理解,以及把空间利用到极致的能力。我自己第一次做的时候,第一反应也是开个 HashSet,写完才发现空间不达标,盯着数组本身看了半天才想通。想通之后,代码其实只有十几行。
二、动手前先框住答案:鸽巢原理定乾坤
先记住一个结论,它是整道题的分水岭:
长度为 n 的数组,缺失的最小正整数一定落在 [1, n+1] 区间内。
证明很简单,就是鸽巢原理:
- n 个位置最多装下 n 个不同的正整数。如果 1 到 n 全都出现了,数组正好装满,答案只能是
n+1; - 只要 1 到 n 里有任何一个没出现,答案就一定在 1 到 n 之间,不可能超过 n。
别小看这一句,它真正的作用是把"无限"的搜索空间压缩成了 n 个候选桶:我们只需要关心 1 到 n 这 n 个数有没有出现,负数、0、大于 n 的超大数全都是干扰项,原地忽略即可。
有了这个范围收缩,后面的原地哈希才有了可能——既然答案范围和数组长度正好对上,那能不能干脆把数组的下标本身当成哈希表的 key?
答案是:能。
面试加分项:主动讲清楚"为什么只看 1~n 就够",把"范围缩放"和"原地哈希"这两步连起来说,就是一套高分回答。
三、思路演进:为什么排序和 HashSet 都不及格
面试时建议先主动把思路演进过程摆出来,再引出最优解,这个节奏比直接甩答案加分得多:
| 方案 | 时间 | 空间 | 是否达标 | 面试官心理活动 |
|---|---|---|---|---|
| 排序后扫描 | O(n log n) | O(1)~O(n),视排序实现 | ❌ | "能想到,但没听清 O(n) 的要求" |
| HashSet / 布尔数组打表 | O(n) | O(n) | ❌ | "能过,但没听懂 O(1) 的约束" |
| 原地哈希(置换归位) | O(n) | O(1) | ✅ | "嗯,这人懂下标当桶" |
| 符号标记法 | O(n) | O(1) | ✅ | "会两种写法,可以聊聊工程权衡" |
前两种方案不是废物,它们在面试里是绝佳的铺垫:排序死在时间上,HashSet 死在空间上,剩下的路只有一条——把数组本身榨干。
用一位面试官的原话说:能写出哈希表解法只能算及格,能写出原地哈希并把时间复杂度解释清楚,才算优秀。
四、核心思路:把数组本身变成哈希表
核心思想一句话:
值
x就应该住在下标x-1的位置上。 把每个数"送回家",最后扫一遍谁家没人。
用班主任排座位来打比方:数组是一排编号 0 到 n-1 的座位,数字是拿着学号的学生,学号 x 的学生应该坐到第 x-1 号座位。等所有人都对号入座,从头扫一遍,第一个"座位号 ≠ 学号"的位置就是答案。
下标与值的对应关系:
| 数组下标 | 0 | 1 | 2 | … | n-1 |
|---|---|---|---|---|---|
| 应存放的值 | 1 | 2 | 3 | … | n |
归位规则只有三条:
- 只处理
1 <= nums[i] <= n的元素,其余的原地当"无效占位",完全不用管; - 若
nums[i]不在正确位置,且目标位置上的值不等于它,就交换; - 归位完成后扫描:第一个满足
nums[i] != i + 1的下标i,答案就是i + 1;若全部匹配,答案是n + 1。
单个位置的处理逻辑画成流程图:
思路到这就通了,但真正写代码时,很多人会在细节上翻车。我们先手动过一遍完整例子,再把过程翻译成代码。
五、手撕演示:[3, 4, -1, 1] 的归位全过程
以 nums = [3, 4, -1, 1](长度 n = 4)为例,我们只处理 1~4 范围内的有效数:
| 步骤 | 当前 i | 数组状态 | 动作说明 |
|---|---|---|---|
| 1 | i=0 | [3,4,-1,1] | 3 应住下标 2,与 nums[2] 交换 |
| 2 | i=0 | [-1,4,3,1] | 3 归位;换来的 -1 是无效值,跳过,i++ |
| 3 | i=1 | [-1,4,3,1] | 4 应住下标 3,与 nums[3] 交换 |
| 4 | i=1 | [-1,1,3,4] | 4 归位;换来的 1 也要归位,继续换 |
| 5 | i=1 | [1,-1,3,4] | 1 归位到下标 0;换来的 -1 无效,i++ |
| 6 | i=2 | [1,-1,3,4] | nums[2]=3 == 2+1,已在正确位置,i++ |
| 7 | i=3 | [1,-1,3,4] | nums[3]=4 == 3+1,已在正确位置,遍历结束 |
最后扫描校验:
- i=0 → 值为 1,匹配;
- i=1 → 值为 -1,不匹配 → 缺失的最小正整数 = i + 1 = 2。
注意第 4、5 步:4 归位之后,换来的 1 也是个"要回家的人",得接力把它送走。这个细节直接决定了代码里该用 while 还是 if,下一节就讲。
六、代码实现,以及三个决定生死的细节
Java 实现(交换置换法,面试最常考,推荐作为主推写法):
class Solution {
public int firstMissingPositive(int[] nums) {
int n = nums.length;
// 第一阶段:原地置换,让每个合法值 x(1<=x<=n)回到下标 x-1
for (int i = 0; i < n; i++) {
while (nums[i] >= 1 && nums[i] <= n
&& nums[nums[i] - 1] != nums[i]) {
int targetIdx = nums[i] - 1;
int temp = nums[i];
nums[i] = nums[targetIdx];
nums[targetIdx] = temp;
}
}
// 第二阶段:线性扫描,找第一个下标与值不匹配的位置
for (int i = 0; i < n; i++) {
if (nums[i] != i + 1) {
return i + 1;
}
}
// 1~n 全部出现,答案是 n+1
return n + 1;
}
}
代码很短,但里面藏着三个细节,错一个就翻车。
细节一:为什么用 while 而不是 if
交换到当前位置的那个数,可能也需要归位。用 if 只归位一轮,换进来的数就继续"流浪"了。
拿 nums = [3, 1, 2] 举例:i=0 时把 3 换到下标 2,得到 [2,1,3],换来的 2 还得再换到下标 1,才能变成 [1,2,3]。连续两次交换,if 会漏掉第二次,直接给出错误答案。
细节二:nums[nums[i]-1] != nums[i] 是保命条件
没有它,遇到 [1,1] 这种输入:nums[0]=1,目标位置就是 0,自己和自己交换,数组纹丝不动,循环条件永远成立——死循环,直接 swap 到天长地久。
加上这个判断后:目标位置上已经是正确的值(说明重复元素已经处理过),就不交换,天然规避重复值导致的死锁。
细节三:双层循环,凭什么还是 O(n)
这是面试官最爱追问的一点,建议主动讲出来:
每一次交换,都至少让一个数字到达它的"最终位置",之后再也不会被移动。 数组一共 n 个元素,交换总次数不超过 n 次,所以整个 while 过程是均摊 O(n),而不是看上去的 O(n²)。
技术亮点汇总:
- 空间 O(1):原地修改输入数组,没有任何额外数据结构,完美满足常数空间要求;
- 时间 O(n):两次线性扫描 + 至多 n 次交换,在 1e5 长度的大数组场景下,相比"奢侈哈希"方案直接省掉哈希表的内存开销,性能优势明显;
- 天然处理边界:负数、0、大于 n 的超大数会被 while 条件自动过滤,无需任何预处理;
&&短路还顺带规避了Integer.MIN_VALUE - 1这类溢出风险。
面试时把这个写法写出来,基本就稳了。但如果面试官追问一句"能不能不交换位置?",下面这个备选写法就是你的加分机会。
七、还没完:符号标记法(备选写法)
同样是原地哈希,还有一种不动元素位置的思路:用负号当"出现过"的标记。分三步:
- 清洗无效值:把所有非正数替换成哨兵
n + 1(它们不可能是答案); - 打标记:遍历数组,对每个
x = |nums[i]|,若x <= n,就把nums[x-1]置为负数,表示"x 来过"; - 验收:第一个仍然是正数的位置,就是缺失的那个数。
class Solution {
public int firstMissingPositive(int[] nums) {
int n = nums.length;
// 第一步:清洗无效值,非正数替换为哨兵 n+1
for (int i = 0; i < n; i++) {
if (nums[i] <= 0) {
nums[i] = n + 1;
}
}
// 第二步:用负号标记出现过的数字
for (int i = 0; i < n; i++) {
int x = Math.abs(nums[i]);
if (x <= n) {
nums[x - 1] = -Math.abs(nums[x - 1]);
}
}
// 第三步:第一个仍为正数的位置就是答案
for (int i = 0; i < n; i++) {
if (nums[i] > 0) {
return i + 1;
}
}
return n + 1;
}
}
这个写法有两个加分点:
- 还有一种变体:先扫一遍判断 1 是否存在(不存在直接返回 1),再把所有越界值统一压成 1 来做标记,效果等价,少一次对哨兵值的判断;
Math.abs(Integer.MIN_VALUE)仍然是负数(正数范围比负数少一个),这是 Java 里经典的坑。不过在这个写法里,第一步清洗已经把所有值压进了[1, n+1],天然排除了溢出风险——面试时把这个细节讲出来,面试官会抬头看你。
两种写法对比,技术选型一目了然:
| 维度 | 交换置换法 | 符号标记法 |
|---|---|---|
| 核心动作 | 把值 x 送到下标 x-1 | 给出现过的 x,在下标 x-1 处打负号 |
| 对原数据的改动 | 改变元素位置 | 不改变元素相对位置,只改值的符号 |
| 代码形态 | 一个 while 搞定,短 | 需要先清洗无效值,步骤略多 |
| 典型坑点 | 重复值死循环 | 符号处理、Math.abs 的坑 |
| 使用建议 | 面试主推写法 | 面试官要求"不移动位置"时的加分弹药 |
主武器和备用武器都有了,接下来看看子弹容易打在哪。
八、避坑清单:90% 的人栽在这几个地方
这些是我汇总模拟面试和实战后整理的高频翻车现场,建议收藏:
| # | 坑点 | 翻车现场 | 正确姿势 |
|---|---|---|---|
| 1 | 用 if 不用 while | 只归位一轮,[3,4,-1,1] 直接答错 | 用 while,换进来的数接力归位 |
| 2 | 漏掉重复值判断 | [1,1] 自己和自己换,无限循环 | 加 nums[nums[i]-1] != nums[i] 短路 |
| 3 | 不做范围守卫 | 负数、0、超大数让 nums[i]-1 越界 | 先判 1 <= x <= n,&& 短路天然兜底 |
| 4 | swap 用异或写法 | i == j 时异或会把值清零 | 老实临时变量,可读性大于炫技 |
| 5 | 忘记 n+1 兜底 | [1,2,3] 这类完整序列越界访问 | 扫描无错位就返回 n+1 |
| 6 | 看到双层循环就认 O(n²) | 复杂度被面试官质疑 | 均摊分析:交换总次数 ≤ n |
| 7 | 标记法里 Math.abs | Math.abs(Integer.MIN_VALUE) 仍是负数 | 前置清洗把值压进 [1, n+1] |
第 4 条多说一句:有人喜欢用异或来写 swap 秀操作,但这道题里,当 nums[i] 已经在正确位置时,targetIdx 就等于 i,异或"秀"完值直接没了。临时变量三行,踏实。
九、面试追问小抄
写法之外,追问才是真正的拉分点。高频问题和答题要点都备好了:
Q1:数组里全是负数,答案是什么? 返回 1,因为最小的正整数 1 没出现。
Q2:数组正好是 [1,2,3,...,n] 完整序列呢?
返回 n+1,代码末尾的兜底逻辑正好覆盖。
Q3:为什么要忽略负数和大于 n 的数? 答案范围是 [1, n+1],这些数不可能是答案,忽略它们也不影响 1~n 的占位。
Q4:面试官说"不许修改原数组"怎么办?
先反问确认约束:如果仍坚持 O(1) 空间 + O(n) 时间,那无解;退让方案是拷贝后排序(O(n log n) 时间),或者用位图 / BitSet(O(n) 空间)。其中 BitSet 的空间约 O(n/8),常数比布尔数组降 32 倍,这个答案很有工程味。
Q5:如果要找缺失的前 k 个正数呢? 归位之后,1~n 中空位的下标就是答案,扫一遍取前 k 个;不足 k 个,从 n+1 往后补齐。仍然是 O(n)。
Q6:如果数组只读,但允许 O(n) 空间?
直接开 boolean[] seen = new boolean[n+1],或者用 BitSet 省内存,打表后扫描即可。
Q7:这思路在项目里有什么用? 这问出现率意外地高,可以准备两个真实场景:
- 分布式 ID 空洞检测:分库分表后各分片自增 ID 有跳号,用类似思路扫一遍订单号区间,快速定位"缺失号段",触发补偿对账;
- 网关消息序列号断流检测:消息序列号出现断流时,同样的思路可以快速定位断点。
算法不只是刷题,能落到业务场景里,面试官才会真的信服。
十、测试用例自查清单
代码写完别急着交,先把这组边界用例在脑子里跑一遍:
[] → 1
[1] → 2
[2,1] → 3
[1,1] → 2
[1,2,0] → 3
[3,4,-1,1] → 2
[7,8,9,11,12] → 1
[1,2,3] → 4
[0,-1,-2] → 1
覆盖了空数组、单元素、重复值、全无效值、完整序列这几类边界,全过就可以放心提交了。
十一、带走这三句话
整篇文章压缩成一个背诵版:
长度为 n 的数组,答案必在 [1, n+1];把每个数送到下标 x-1 的家,用 while + 去重判断避免死循环,最后扫空位。均摊 O(n)、空间 O(1)。
再压缩一句就是:坑位对号入座,谁没坐谁就是答案。
这道题的「原地哈希」套路不是孤例,LeetCode 442「数组中重复的数据」和 448「找到所有数组中消失的数字」本质都是同一招,吃透这一道,等于连刷三道题。这类大厂高频题解析我会持续更新,觉得有用的话可以点个关注,不迷路。
最后给三个落地建议:
- 遇到带约束的题,先从约束里框出答案范围,范围收缩往往是破题的起点;
- 把"while + 范围守卫 + 去重判断"这个三件套记牢,这是原地哈希的防翻车精髓;
- 提交前脑跑一遍边界用例,一分钟自查,胜过被面试官追问时现场补救。
这道题还教会我们一件事:约束即思路——正是 O(1) 空间把门焊死,才逼出"把数组本身用成哈希表"这个妙招。很多时候,题目的限制本身就是最诚实的提示。
留言聊聊:你第一次看到这道题时,第一反应是什么写法?是直接想到原地哈希,还是先开了个 HashSet?或者你有没有被重复值坑出过死循环?评论区聊聊你的翻车现场,我挑几个典型的展开讲讲。
觉得有帮助的话,点赞、在看走一波,你的支持是我持续更新的动力。