缺失的第一个正数：原地哈希与O(1)空间复杂度解法详解

做过几年算法面试题的人，大概率都碰过这道题：给定一个未排序的整数数组，找出其中没有出现的最小的正整数。题目看起来人畜无害，样例也简单，可一旦加上“时间复杂度O(n)、空间复杂度O(1)”这两个条件，难度直接翻倍。我最早刷到它的时候，第一反应是排序后扫一遍，结果被复杂度要求堵死；后来又想着用哈希表，又被空间卡住。折腾了一晚上才摸到“把数组本身当成哈希表”这条路，那一刻是真的有醍醐灌顶的感觉。

这篇文章我打算把“缺失的第一个正数”从暴力解法到最优解完整拆一遍，重点讲清楚两种经典的最优实现——原地标记法和置换法，包括它们的原理、代码、边界条件和实测中容易踩的坑。无论你是在准备面试、复习算法，还是纯粹想练数组操作，这篇都能给你一些值得收藏的东西。

1. 问题定义与复杂度分析

1.1 题目到底在问什么

先明确一下题目本身。给一个未排序的整数数组 nums，要求返回其中没有出现的最小的正整数。注意三个关键词：正整数、最小、没出现。

举个例子：nums = [3, 4, -1, 1]，正整数有1、3、4，缺的是2，所以答案是2。再比如 nums = [7, 8, 9, 11, 12]，数组里最小的正整数是7，1压根没出现，所以答案是1。这个例子容易让人误解，很多人会下意识在数组里从前往后找“断档”，但这里的关键是从1开始枚举，而不是从数组最小值开始。

还有一类例子要注意：nums = [1, 2, 0]，1和2都在，3没出现，所以答案是3，不是0，因为0不是正整数。这点新手特别容易错。

1.2 表面简单，实则全是边界条件

这题之所以被归为“困难”级别，不是因为思路有多高深，而是边界条件极其密集。我总结下来主要有这几类：

• 数组里有负数、零，它们既不参与答案判断，又占着空间。
• 数组里的正数可能非常大，比如 2147483647，远超数组长度。
• 数组里有重复数字，处理时要防止重复标记导致误判。
• 答案可能是 n + 1，也就是数组恰好包含了1到n的所有整数。

这四条单拎出来哪条都不难，但全凑在一起，代码里漏掉任何一条都会出错。这就是为什么很多人看题解觉得“这也不难啊”，一写就废。

1.3 复杂度限制才是灵魂

题目要求时间复杂度O(n)、空间复杂度O(1)。这意味着：

• 不能排序，因为排序最快也是O(n log n)。
• 不能开额外的哈希表或Set，因为那是O(n)空间。
• 只能在原数组上做文章，而且最多只能常数级额外变量。

直觉上“找缺失数字”就是哈希表的活，现在哈希表不让用了，怎么办？答案是把数组本身改造成哈希表。这个思路是这题的核心，也是后面所有解法的基础。我后面会用一个比喻来解释它：想象你有一排抽屉，编号从1开始，你要检查哪些编号的球出现过，但你不允许拿本子记录，只能靠摆弄抽屉本身来留下痕迹。

2. 从暴力到哈希表：先解开思路的第一层

2.1 暴力解法：二重循环逐个查

最朴素的想法是从1开始枚举正整数，逐个在数组里线性查找：

python复制def firstMissingPositive(nums):
    i = 1
    while True:
        if i not in nums:
            return i
        i += 1

每次 i not in nums 都是O(n)的扫描，最坏情况下要查 n+1 次，所以整体时间复杂度是O(n²)。这个解法思路完全正确，但复杂度无法接受。它的问题在于：没有利用已经扫描过的信息。

实际上这道题有个隐藏性质：对于长度为n的数组，答案一定落在 [1, n+1] 这个区间里。为什么？因为如果1到n全都出现过，那么数组里至少有n个互不相同的正整数，正好把区间填满，答案就是n+1；只要有任何一个缺失，缺失的那个就是答案，它必然不超过n。这个结论是后续所有优化方案的理论基石。

2.2 哈希表解法：O(n)时间，但空间超了

