41. 缺失的第一个正数
1.题目介绍
给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。
请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。
示例 1：
输入：nums = [1,2,0]
输出：3
示例 2：
输入：nums = [3,4,-1,1]
输出：2
示例 3：
输入：nums = [7,8,9,11,12]
输出：1
2.题解
2.0 哈希表
思路
注意!这里用哈希表是不行的,题目要求常量级别的空间复杂度!!!这里只是演示一下做法
实际上，对于一个长度为 N 的数组，其中没有出现的最小正整数只能在 [1,N+1] 中。这是因为如果 [1,N] 都出现了，那么答案是 N+1，否则答案是 [1,N] 中没有出现的最小正整数。
这样一来，我们将所有在 [1,N] 范围内的数放入哈希表，也可以得到最终的答案.
代码
class Solution {
public:
int firstMissingPositive(vector<int>& nums) {
int n = nums.size(), ans = 0;
unordered_map<int, int> mp;
for(int i = 0; i < n; i++){
if(mp.count(nums[i])){
mp[nums[i]]++;
}else{
mp.emplace(nums[i], 1);
}
}
for(int i = 1; i <= n + 1; i++){
if(!mp.count(i)){
ans = i;
break;
}
}
return ans;
}
};
2.1 数组+标记法(正负号)
思路
注意,由于这里有正有负,不像之前的数据中是固定在[1,n]当中,所以我们并不好使用标记法(%循环)
负数+n之后,有可能也是存在于[1,n]之间的!!!!
实际上，对于一个长度为 N 的数组，其中没有出现的最小正整数只能在 [1,N+1] 中。这是因为如果 [1,N] 都出现了，那么答案是 N+1，否则答案是 [1,N] 中没有出现的最小正整数。这样一来，我们将所有在 [1,N] 范围内的数放入哈希表，也可以得到最终的答案。而给定的数组恰好长度为 N，这让我们有了一种将数组设计成哈希表的思路：
我们对数组进行遍历，对于遍历到的数 x，如果它在 [1,N] 的范围内，那么就将数组中的第 x−1 个位置（注意：数组下标从 0 开始）打上「标记」。在遍历结束之后，如果所有的位置都被打上了标记，那么答案是 N+1，否则答案是最小的没有打上标记的位置加 1。
那么如何设计这个「标记」呢？由于数组中的数没有任何限制，因此这并不是一件容易的事情。但我们可以继续利用上面的提到的性质：由于我们只在意 [1,N] 中的数，因此我们可以先对数组进行遍历，把不在 [1,N] 范围内的数修改成任意一个大于 N 的数（例如 N+1）。这样一来，数组中的所有数就都是正数了，因此我们就可以将「标记」表示为「负号」。算法的流程如下：
我们将数组中所有小于等于 0 的数修改为 N+1；
我们遍历数组中的每一个数 x，它可能已经被打了标记，因此原本对应的数为 ∣x∣。如果 ∣x∣∈[1,N]，那么我们给数组中的第 ∣x∣−1个位置的数添加一个负号。注意如果它已经有负号，不需要重复添加；
在遍历完成之后，如果数组中的每一个数都是负数，那么答案是 N+1，否则答案是第一个正数的位置加 1。
代码
1.这里为何要标记 nums[num - 1] 为负号，而不是直接标记 nums[i] 为负号呢？
这里有一个最终寻找的问题，如果我们直接标记 nums[i]，那么最后我是按索引顺序遍历数组的，标记散落在各处，有可能是遇到的第一个非标记处是最小的，也可能是最后一个或者其中的任意一个非标记处。 比如像 3, -1, 2, 4 => -3, 5(4+1), -2, -4, 根本找不到究竟哪一个是缺失的第一个正数.
而nums[num - 1] 实际上是直接上将要标记的数化为有序的索引进行标记，这样我按索引顺序遍历到的第一个标记，就是最小的num - 1
而按照这种标记方式, 3, -1, 2, 4 => 3, -5(2-1 = 1), -2(3-1 = 2), -4(4-1=3), 找到的第一个非标记处便是索引0的位置，返回0+1 = 1即可
像是1,-1,2,3 => -1(1-1=0), -5(2-1=1), -2(3-1=2), 3, 第一个非标记处索引为3，即返回3+1 = 4即可
这里标记和索引的单调性共同完成了任务。
2.为何使用的是num-1 而不是num? 因为[1,N]这几个数对应数组索引的[0,N-1]
3.这里为何不直接在一个循环内处理[-∞，0],[N+1,+∞] 和 [1,N] 中的内容？
就像： for(int i = 0; i < N; i++){
if(nums[i] > N || nums[i] <= 0) nums[i] = N+1;
else{nums[nums[i] - 1] = -abs(nums[nums[i] - 1]);}
}
首先这样的话判断条件中nums[i]<=0就可能不是这个数本来是负数，而是被标记后成为了负数，后续我遍历到这个数的时候，就会错误地被化为N+1
其次由于这里nums[i]的值可能为负数，所以我们在第二个循环中使用abs取绝对值进行比较
4.寻找第一个非标记处，其索引+1即所求位置。
class Solution {
public:
int firstMissingPositive(vector<int>& nums) {
int N = nums.size();
for(int i = 0; i < N; i++){ // for(int &num: nums) 这种形式加个&也可以改变数组中的值
if(nums[i] > N || nums[i] <= 0) nums[i] = N+1;
}
for(int i = 0; i < N; i++){
int num = abs(nums[i]);
if(num <= N)
nums[num - 1] = -abs(nums[num - 1]);
}
for(int i = 0; i < N; i++)
if(nums[i] > 0) return i + 1;
return N + 1;
}
};
2.2 置换
思路
除了打标记以外，我们还可以使用置换的方法，将给定的数组「恢复」成下面的形式：
如果数组中包含 x∈[1,N]，那么恢复后，数组的第 x−1个元素为 x。
在恢复后，数组应当有 [1, 2, ..., N] 的形式，但其中有若干个位置上的数是错误的，每一个错误的位置就代表了一个缺失的正数。以题目中的示例二 [3, 4, -1, 1] 为例，恢复后的数组应当为 [1, -1, 3, 4]，我们就可以知道缺失的数为 2。
那么我们如何将数组进行恢复呢？我们可以对数组进行一次遍历，对于遍历到的数 x=nums[i]，如果 x∈[1,N]，我们就知道 x 应当出现在数组中的 x−1 的位置，因此交换 nums[i] 和 nums[x−1]，这样 x 就出现在了正确的位置。在完成交换后，新的 nums[i] 可能还在 [1,N] 的范围内，我们需要继续进行交换操作，直到 x∉[1,N]
注意到上面的方法可能会陷入死循环。如果 nums[i] 恰好与 nums[x−1] 相等，那么就会无限交换下去。此时我们有 nums[i] = x = nums[x−1]，说明 x 已经出现在了正确的位置。因此我们可以跳出循环，开始遍历下一个数。
由于每次的交换操作都会使得某一个数交换到正确的位置，因此交换的次数最多为 N，整个方法的时间复杂度为 O(N)。
例:3, 4, -1, 1 => -1,4,3,1 =>-1,1,3,4 =>1,-1,3,4=>1,-1,3,4=>结束
代码
这里的核心是交换而不是覆盖，从而解决了数据丢失的问题，通过不断地复位使数组中的数到达与其索引对应的位置。
其次要注意可能导致的死循环问题，就是当nums[i] == nums[nums[i] - 1] 无限交换的情况。
class Solution {
public:
int firstMissingPositive(vector<int>& nums) {
int n = nums.size();
for(int i = 0; i < n; i++){
while(nums[i] <= n && nums[i] >=1 && nums[nums[i] - 1] != nums[i]) {
swap(nums[i], nums[nums[i] - 1]);
}
}
for(int i = 0; i < n; i++){
if(nums[i] != i+1) return i+1;
}
return n+1;
}
};
