[LeetCode]41.缺失的第一个正数

题目描述

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

示例 1:

输入: [1,2,0]
输出: 3

示例 2:

输入: [3,4,-1,1]
输出: 2

示例 3:

输入: [7,8,9,11,12]
输出: 1

说明:

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

分析：
常数级别的空间，也就是说只能用数组原有的空间加上O(1)的空间复杂度。

在LeetCode中主要有两类方法

1. 哈希方法

可以思考，如果对空间没有要求，我们就能够再申请一个数组统计每个数字出现的个数（或者是否出现）。那么在O(n)时间内就能够解决问题。在空间不做要求的情况下也可以建立一个哈希表，这样可以起到相同的作用。

1. 那么在限制空间的情况下，我们只能在原有数组实现类似哈希的功能。
2. 也就是说在原有数组中想办法统计每个数字是否出现，最简单的方法就是用正负号。
3. 可是数组中也可能有0或者负数。我们需要将0或者负数用正数表示。这时我们发现缺失的正数只能是1~n+1
4. 我们可以只统计1~n是否出现，就可以确定结果了。
5. 为了不影响1~n的统计，我们将0或者负数全都变为n+1
6. 然后遍历数组，当出现i，就将i-1索引的数字置为负。
7. 遍历数组，如果i索引下的数是正数，那缺失的就是i+1，如果都不缺，那么缺失的就是n+1

class Solution {
    public int firstMissingPositive(int[] nums) {
        int n=nums.length;
        for (int i = 0; i < n; i++) {
            // 如果出现小于等于0的情况，那么缺少的正数一定在0~n中
            if(nums[i]<=0){
                nums[i]=n+1;
            }
        }
        // 将已经出现的数字的哈希置为负
        for (int i = 0; i < n; i++) {
            if (Math.abs(nums[i])>n) {
                continue;
            }
            int index=Math.abs(nums[i])-1;
            if (nums[index]>0) {
                nums[index]=-nums[index];
            }
        }
        for (int i = 0; i < n; i++) {
            if (nums[i]>0) {
                return i+1;
            }            
        }
        return n+1;
    }
}

除了可以将0或者负数以n+1取代，还可以将不在1~n范围的数字用1取代，不过需要提前确定数组里面原来就没有1。（也可以用其他方式取代）

class Solution {
    public int firstMissingPositive(int[] nums) {
        int n=nums.length;
        boolean haveOne=false;
        // 找有没有1
        for (int var : nums) {
            haveOne |= (var == 1);
        }
        if(!haveOne) return 1;
        // 将不在1~n范围的数字置为1
        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 index=Math.abs(nums[i])-1;
            if(nums[index]>0){
                nums[index]=-nums[index];
            }
        }
        // 寻找正数
        for (int i = 0; i < n; i++) {
            if (nums[i]>0) {
                return i+1;
            }
        }
        return n+1;
    }
}

2. 桶排序方法

1. 题目要求的时间复杂度是O(n)，我们可以想起桶排序的时间复杂度也是O(n)。
2. 我们想办法将数字i放到索引i下，只要从小到大遍历一遍，索引与所放数字不相同的就是缺失的了。
3. 想要达到2的效果，我们使用交换的方法。每次交换都会有一个被放置到正确的位置，所以时间复杂度是O(n)
4. 交换的时候要注意，Java只有对象是传引用的，数组也是对象。

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[i]!=i+1){
                int index=nums[i]-1;
                if(nums[i]==nums[index]) break;
                swap(nums,i,index);
            }
        }
        for (int i = 0; i < n; i++) {
            if(nums[i] != i+1){
                return i+1;
            }
        }
        return n+1;
    }

    private void swap(int[] nums,int a,int b){
        int c;
        c=nums[a];
        nums[a]=nums[b];
        nums[b]=c;
    }
}