既然线性查找慢，那就用哈希表加速：

python复制def firstMissingPositive(nums):
    seen = set(nums)
    for i in range(1, len(nums) + 2):
        if i not in seen:
            return i

时间复杂度O(n)，但额外开了O(n)的集合。如果题目不限制空间，这个解法已经足够好了，代码简洁、不易出错、可读性高。可一旦面试官补一句“空间复杂度能不能也做到O(1)”，你就得硬着头皮改造了。

2.3 核心洞察：既然不能用外部哈希表，就复用数组本身

哈希表能做到O(1)查询，本质是“值到位置的映射”。这里有个关键观察：如果我们把数组的下标当成哈希表的key，数组的值当成value，不就能在O(1)空间内完成同样的工作吗？而且哈希表需要解决的核心问题是：如何记录“数字x是否出现过”。

但数组的下标只有0到n-1，怎么映射？最自然的做法是把数字 x 映射到下标 x-1。这样 nums[x-1] 就可以承载“x是否出现”的信息。问题在于，数组每个位置已经存了一个原始值，如果直接在原值上记录“出现过”，会破坏后续读取。所以我们需要一种“既能记录状态、又不丢失原值”的编码方式。

这就是两种经典解法的分水岭：一种用正负号编码状态，一种用交换把数字送回“家”。

3. 核心解法：原地数组标记法（正负号标记）

3.1 思路拆解：把数组变成一排抽屉

想象你有n个抽屉，编号分别是1到n，每个抽屉里放着一张纸条，纸条上写着一个数字。你的任务是在不借助任何外部记录的前提下，检查“第1个抽屉有没有1号球”“第2个抽屉有没有2号球”，以此类推。

正负号标记法是这样做的：我规定，如果一个抽屉里的纸条是负数，说明这个抽屉对应的编号出现过。举例来说，如果 nums[2] 被改成负数，就说明数字3出现过（因为 3 -> 下标2）。这样，我只需要扫描一遍数组，每遇到一个值 x，就跑到 nums[x-1] 那里，把它变成负数，打上一个“已出现”的印记。

这个方法有两大难题需要解决：

1. 初始数组里就有负数，怎么区分“原本就是负的”和“被打过标记的”？
2. 遇到的值可能是0、负数、大于n的数，它们不对应任何抽屉，怎么办？

答案是：第一步先统一清洗，把所有不合规的数字全部替换成一个“合法但不影响结果”的占位值。

3.2 三步走：清洗、标记、扫描

代码实现分三步：

cpp复制int firstMissingPositive(vector<int>& nums) {
    int n = nums.size();

    // 第一步：清洗。先把不合规的值全部换成 1
    bool hasOne = false;
    for (int i = 0; i < n; i++) {
        if (nums[i] == 1) hasOne = true;
        if (nums[i] <= 0 || nums[i] > n) {
            nums[i] = 1;
        }
    }

    // 如果数组里压根没有 1，答案就是 1，直接返回
    if (!hasOne) return 1;

    // 第二步：标记。遍历数组，把每个出现过的数字 x
    // 对应到下标 x-1，并把该位置的值改成负数
    for (int i = 0; i < n; i++) {
        int idx = abs(nums[i]) - 1;
        if (nums[idx] > 0) {
            nums[idx] = -nums[idx];
        }
    }

    // 第三步：扫描。找第一个还为正数的位置，返回 i + 1
    for (int i = 0; i < n; i++) {
        if (nums[i] > 0) {
            return i + 1;
        }
    }

    // 所有 1 到 n 都出现过，返回 n + 1
    return n + 1;
}

注意第一步里 hasOne 的判断必须在替换之前完成。我见过有人把顺序写反，先替换再判断 hasOne，结果数组里只要有任何不合规的数，替换后全都变成1，hasOne 被误判为 true，整个算法直接失灵。这个顺序问题非常隐蔽，特别容易在紧张的时候写错。

3.3 几个必须解释清楚的细节

