【LeetCode闲暇一题】41. 缺失的第一个正数【困难】

题目：

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

示例 1:
输入: [1,2,0]
输出: 3
示例 2:
输入: [3,4,-1,1]
输出: 2
示例 3:
输入: [7,8,9,11,12]
输出: 1

提示：
你的算法的时间复杂度应为O(n)，并且只能使用常数级别的额外空间。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/first-missing-positive
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

我的思路：

根据题目可以知道，我需要一个长度与原数组长度一致的数组,然后遍历原数组的值，并在新数组里面进行标记哪些是已存在的。最后从1开始遍历，找到首个不存在的即可。但是后面忽然想到既然已经有现有的数组了，那我为什么不用现有的数组然后用替换法呢？
对于已有的数组，我们可知这个缺失的第一个整数的取值范围一定在[1,length+1].因此我们可以利用已有的数组将每一个在[1,length-1]范围内的值替换到对应下标所在,以达到nums[i] == i来标记那些整数已存在,而不再范围的内的则无需关注，因为无论是其一直在原位置还是后来被覆盖丢失，都不会影响最终的结果(其值为length且恰好在nums[0],只需最后与nums[0]比较,如果其不在nums[0]在数值都存在的情况下其必然会被替换到nums[0], 数值不是都存在或其大于length,则共length个数,有一个还不在范围内,则在[1,length-1]范围内必然有数是不在数组中的)。替换完毕后从1开始遍历，遍历到nums[i] != i的位置，即可得到第一位丢失的正整数，返回即可。如果遍历到最后也没有发现nums[i] != i的位置 ,则说明在[1,length-1]范围内数值均存在数组内。此时我们需要判断length是否为0,如果是空数组直接返回1,否则再判断nums[0]是否与length相等,如果不等那缺失的就是length,如果相等那么缺失就是length+1.最后与length比较是为了避免数据nums的第一个元素刚好是length,而[1,length-1]均含在后续数组种的情况,如[3,1,2],此时3依然会在nums[0]中不被替换掉。

我的代码：

public int firstMissingPositive(int[] nums) {
        int index = 0;
        for (index = 0; index < nums.length;) {
            int num = nums[index];
            // [1,length-1]的有效范围替换
            // 以及避免出现自己和自己替换,两个值重复时的无效替换的num != nums[num]判断
            if(num > 0 && num < nums.length && num != nums[num]){
                int temp = nums[num];
                nums[num] = num;
                nums[index] = temp;
            } else {
                // 只要这个下标对应的值不符合条件时才开始进入下一个下标的替换
                index++;
            }
        }
        for (index = 1; index < nums.length; index++) {
            if (index != nums[index]) {
                // 发现缺失时直接返回缺失的值
                return index;
            }
        }
        // 如果数组为空就直接返回1,这里不放到最前面是因为长度为0是特殊情形,有值的会是大多数情形,所以不让大多数情形做这种无谓的判断，如果长度为0的情况占多数,则放到前面较好
        if (nums.length == 0) {
                return 1;
        }
        // 在[1,length-1]又没有缺失的正整数时如果num[0]里面的值与length相等,那么index需要再+1。数值是填充式都存在那么length也必然会被替换到nums[0]
        if (nums[0] == index) {
            index ++;
        }
        return index;
    }

运行结果：

官方题解：

前言
如果本题没有额外的时空复杂度要求，那么就很容易实现：
1.我们可以将数组所有的数放入哈希表，随后从 $1$ 开始依次枚举正整数，并判断其是否在哈希表中；
2.我们可以从 $1$ 开始依次枚举正整数，并遍历数组，判断其是否在数组中。
如果数组的长度为N，那么第一种做法的时间复杂度为$O(N)$，空间复杂度为 $O(N)$；
第二种做法的时间复杂度为$O(N^2)$，空间复杂度为 $O(1)$。但它们都不满足题目的要求：时间复杂度为 $O(N)$，空间复杂度为$O(1)$。

「真正」满足此要求的算法是不存在的。但是我们可以退而求其次：利用给定数组中的空间来存储一些状态。也就是说，如果题目给定的数组是不可修改的，那么就不存在满足时空复杂度要求的算法；但如果我们可以修改给定的数组，那么是存在满足要求的算法的。
方法一：哈希表 对于「前言」中提到的第一种做法：
我们可以将数组所有的数放入哈希表，随后从 $1$ 开始依次枚举正整数，并判断其是否在哈希表中。
仔细想一想，我们为什么要使用哈希表？这是因为哈希表是一个可以支持快速查找的数据结构：给定一个元素，我们可以在 $O(1)$的时间查找该元素是否在哈希表中。因此，我们可以考虑将给定的数组设计成哈希表的「替代产品」。
实际上，对于一个长度为 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）。这样一来，数组中的所有数就都是正数了，因此我们就可以将「标记」表示为「负号」。算法的流程如下：
1.我们将数组中所有小于等于 0 的数修改为 N+1；
2.我们遍历数组中的每一个数 x，它可能已经被打了标记，因此原本对应的数为 |x|，其中 $\mid \mid$ 为绝对值符号。如果 $|x|\in [1,N]$，那么我们给数组中的第 $|x|-1$个位置的数添加一个负号。注意如果它已经有负号，不需要重复添加；
3.在遍历完成之后，如果数组中的每一个数都是负数，那么答案是 $N+1$，否则答案是第一个正数的位置加 1。
复杂度分析
时间复杂度：$O(N)$，其中 $N$ 是数组的长度。
空间复杂度：$O(1)$。

