一、数组_统计数组中的元素_41. 缺失的第一个正数

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

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

示例 1：

输入：nums = [1,2,0]
输出：3
示例 2：

输入：nums = [3,4,-1,1]
输出：2
示例 3：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/first-missing-positive

hashmap表法：
1.这里首先想到的一种做法是，建立一个hashmap表，然后，在hashmap表中添加对应的元素，这种过程遍历nums中实现
2.下次在1-n【nums中的最大值】的，遍历hashmap表，找到第一个未出现的元素
3. 这里时间复杂度是O(n)，空间复杂度也是O(n)

int firstMissingPositive(vector<int>& nums) {
    unordered_map<int, int> map;  //map表
    int n = nums.size();
    int m = 1;

    //将所有的数都加入到map中
    for(int i = 0; i < n; i++) {
        int num = nums[i];
        map[num]++;
    }

    //从1开始，每次增加1，肯定会有一个数，找不到，那么就是解
    while(true) {
        if(map[m] == 0) { //解，退出
            break;
        }

        m++;
    }

    return m; //如果前面都出现的话
}

这里参考官方题解的一句话，若是“真正”满足时间复杂度O(N)，O(1)的算法是不存在的，但是，退而求其次，若nums数组可以修改
那么便可以实现，若nums数组不可以修改，那么永远不会满足空间复杂度
hashmap映射表优化法：降低空间复杂度
1.这里nums.size()的长度是n，那么未出现的元素一定是在[1,n]中，这里包含1和n，或者前n个元素全部出现了，那么就是n+1
2.那么nums中的[1，n]的元素与我们无关，我们需要将其置位n+1
3.再次nums，[1,n]范围内的数字，nums[x-1]置位负数，访问按照abs(x)
4.再次访问，若是非负即答案，或者为n+1
2 4 -1 3
2 4 5 3 //将不再[1-n]内的变为n+1
2 -4 -5 -3 //置位负
答案是1，对应的位置非负

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

    //这里，首先将不再范围内的元素x，置换为n+1
    for(int i = 0; i < n; i++) {
        int num = nums[i];

        if(num < 1 || num > n) {
            nums[i] = n + 1;
        }
    }

    //取对应的元素x，若在[1,n]范围内，且nums[x-1]大于0，有可能会出现重复的元素，那么置位负值
    for(int i = 0; i < n; i++) {
        int x = abs(nums[i]);

        if(x >= 1 && x <= n && nums[x - 1] > 0) {
            nums[x - 1] = -nums[x - 1];
        }
    }

    int m = -1;

    //这里负数标记时存在的意思，否则是不存在的意思
    for(int i = 0; i < n; i++) {
        int x = nums[i];

        if(x > 0) {
            m = i + 1;
            break;
        }
    }

    //若没找到，则返回n+1
    return m != -1 ? m : n + 1;
}

int main() {
    vector<int> nums = { 1, 1};
    int ret = firstMissingPositive(nums);
    cout << ret << endl;
    return 0;
}

置换优化方法：
1.这里与之前不同的是，首先遍历nums的每个元素，若是x在[1,n]的范围内的话，将置换nums[i]与nums[x-1]对应的值
2.直到不能在x不在范围内停止，继续遍历nums的每个元素，若是nums[i]==nums[x-1]则位置正好，不用循环
3.检查的时候通过(i+1)!=nums[i]，就返回