第一个细节：为什么清洗时把不合规的值换成 1，而不是0或者别的数？因为后续的标记阶段，我们需要读取 nums[i] 的值来定位下标，如果 nums[i] 是0，abs(0) - 1 是-1，数组下标直接越界。换成1则刚好落在第一个抽屉，且因为1在合法的 [1, n] 区间内，不会再触发清洗条件。要换只能换一个“合法但不干扰结果”的数，1就是最好的选择。

第二个细节：清洗时把大于n的数也换成1，会不会把原本“n+1出现过”这个信息弄丢？不会，因为我们已经证明答案最大就是n+1。只有当1到n全部出现过时，答案才是n+1；而这种情况下一旦n+1真的出现，它也不会影响“1到n全部出现过”的判断。换句话说，大于n的数对答案没有任何贡献，留着反而碍事。

第三个细节：标记阶段用 abs(nums[i]) - 1 取下标，是因为 nums[i] 可能在之前的标记中被改成了负数。打个比方，数组 [3, 1, 2]，遍历到 nums[0]=3 时会把 nums[2] 改成负数；遍历到 nums[2] 时，它的值已经是负数了，如果直接拿负数去算下标就错了。取绝对值是为了保证定位正确，这也是这种标记法最容易写漏的地方。

第四个细节：标记时用 if (nums[idx] > 0) 避免重复标记导致符号翻转。如果数组里有重复数字，比如 [2, 2]，第一次遇到2时把 nums[1] 改为 -2，第二次遇到2时发现 nums[1] 已经是负数，如果直接执行 nums[idx] = -nums[idx]，它会从 -2 变成 2，等于把标记又擦掉了，最终误判。这个坑极隐蔽，实测中很多人都是在这里翻车的。

3.4 复杂度分析

标记法的时间复杂度是O(n)：清洗一遍O(n)，标记一遍O(n)，扫描一遍O(n)，三趟循环加在一起常数次。空间复杂度是O(1)，只用了若干个整数变量。也就是说，它完全满足题目的硬性要求，而且代码逻辑清晰，每一步都能说出“为什么”。

我自己的经验是，这套思路一旦理解透彻，基本不会忘，因为它把“哈希表”这个抽象概念具象成了“用正负号打标签”的生活化操作，记忆负担小很多。面试的时候，如果能把这一步一步讲给面试官听，对方通常会觉得你是真懂，而不是背题。

4. 另一种经典实现：置换法（占位法）

4.1 思路：直接把数字送回“家”

标记法是用正负号做标记，还有一种思路更直观：让数组下标 i 的位置存数字 i+1，也就是让 nums[i] == i + 1 恒成立。这样数组就变成了“家有序位”的抽屉：1号抽屉放着1，2号抽屉放着2，依此类推。最后再扫一遍，哪个抽屉里的数字对不上号，那个抽屉对应的数字就是缺失的。

cpp复制int firstMissingPositive(vector<int>& nums) {
    int n = nums.size();

    for (int i = 0; i < n; i++) {
        // 只要当前位置的数字是合法正数，且没有回到家，就不断交换
        while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) {
            swap(nums[i], nums[nums[i] - 1]);
        }
    }

    // 扫描：第一个 i + 1 != nums[i] 的位置就是答案
    for (int i = 0; i < n; i++) {
        if (nums[i] != i + 1) {
            return i + 1;
        }
    }

    return n + 1;
}

关键在 while 循环里那三个条件，缺一不可：

• nums[i] > 0：负数、零没必要回家，它们没有对应的家。
• nums[i] <= n：超出n的数，家在外面，管不了。
• nums[nums[i] - 1] != nums[i]：如果目标家已经住了同样的数字，说明这个数字已经归位了，再交换会死循环。

第三点特别重要。比如数组 [2, 2]，i=0时，nums[0]=2，目标位置是 nums[1]，而 nums[1] 也等于2，条件不成立，直接跳过。否则你会在两个2之间来回交换，永远出不了循环。

4.2 与标记法的对比

两个解法都是O(n)时间、O(1)空间，但各有优劣。我整理了一张对比表：

我个人在实际刷题时更偏爱置换法，因为代码短、思路像“整理书架”，遇到对不上的书抽出来放到它该在的位置，重复操作直到整排书各就各位，最后一眼就能看到空位。但如果你是在给面试官讲思路，标记法反而更容易把“数组当哈希表”这个核心洞察表达清楚。