方法二：置换 除了打标记以外，我们还可以使用置换的方法，将给定的数组「恢复」成下面的形式：
如果数组中包含 $x\in [1,N]$，那么恢复后，数组的第 $x-1$ 个元素为 $x$。
在恢复后，数组应当有 [1, 2, …, N]的形式，但其中有若干个位置上的数是错误的，每一个错误的位置就代表了一个缺失的正数。以题目中的示例二 [3, 4, -1, 1]
为例，恢复后的数组应当为 [1, -1, 3, 4]，我们就可以知道缺失的数为 2。
那么我们如何将数组进行恢复呢？我们可以对数组进行一次遍历，对于遍历到的数 $x=nums[i]$，如果$x\in [1,N]$，我们就知道 $x$ 应当出现在数组中的 $x-1$的位置，因此交换$nums[i]$ 和 $nums[x-1]$，这样 $x$就出现在了正确的位置。在完成交换后，新的 $nums[i]$ 可能还在 $[1,N]$的范围内，我们需要继续进行交换操作，直到 $x\notin [1,N]$。
注意到上面的方法可能会陷入死循环。$nums[i]$ 恰好与 $nums[x-1]$ 相等，那么就会无限交换下去。此时我们有 $nums[i]=x=nums[x-1]$，说明 $x$ 已经出现在了正确的位置。因此我们可以跳出循环，开始遍历下一个数。
由于每次的交换操作都会使得某一个数交换到正确的位置，因此交换的次数最多为 $N$，整个方法的时间复杂度为 $O(N)$。
复杂度分析
时间复杂度：O(N)O(N)，其中 NN 是数组的长度。
空间复杂度：O(1)O(1)。

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/first-missing-positive/solution/que-shi-de-di-yi-ge-zheng-shu-by-leetcode-solution/ 来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

官方题解下的其它联想：

可以看到在官方题解中,可以看到使用下标为i-1的位置存在i,最后再将得到的i进行+1即可,诚然这样在数组遍历完未找到对应数值时可以不再判断nums.length为0时直接返回1以适配数组为空的场景,也无需nums.length不为0时再拿nums[0]与length进行比较以适配[3,1,2]这种场景。但是这样每次替换都会进行额外的数次-1操作,对于一个使用场景未知的方法,或者是作为一个封装的对外提供的方法，我认为应该做到的是在保证逻辑性与可读性的前提下尽可能的节省开销。如果用-1操作,那么数组较大时就会进行很多次的-1操作,相对于这种开销,较坏情况下才会出现判断nums.length为0直接返回1与判断nums[0]是否与length相等在开销上面则会小很多。
而方法一的Hash表法，在我看来和置换法的实质是一样的，只是其判断存在的依据由index！=nums[index]改为nums[index]大于0。

官方思路下的个人解题：

public static int firstMissingPositive2(int[] nums) {
        int index = 0;
        int length = nums.length;
        for (index = 0; index < length;index++) {
            int num = nums[index];
            // 将小于等于0的数全部赋值为length+1,以使得nums的值均为正数。去除干扰
            if(num <= 0){
                nums[index] = length+1;
            }
        }
        for (index = 0; index < length; index++) {
            // 取绝对值的原因是可能前面的一个数指向了当前下标，把当前下标对应的数改成了负数
            int num = Math.abs(nums[index]);
            if (num <= length) {
                // 如果num在范围内,那么就把对应下标的值改为负数,标明这个数存在
                nums[num-1] = -Math.abs(nums[num-1]);
            }
        }
        for (index = 0; index < length; index++) {
            if (nums[index] > 0) {
                break;
            }
        }
        return ++index;
    }

运行结果：

hash法使用index-1标识index是因为hash法不存在替换，需要使用[0,length-1]标识length个数。在1-length数值都存在的情况下不能保证最后length一定会在nums[0]，而置换法则能保证1-length数值都存在置换到最后数值length一定在nums[0].

官方代码：

// 哈希表法
class Solution {
    public int firstMissingPositive(int[] nums) {
        int n = nums.length;
        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;
    }
}
// 置换法
class Solution {
    public int firstMissingPositive(int[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; ++i) {
            while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) {
                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;
            }
        }
        return n + 1;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/first-missing-positive/solution/que-shi-de-di-yi-ge-zheng-shu-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。