Java详解LeetCode 热题 100(17):LeetCode 41. 缺失的第一个正数（First Missing Positive）详解

文章目录

- [1. 题目描述](#1. 题目描述)
- [2. 理解题目](#2. 理解题目)
- [3. 解法一：排序法（不满足题目要求）](#3. 解法一：排序法（不满足题目要求）)
- - [3.1 思路](#3.1 思路)
  - [3.2 Java代码实现](#3.2 Java代码实现)
  - [3.3 代码详解](#3.3 代码详解)
  - [3.4 复杂度分析](#3.4 复杂度分析)
  - [3.5 不足之处](#3.5 不足之处)
- [4. 解法二：哈希表法](#4. 解法二：哈希表法)
- - [4.1 思路](#4.1 思路)
  - [4.2 Java代码实现](#4.2 Java代码实现)
  - [4.3 代码详解](#4.3 代码详解)
  - [4.4 复杂度分析](#4.4 复杂度分析)
  - [4.5 不足之处](#4.5 不足之处)
- [5. 解法三：原地哈希法（最优解）](#5. 解法三：原地哈希法（最优解）)
- - [5.1 思路](#5.1 思路)
  - [5.2 Java代码实现](#5.2 Java代码实现)
  - [5.3 代码详解](#5.3 代码详解)
  - [5.4 复杂度分析](#5.4 复杂度分析)
  - [5.5 适用场景](#5.5 适用场景)
- [6. 详细步骤分析与示例跟踪](#6. 详细步骤分析与示例跟踪)
- - [6.1 示例跟踪：原地哈希法](#6.1 示例跟踪：原地哈希法)
  - [6.2 复杂示例跟踪](#6.2 复杂示例跟踪)
- [7. 常见错误与优化](#7. 常见错误与优化)
- - [7.1 常见错误](#7.1 常见错误)
  - [7.2 优化技巧](#7.2 优化技巧)
- [8. 解法对比](#8. 解法对比)
- [9. 扩展题目与应用](#9. 扩展题目与应用)
- - [9.1 相关题目](#9.1 相关题目)
  - [9.2 实际应用](#9.2 实际应用)
- [10. 实际应用场景](#10. 实际应用场景)
- - [10.1 数据库ID管理](#10.1 数据库ID管理)
  - [10.2 网络协议中的丢包检测](#10.2 网络协议中的丢包检测)
  - [10.3 内存分配器](#10.3 内存分配器)
- [11. 完整的 Java 解决方案](#11. 完整的 Java 解决方案)
- [12. 总结与技巧](#12. 总结与技巧)
- - [12.1 解题要点](#12.1 解题要点)
  - [12.2 学习收获](#12.2 学习收获)
  - [12.3 面试技巧](#12.3 面试技巧)
- [13. 参考资料](#13. 参考资料)

1. 题目描述

给你一个未排序的整数数组 nums，请你找出其中没有出现的最小的正整数。

请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。

示例 1:

复制代码

输入：nums = [1,2,0]
输出：3
解释：数组中包含了 1 和 2，所以缺失的最小正整数是 3

示例 2:

复制代码

输入：nums = [3,4,-1,1]
输出：2
解释：数组中包含了 3、4 和 1，所以缺失的最小正整数是 2

示例 3:

复制代码

输入：nums = [7,8,9,11,12]
输出：1
解释：数组中不包含任何正数 1~5，所以缺失的最小正整数是 1

提示：

1 <= nums.length <= 5 * 10^5
-2^31 <= nums[i] <= 2^31 - 1

2. 理解题目

这道题要求我们找出数组中缺失的第一个正整数。具体来说：

我们要找的是最小的 未出现在数组中的正整数
正整数意味着我们只考虑大于0的整数（即1, 2, 3, ...）
如果数组中包含了1到n的所有正整数，那么答案就是n+1

关键点：

数组可能包含负数、0或重复元素，这些都不是我们要找的答案
数组可能不包含任何正整数，此时答案是1
时间复杂度要求O(n)，空间复杂度要求O(1)，这意味着我们不能使用额外的数据结构如哈希表（除非能够证明它只使用常数空间）

这个问题的难点在于时空复杂度的限制，让我们不能使用排序（O(nlogn)）或额外的数组/哈希表来跟踪数字的出现情况。

3. 解法一：排序法（不满足题目要求）

3.1 思路

虽然这种解法不满足题目的时间复杂度要求，但它是最直观的方法，适合初学者理解问题：

对数组进行排序
遍历排序后的数组，找到第一个不连续的正整数

3.2 Java代码实现

java 复制代码

class Solution {
    public int firstMissingPositive(int[] nums) {
        // 对数组进行排序
        Arrays.sort(nums);
        
        // 记录期望的下一个正整数，初始为1
        int expectedNum = 1;
        
        // 遍历排序后的数组
        for (int num : nums) {
            // 如果当前数字等于期望的数字，更新期望值
            if (num == expectedNum) {
                expectedNum++;
            } 
            // 如果当前数字大于期望的数字，说明找到了缺失的正整数
            else if (num > expectedNum) {
                return expectedNum;
            }
            // 忽略小于等于0或重复的数字
        }
        
        // 如果数组中的所有正整数都是连续的，返回最后一个正整数+1
        return expectedNum;
    }
}

3.3 代码详解

java 复制代码

// 对数组进行排序
Arrays.sort(nums);

使用Java内置的排序函数对数组进行排序，这样相同的数字会挨在一起，正数会按从小到大排列

java 复制代码

// 记录期望的下一个正整数，初始为1
int expectedNum = 1;

我们从1开始检查，因为1是最小的正整数

java 复制代码

// 遍历排序后的数组
for (int num : nums) {
    // 如果当前数字等于期望的数字，更新期望值
    if (num == expectedNum) {
        expectedNum++;
    } 
    // 如果当前数字大于期望的数字，说明找到了缺失的正整数
    else if (num > expectedNum) {
        return expectedNum;
    }
    // 忽略小于等于0或重复的数字
}

遍历排序后的数组，跟踪下一个预期出现的正整数
如果当前数字等于预期数字，说明这个数字存在，我们增加预期值
如果当前数字大于预期数字，说明预期数字不在数组中，我们找到了答案
如果当前数字小于预期数字（包括负数、0或重复值），我们直接忽略它

java 复制代码

// 如果数组中的所有正整数都是连续的，返回最后一个正整数+1
return expectedNum;

如果我们遍历完整个数组都没有返回，说明数组中包含了从1到某个数的所有正整数，缺失的第一个正整数就是这个数加1

3.4 复杂度分析

时间复杂度：O(n log n)，主要由排序操作决定。
空间复杂度：O(1) 或 O(log n)，取决于排序算法的实现（一些排序算法可能需要O(log n)的栈空间）。

3.5 不足之处

虽然这种方法很直观，但它的时间复杂度是O(n log n)，不满足题目要求的O(n)。此外，某些排序算法可能需要额外的空间。因此，我们需要探索更高效的解法。

4. 解法二：哈希表法

4.1 思路

利用哈希表记录数组中存在的正整数，然后从1开始检查，找到第一个不在哈希表中的正整数：

创建一个哈希表（HashSet）
将数组中所有大于0的整数加入哈希表
从1开始遍历正整数，找到第一个不在哈希表中的数

4.2 Java代码实现

java 复制代码

class Solution {
    public int firstMissingPositive(int[] nums) {
        // 创建哈希表存储数组中的正整数
        Set<Integer> positiveNums = new HashSet<>();
        
        // 将所有正整数加入哈希表
        for (int num : nums) {
            if (num > 0) {
                positiveNums.add(num);
            }
        }
        
        // 从1开始检查每个正整数是否存在
        int missingPositive = 1;
        while (positiveNums.contains(missingPositive)) {
            missingPositive++;
        }
        
        return missingPositive;
    }
}

4.3 代码详解

java 复制代码

// 创建哈希表存储数组中的正整数
Set<Integer> positiveNums = new HashSet<>();

使用HashSet作为哈希表，它能够以O(1)的时间复杂度检查一个数字是否存在

java 复制代码

// 将所有正整数加入哈希表
for (int num : nums) {
    if (num > 0) {
        positiveNums.add(num);
    }
}

遍历数组，只将正整数（大于0的数）添加到哈希表中
负数和0不是我们要找的答案，可以直接忽略

java 复制代码

// 从1开始检查每个正整数是否存在
int missingPositive = 1;
while (positiveNums.contains(missingPositive)) {
    missingPositive++;
}

从最小的正整数1开始，检查哈希表中是否包含该数字
如果包含，则增加计数器，继续检查下一个正整数
一旦找到一个不在哈希表中的正整数，就找到了答案

4.4 复杂度分析

时间复杂度：O(n)，我们需要遍历数组一次将元素加入哈希表，然后在最坏情况下检查从1到n的每个正整数。
空间复杂度：O(n)，我们需要一个哈希表来存储数组中的正整数，最坏情况下存储n个不同的正整数。

4.5 不足之处

这种方法的时间复杂度满足题目要求，但空间复杂度是O(n)，不满足O(1)的要求。因此，我们需要继续寻找更优的解法。

5. 解法三：原地哈希法（最优解）

5.1 思路

这种方法的核心思想是利用数组本身作为哈希表，通过将每个数值放置到对应的位置上，然后再遍历一次数组找出第一个不符合要求的位置。具体步骤如下：

遍历数组，将每个在范围[1, n]内的正整数放到对应的位置上（nums[i-1] = i）
再次遍历数组，找到第一个不满足nums[i-1] = i的位置，该位置对应的正整数i就是缺失的第一个正整数

关键思想：对于长度为n的数组，如果数组包含了1到n的所有正整数，那么缺失的第一个正整数就是n+1。因此，我们只需要关心范围在[1, n]内的正整数。

5.2 Java代码实现

java 复制代码

class Solution {
    public int firstMissingPositive(int[] nums) {
        int n = nums.length;
        
        // 第一次遍历，将每个数放到对应的位置上
        for (int i = 0; i < n; i++) {
            // 当前值在[1,n]范围内，且还未放到正确位置上
            while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) {
                // 交换nums[i]和nums[nums[i]-1]
                int temp = nums[nums[i] - 1];
                nums[nums[i] - 1] = nums[i];
                nums[i] = temp;
            }
        }
        
        // 第二次遍历，找到第一个不符合要求的位置
        for (int i = 0; i < n; i++) {
            if (nums[i] != i + 1) {
                return i + 1;
            }
        }
        
        // 如果数组中包含了1到n的所有正整数，则返回n+1
        return n + 1;
    }
}

5.3 代码详解

java 复制代码

int n = nums.length;

获取数组长度，这是我们寻找缺失正整数的范围上限

java 复制代码

// 第一次遍历，将每个数放到对应的位置上
for (int i = 0; i < n; i++) {
    // 当前值在[1,n]范围内，且还未放到正确位置上
    while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) {
        // 交换nums[i]和nums[nums[i]-1]
        int temp = nums[nums[i] - 1];
        nums[nums[i] - 1] = nums[i];
        nums[i] = temp;
    }
}

遍历数组，尝试将每个数放到其对应的位置上：
- 对于值为k的元素，其正确位置应该是索引k-1处（因为数组索引从0开始）
- 条件nums[i] > 0 && nums[i] <= n确保我们只处理范围在[1,n]内的正整数
- 条件nums[nums[i] - 1] != nums[i]确保当前数字还未放置到正确位置，避免无限循环
- 使用while循环而不是if是因为交换后的新值也可能需要放置到正确位置

java 复制代码

// 第二次遍历，找到第一个不符合要求的位置
for (int i = 0; i < n; i++) {
    if (nums[i] != i + 1) {
        return i + 1;
    }
}

再次遍历数组，检查每个位置上的数字是否正确：
- 索引i处应该是数字i+1
- 如果发现某个位置上的数字不是预期值，说明该预期值在数组中缺失，返回这个值

java 复制代码

// 如果数组中包含了1到n的所有正整数，则返回n+1
return n + 1;

如果遍历完整个数组都没有返回，说明数组中包含了1到n的所有正整数，缺失的第一个正整数就是n+1

5.4 复杂度分析

时间复杂度：O(n)
- 第一次遍历中，虽然有一个嵌套的while循环，但每个元素最多只会被交换一次到它的正确位置，所以总的交换操作不会超过n次
- 第二次遍历是一个简单的O(n)操作
- 因此，总的时间复杂度是O(n)
空间复杂度：O(1)
- 我们只使用了有限的变量，没有额外的数据结构，满足题目的空间要求

5.5 适用场景

这种解法是该问题在O(n)时间和O(1)空间约束下的最优解，适用于所有包含此类约束的缺失正整数问题。

6. 详细步骤分析与示例跟踪

让我们通过一个具体例子来跟踪原地哈希算法的执行过程，以加深理解。

6.1 示例跟踪：原地哈希法

输入：nums = [3,4,-1,1]

初始状态：

数组：[3,4,-1,1]
长度 n = 4

第一次遍历（原地哈希过程）：

i = 0, nums[0] = 3
- 3应该在索引2的位置（3-1=2）
- 交换nums[0]和nums[2]: [3,4,-1,1] → [-1,4,3,1]
- 现在nums[0] = -1，不在[1,n]范围内，不需要再交换
i = 1, nums[1] = 4
- 4应该在索引3的位置（4-1=3）
- 交换nums[1]和nums[3]: [-1,4,3,1] → [-1,1,3,4]
- 现在nums[1] = 1，它应该在索引0的位置
- 交换nums[1]和nums[0]: [-1,1,3,4] → [1,-1,3,4]
- 现在nums[1] = -1，不在[1,n]范围内，不需要再交换
i = 2, nums[2] = 3
- 3已经在正确的位置上（索引2），不需要交换
i = 3, nums[3] = 4
- 4已经在正确的位置上（索引3），不需要交换

经过第一次遍历后，数组变为：[1,-1,3,4]

第二次遍历（查找缺失的正整数）：

i = 0, nums[0] = 1
- 1应该在索引0的位置（1-1=0）✓
- 符合预期，继续检查下一个位置
i = 1, nums[1] = -1
- 索引1处应该是数字2（1+1=2）✗
- nums[1] ≠ 2，找到了缺失的第一个正整数：2

因此，返回结果：2

6.2 复杂示例跟踪

输入：nums = [7,8,9,11,12]

初始状态：

数组：[7,8,9,11,12]
长度 n = 5

第一次遍历（原地哈希过程）：

i = 0, nums[0] = 7
- 7超出了数组长度5，不在[1,5]范围内，不需要交换
i = 1, nums[1] = 8
- 8超出了数组长度5，不在[1,5]范围内，不需要交换
i = 2, nums[2] = 9
- 9超出了数组长度5，不在[1,5]范围内，不需要交换
i = 3, nums[3] = 11
- 11超出了数组长度5，不在[1,5]范围内，不需要交换
i = 4, nums[4] = 12
- 12超出了数组长度5，不在[1,5]范围内，不需要交换

经过第一次遍历后，数组保持不变：[7,8,9,11,12]

第二次遍历（查找缺失的正整数）：

i = 0, nums[0] = 7
- 索引0处应该是数字1（0+1=1）✗
- nums[0] ≠ 1，找到了缺失的第一个正整数：1

因此，返回结果：1

7. 常见错误与优化

7.1 常见错误

未处理负数和零：

java 复制代码

// 错误：忽略了负数和零的处理
while (nums[i] != i + 1) {
    // 交换逻辑
}

// 正确：只处理范围在[1,n]内的正整数
while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) {
    // 交换逻辑
}

未考虑重复元素：

java 复制代码

// 错误：没有检查目标位置是否已经有正确的值
while (nums[i] > 0 && nums[i] <= n) {
    // 交换逻辑，可能导致无限循环
}

// 正确：避免无限循环
while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) {
    // 交换逻辑
}

交换逻辑错误：

java 复制代码

// 错误：交换顺序不正确
nums[i] = nums[nums[i] - 1];
nums[nums[i] - 1] = nums[i]; // 这里的nums[i]已经被更改

// 正确：使用临时变量进行交换
int temp = nums[nums[i] - 1];
nums[nums[i] - 1] = nums[i];
nums[i] = temp;

循环条件错误：

java 复制代码

// 错误：使用if而不是while
for (int i = 0; i < n; i++) {
    if (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) {
        // 交换逻辑，但只交换一次
    }
}

// 正确：使用while循环确保所有元素都被放到正确位置
for (int i = 0; i < n; i++) {
    while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) {
        // 交换逻辑
    }
}

7.2 优化技巧

提前检查特殊情况：

java 复制代码

// 优化：快速检查1是否存在
boolean containsOne = false;
for (int num : nums) {
    if (num == 1) {
        containsOne = true;
        break;
    }
}

if (!containsOne) {
    return 1; // 如果不包含1，直接返回
}

预处理数组：

java 复制代码

// 优化：将所有无效值（负数、零和大于n的数）替换为统一的值
for (int i = 0; i < n; i++) {
    if (nums[i] <= 0 || nums[i] > n) {
        nums[i] = n + 1; // 使用n+1作为标记值
    }
}

使用标记法代替交换 ：

另一种原地哈希的变种，通过修改数组元素的符号来标记存在的数字，避免了频繁的交换操作。

java 复制代码

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 num = Math.abs(nums[i]);
            if (num <= n) {
                nums[num - 1] = -Math.abs(nums[num - 1]);
            }
        }
        
        // 找到第一个正数的位置
        for (int i = 0; i < n; i++) {
            if (nums[i] > 0) {
                return i + 1;
            }
        }
        
        return n + 1;
    }
}

8. 解法对比

解法	时间复杂度	空间复杂度	优点	缺点
排序法	O(n log n)	O(1) 或 O(log n)	简单易懂，容易实现	不满足O(n)时间复杂度要求
哈希表法	O(n)	O(n)	思路清晰，容易理解	不满足O(1)空间复杂度要求
原地哈希法（交换）	O(n)	O(1)	满足所有复杂度要求	实现较复杂，边界条件多
原地哈希法（标记）	O(n)	O(1)	满足所有复杂度要求，减少交换操作	修改了原始数据，可能不适合某些场景

最优解：原地哈希法，无论是交换版本还是标记版本，都满足题目的所有时空复杂度要求。选择哪种具体实现取决于对原始数据修改的限制和个人偏好。

9. 扩展题目与应用

9.1 相关题目

LeetCode 268. 丢失的数字（Missing Number）：
- 给定一个包含 [0, n] 范围内不重复整数的数组 nums，找出丢失的那个数字
- 与本题类似，但范围包括0，且保证数组中不重复
LeetCode 448. 找到所有数组中消失的数字（Find All Numbers Disappeared in an Array）：
- 给定一个范围在 [1, n] 内的整数数组，找出数组中所有没有出现的数字
- 与本题类似，但需要找出所有缺失的数字而不仅仅是第一个
LeetCode 287. 寻找重复数（Find the Duplicate Number）：
- 给定一个包含 n + 1 个整数的数组 nums，所有数字都在 [1, n] 范围内，找出唯一重复的数字
- 与本题操作数组的方式类似，但目标不同

9.2 实际应用

数据完整性检查：
- 验证一组连续ID是否有缺失
- 检查系统中是否有未分配的资源ID
网络包序列号检测：
- 检测网络传输中是否有丢失的数据包
- 实现可靠的数据传输协议
分布式系统中的ID分配：
- 在分布式环境中高效地分配唯一ID
- 回收未使用的ID以避免ID耗尽
内存管理：
- 在内存分配器中找出第一个可用的内存块
- 实现高效的内存回收和重用机制

10. 实际应用场景

10.1 数据库ID管理

在数据库系统中，通常需要为记录分配唯一的ID。当某些记录被删除后，可能需要重用这些ID以避免ID过大导致的性能问题。这时可以使用缺失的第一个正整数算法快速找出可重用的最小ID：

java 复制代码

public class DatabaseIdManager {
    private Set<Integer> usedIds = new HashSet<>();
    private int maxId = 0;
    
    public int allocateId() {
        // 找出当前使用的ID中缺失的第一个正整数
        int[] ids = usedIds.stream().mapToInt(Integer::intValue).toArray();
        int missingId = findFirstMissingPositive(ids);
        
        if (missingId <= maxId) {
            // 重用之前的ID
            usedIds.add(missingId);
            return missingId;
        } else {
            // 分配新ID
            maxId++;
            usedIds.add(maxId);
            return maxId;
        }
    }
    
    public void releaseId(int id) {
        usedIds.remove(id);
    }
    
    private int findFirstMissingPositive(int[] nums) {
        // 实现原地哈希算法
        // ...
    }
}

10.2 网络协议中的丢包检测

在网络传输中，数据包通常带有序列号。接收方可以使用缺失的第一个正整数算法来检测是否有丢失的数据包，以便请求重传：

java 复制代码

public class PacketLossDetector {
    public int detectFirstLostPacket(int[] receivedPacketSequences) {
        // 对接收到的序列号排序（如果未排序）
        Arrays.sort(receivedPacketSequences);
        
        // 找出缺失的第一个序列号
        int expectedSeq = 1;
        for (int seq : receivedPacketSequences) {
            if (seq == expectedSeq) {
                expectedSeq++;
            } else if (seq > expectedSeq) {
                return expectedSeq; // 找到缺失的第一个序列号
            }
        }
        
        return expectedSeq; // 下一个期望的序列号
    }
}

10.3 内存分配器

在内存管理中，可以使用缺失的第一个正整数算法快速找出第一个可用的内存块索引：

java 复制代码

public class MemoryAllocator {
    private boolean[] usedBlocks; // 标记内存块是否被使用
    
    public MemoryAllocator(int totalBlocks) {
        usedBlocks = new boolean[totalBlocks];
    }
    
    public int allocate() {
        // 找到第一个未使用的内存块
        for (int i = 0; i < usedBlocks.length; i++) {
            if (!usedBlocks[i]) {
                usedBlocks[i] = true;
                return i + 1; // 返回块ID（从1开始）
            }
        }
        
        throw new OutOfMemoryError("No available memory blocks");
    }
    
    public void free(int blockId) {
        if (blockId > 0 && blockId <= usedBlocks.length) {
            usedBlocks[blockId - 1] = false;
        }
    }
}

11. 完整的 Java 解决方案

以下是结合了最佳实践和优化技巧的完整解决方案：

java 复制代码

class Solution {
    public int firstMissingPositive(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 1;
        }
        
        int n = nums.length;
        
        // 优化1: 快速检查1是否存在
        boolean contains1 = false;
        for (int num : nums) {
            if (num == 1) {
                contains1 = true;
                break;
            }
        }
        
        if (!contains1) {
            return 1;
        }
        
        // 优化2: 将所有无效值替换为1
        // 1已经存在，且我们只关心[1,n]范围内的数，
        // 所以用1替换所有负数、0和大于n的数不会影响结果
        for (int i = 0; i < n; i++) {
            if (nums[i] <= 0 || nums[i] > n) {
                nums[i] = 1;
            }
        }
        
        // 使用原地哈希法（标记版本）
        for (int i = 0; i < n; i++) {
            int val = Math.abs(nums[i]);
            if (val == n) {
                // 特殊处理n，使用索引0来标记
                nums[0] = -Math.abs(nums[0]);
            } else {
                // 使用负号标记值为val的数字存在
                nums[val] = -Math.abs(nums[val]);
            }
        }
        
        // 找到第一个正数的位置
        for (int i = 1; i < n; i++) {
            if (nums[i] > 0) {
                return i;
            }
        }
        
        // 检查n是否存在
        if (nums[0] > 0) {
            return n;
        }
        
        // 如果1到n都存在，返回n+1
        return n + 1;
    }
}

这个解决方案结合了多种优化技巧：

提前检查1是否存在，如果不存在直接返回1
将所有无效值（负数、0和大于n的数）统一替换为1
使用标记法而不是交换法来减少操作
巧妙利用数组索引来标记存在的值

12. 总结与技巧

12.1 解题要点

理解问题约束：这类问题的关键是理解时间和空间复杂度的严格限制。
利用数值范围：对于长度为n的数组，我们只需要关心[1,n+1]范围内的正整数。
原地哈希思想：将数组自身作为哈希表，通过交换或标记来记录数字的存在情况。
处理边界情况：注意处理负数、零、重复值和超出范围的数字。

12.2 学习收获

通过学习本题，你可以掌握：

原地哈希的思想和实现
如何在严格的空间复杂度约束下解决问题
处理数组元素交换和标记的技巧
分析问题并识别关键约束的能力

12.3 面试技巧

如果在面试中遇到此类问题：

先提出简单直观的解法（如排序法或哈希表法）
分析其复杂度，指出不满足题目要求的地方
引入原地哈希的思想，解释如何利用数组本身作为哈希表
讨论实现细节和边界条件
提供不同版本的原地哈希实现（交换法vs标记法）及其优缺点

记住，面试官通常更关注你的思考过程和问题分析能力，而不仅仅是最终的解法。

Java详解LeetCode 热题 100(17):LeetCode 41. 缺失的第一个正数（First Missing Positive）详解

文章目录

1. 题目描述

2. 理解题目

3. 解法一：排序法（不满足题目要求）

3.1 思路

3.2 Java代码实现

3.3 代码详解

3.4 复杂度分析

3.5 不足之处

4. 解法二：哈希表法

4.1 思路

4.2 Java代码实现

4.3 代码详解

4.4 复杂度分析

4.5 不足之处

5. 解法三：原地哈希法（最优解）

5.1 思路

5.2 Java代码实现

5.3 代码详解

5.4 复杂度分析

5.5 适用场景

6. 详细步骤分析与示例跟踪

6.1 示例跟踪：原地哈希法

6.2 复杂示例跟踪

7. 常见错误与优化

7.1 常见错误

7.2 优化技巧

8. 解法对比

9. 扩展题目与应用

9.1 相关题目

9.2 实际应用

10. 实际应用场景

10.1 数据库ID管理

10.2 网络协议中的丢包检测

10.3 内存分配器

11. 完整的 Java 解决方案

12. 总结与技巧

12.1 解题要点

12.2 学习收获

12.3 面试技巧

13. 参考资料