4.3 置换法的复杂度到底是多少

有人会担心，while 循环里可能会交换很多次，复杂度会不会变成O(n²)？不会。因为每一次交换都会把一个数字送到它最终该待的位置，而一个数字一旦归位，以后就再也不会被移动了。最多n次交换，所有能归位的数字就会全部归位，后面的循环就只是空转判断条件。所以总交换次数是O(n)，整体复杂度还是O(n)。

顺便说一句，如果要证明“每个数字最多被交换一次”，最直观的说法是：交换的目标位置 nums[i] - 1 指向的坑位一旦填入正确数字，这个坑位就满了；而一个坑位只会被填满一次，所以交换次数不超过n。这个论证在面试中说出口，是很加分的。

5. 实操验证：本地测试与边界用例

5.1 测试用例怎么设计

写算法题最忌讳只跑一遍示例就交。这道题的边界条件极多，我建议至少准备这些用例：

尤其是空数组这个用例。n=0 时，两个解法的扫描循环都不会执行，直接返回 n+1=1，这是对的。但如果你用的是哈希表解法，range(1, 2) 也能正常返回1，倒是不容易出错。真正的坑在于标记法如果没有处理 hasOne 为false的情况，空数组走完清洗阶段后直接进入标记，nums[idx] 就会越界，程序直接崩溃。

5.2 我实际跑出来的踩坑记录

我用 C++ 和 Python 各实现了一遍，把五个最容易出错的细节全部踩了一遍，逐个说下现象和修正：

第一个坑：清洗阶段把小于等于0的值换成1后，忘记先判断数组里原本有没有1。结果输入 [-1, -2] 时，数组变成 [1, 1]，算法误判1出现过，返回3，正确答案是1。

第二个坑：标记阶段没有取绝对值。输入 [3, 1, 2]，遍历到 nums[0]=3 时把 nums[2] 改成负数，遍历到 nums[2] 时 nums[2] 已经是负数，nums[nums[2]] 直接越界，程序抛异常。

第三个坑：重复标记导致符号翻转。输入 [2, 2, 1]，第一次遇到2把位置1标记为负，第二次遇到2又把位置1从负翻正，最终位置1是正数，误判2没出现，返回2，正确答案是3。

第四个坑：置换法忘记判断 nums[nums[i] - 1] != nums[i]，输入 [2, 2] 直接死循环。这个坑比较恐怖，因为程序不会报错，而是卡住不动。

第五个坑：Python 里的整数没有溢出问题，但 C++ 里 abs(INT_MIN) 会溢出。不过题目给的是“整数数组”，如果输入包含 INT_MIN，abs 出来的还是负值，下标的计算就会出错。好在LeetCode的测试数据通常不会变态到这种程度，但作为工程习惯，我会在实现里对 >= n 的值提前过滤掉，避免这个隐患。

5.3 一段可用于验证的完整测试代码

为了方便读者本地复现，我写了一个简单的测试框架，用 C++ 实现所有用例：

cpp复制#include <iostream>
#include <vector>
using namespace std;

int firstMissingPositive(vector<int>& nums) {
    int n = nums.size();
    bool hasOne = false;
    for (int i = 0; i < n; i++) {
        if (nums[i] == 1) hasOne = true;
        if (nums[i] <= 0 || nums[i] > n) nums[i] = 1;
    }
    if (!hasOne) return 1;
    for (int i = 0; i < n; i++) {
        int idx = abs(nums[i]) - 1;
        if (nums[idx] > 0) nums[idx] = -nums[idx];
    }
    for (int i = 0; i < n; i++) {
        if (nums[i] > 0) return i + 1;
    }
    return n + 1;
}

void test(vector<int> nums, int expected) {
    int result = firstMissingPositive(nums);
    cout << (result == expected ? "PASS" : "FAIL")
         << " | expected: " << expected
         << " | got: " << result << endl;
}

