力扣题解| 41. 缺失的第一个正数

41. 缺失的第一个正数

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

示例 1:

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

示例 2:

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

示例 3:

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

1，暴力求解

首先最容易想到的就是暴力求解，从1开始一个个查找，没找到就直接返回

    public int firstMissingPositive(int[] nums) {
        for (int i = 1; i <= nums.length; i++) {
            boolean has = false;
            for (int j = 0; j < nums.length; j++) {
                if (nums[j] == i) {
                    has = true;
                    break;
                }
            }
            if (!has) {
                //没有找到这个数，直接返回
                return i;
            }
        }
        return nums.length + 1;
    }

 

2，先排序，再查找

暴力求解运行效率毕竟不高，我们还可以先对数组进行排序，然后再使用二分法再一个个查找。

    public int firstMissingPositive(int[] nums) {
        int len = nums.length;
        Arrays.sort(nums);//先排序
        for (int i = 1; i <= len; i++) {
            int res = binarySearch(nums, i);
            //一个个查找，如果没找到就返回
            if (res == -1)
                return i;
        }
        return len + 1;
    }

    //二分法查找，找到就返回位置下标，没找到就返回-1。
    private int binarySearch(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        while (left <= right) {
            int mid = left + ((right - left) >> 1);
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1;
    }

3，使用集合set解决

还一种比较简单的方式是，把原数组的值全部存放到集合set中，然后再从1开始循环，判断这个数是否存在集合中，如果不存在直接返回。

    public int firstMissingPositive(int[] nums) {
        int len = nums.length;
        Set<Integer> hashSet = new HashSet<>();
        for (int num : nums) {
            hashSet.add(num);
        }
        for (int i = 1; i <= len; i++) {
            if (!hashSet.contains(i))
                return i;
        }
        return len + 1;
    }

4，存放对应的位置

我们还可以把每个元素存放到对应的位置，比如1存放到数组的第一个位置，3存放到数组的第3个位置，
如果是非正数或者大于数组的长度的值，我们不做处理，最后在遍历一遍数组，如果位置不正确，说明这个位置没有这个数，我们就直接返回。

    public int firstMissingPositive(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            //如果在指定的位置就不需要修改
            if (i + 1 == nums[i])
                continue;
            int x = nums[i];
            if (x >= 1 && x <= nums.length && x != nums[x - 1]) {
                swap(nums, i, x - 1);
                i--;//抵消上面的i++，如果交换之后就不++；
            }
        }
        //最后在执行一遍循环，查看对应位置的元素是否正确，如果不正确直接返回
        for (int i = 0; i < nums.length; i++) {
            if (i + 1 != nums[i])
                return i + 1;
        }
        return nums.length + 1;
    }

    //交换两个数的值
    public void swap(int[] A, int i, int j) {
        if (i != j) {
            A[i] ^= A[j];
            A[j] ^= A[i];
            A[i] ^= A[j];
        }
    }

5，位运算求解

位运算的实现原理和上面第4种答案类似，只不过这里使用的是位运算的方式来解决的。我们知道在java中一个int类型占4个字节是32位，我们可以申请一个数组，1到32我们可以存放到数组的第一个元素中，33到64可以存放到第2个元素中……，有的同学可能好奇，一个数字怎么可能存放32个数呢。因为一个int类型数字是32位的，也就是由32个0和1组成，我们只要统计1在存储中的位置即可，我们来看下代码。

    public int firstMissingPositive(int[] nums) {
        int length = nums.length;
        int bit[] = new int[(length - 1) / 32 + 1];
        for (int i = 0; i < nums.length; i++) {
            int digit = nums[i];
            //数组必须在1到length之间才有效
            if (digit >= 1 && digit <= length) {
                int index = (digit - 1) / 32;
                bit[index] |= (1 << ((digit - 1) % 32));
            }
        }
        //最后在执行一遍循环，查看对应位置的元素是否正确，如果不正确直接返回
        for (int i = 0; i < nums.length; i++) {
            if ((bit[i / 32] & (1 << (i % 32))) == 0)
                return i + 1;
        }
        return length + 1;
    }

6，如果某个元素的值是无效的，他会让数组后面的元素填补过来，然后再判断。注释写在代码中了，有兴趣的也可以看下。

    public int firstMissingPositive(int[] nums) {
        int start = 0;
        int end = nums.length - 1;
        while (start <= end) {
            int index = nums[start] - 1;
            if (index == start) {
                //存放的位置正确
                start++;
            } else if (index < 0 || index > end || nums[start] == nums[index]) {
                //前面两个表示数字不在存放位置范围内，就让数组end位置的元素把这个无效的
                // 元素覆盖掉，后面一个表示的是index这个位置存放正确了就不需要在存放了
                nums[start] = nums[end--];
            } else {
                //把start对应的元素存放到正确的位置
                nums[start] = nums[index];
                nums[index] = index + 1;
            }
        }
        return start + 1;
    }

参考：https://leetcode-cn.com/problems/first-missing-positive/solution/javade-6chong-jie-fa-de-tu-wen-xiang-jie-wei-yun-s/