int main() {
    test({3, 4, -1, 1}, 2);
    test({-1, -2, 0}, 1);
    test({1, 2, 0}, 3);
    test({1, 2, 3}, 4);
    test({2, 2, 1}, 3);
    test({1, 2, 3, 4}, 5);
    test({7, 8, 9, 11, 12}, 1);
    test({}, 1);
    return 0;
}

这组用例在我的机器上全部 PASS。建议读者把这份代码拷贝下来，改一改输入多跑几轮，尤其是把标记法和置换法都跑一遍，观察数组在每一趟循环结束后的中间状态，对理解算法非常有帮助。

6. 常见问题与排查实录

6.1 高频报错速查表

我总结了一张速查表，基本覆盖了这道题常见的所有问题：

6.2 调试技巧：打印中间状态

我强烈建议调试时打印每一趟循环结束后的数组状态。标记法经过清洗、标记、扫描三步，中间状态差异很大，通过打印可以直观看到某个值是否被正确标记。

举个例子，输入 [3, 4, -1, 1]，清洗后变成 [3, 4, 1, 1]，注意原来-1的位置变成了1，这并不代表“1重复出现”，只是占位符。标记阶段，3会把下标2标记为负，4会把下标3标记为负，1会把下标0标记为负，最终数组变成 [-3, 4, -1, -1]。扫描时发现 nums[1] 还是正数，说明数字2没出现，返回2。这个中间过程只看代码可能绕，打印出来一目了然。

6.3 变体扩展与延伸思考

把这题吃透之后，可以顺手想一想几个变体，能帮你把思路迁移到更多场景：

• 如果把题目改成“缺失的第一个非负整数”，怎么改？答案是让下标i对应数字i，清洗范围变成 [0, n]，其余逻辑几乎不变。
• 如果要求返回所有缺失的正数，怎么做？可以在标记法基础上二次扫描，把所有正数位置对应的数字收集起来；或者用置换法，把归位后所有不对应的位置收集起来。空间复杂度仍然可以做到O(1)。
• 如果原数组只读，不允许修改，O(1)空间还能做吗？这就比较难了，通常需要借用抽屉原理或者二分思想，属于进阶题范畴，面试中能答出“不能O(1)空间，需要O(n)空间或允许修改数组”就足够了。

这些变体本质上都在考察同一个思维模式：当你要记录“一堆数字中谁出现过”时，不一定非要用哈希表，数组本身的下标就是天然的哈希桶。理解了这一点，迁移到“树状数组上二分”“逆序对”这类题目时，你也会多一层直觉，因为它们同样是在利用数组的索引结构做信息压缩。

6.4 这题的工程意义

有人会问，这种纯算法题工程里真的用得上吗？我的答案是：直接用的场景不多，但背后的思想很常见。比如在内存受限的嵌入式环境里，你需要在有限空间内判断哪些ID出现过；在数据库查询优化中，利用索引下标加速存在性判断；甚至在日志分析里，用位图法标记海量数据中的重复项。这些场景本质上都是“用索引当哈希表”的变体。

我当年在一段C++嵌入式代码里就写过类似的标记逻辑：设备上报的一批传感器ID需要快速去重，ID范围刚好是1到256，不能开大数组，于是就用一个32字节的位图，把每个ID对应的位置置1。这个思路和今天的标记法一模一样，只是把“正负号”换成了“比特位”。所以别看它是一道面试题，背后的工程价值是实打实的。

回到这道题本身，我个人体会最深的一点是：面对复杂度限制，不要急着否定一切，而是去想怎么把手头已有的资源利用到极致。数组就是手头唯一的资源，哈希表的“键值映射”能力它可以模拟，状态记录能力它也可以通过符号位实现。想通这一层，这类题就不再是背解法，而是一种可以迁移的思维工具。

最后再分享一个实操小技巧：如果你在面试时被问到这道题，先别急着写代码，把“答案一定在1到n+1之间”这个关键性质讲出来，再说“因为不能用额外空间，所以我把数组改造成哈希表”，然后分三步讲清楚清洗、标记、扫描。这套话术本身就是得分点，能让面试官觉得你思路清晰、有章法。代码反而是最后一步的事。