再战leetcode （缺失的第一个正数）

41. 缺失的第一个正数

题目描述

方法一 （二分查找法）

题目要求的时间复杂度是o(n)
而用了二分查找法的时间复杂度是 o(log n)不符合题目要求，可是能够做出来，过了这道题。
代码

class Solution {

    /**
     * 二分查找法
     *
     * @param nums 未排序的整数数组(注意)有负数
     * @return 其中没有出现的最小的正整数
     */
    public int firstMissingPositive(int[] nums) {
        int n = nums.length;
        Arrays.sort(nums);

        for (int i = 1; i <= n; i++) {
            int res = binarySearch(nums,i);
            if (res == -1){
                return i;
            }
        }
        // 1 2 3 4 5 6
        return n + 1;
    }

    private int binarySearch(int[] nums, int target) {
        int left = 0, right = nums.length - 1;
        while (left <= right) {
            int mid = (left + right) >>> 1;
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] < target) {
                left = mid + 1;
            }else{
                right = mid -1;
            }
        }
        return -1;
    }

}

方法二 原地哈希

原地哈希就相当于，让每个数字n都回到下标为n-1的家里。
而那些没有回到家里的就成了孤魂野鬼流浪在外，他们要么是根本就没有自己的家（数字小于等于0或者大于nums.size()），要么是自己的家被别人占领了（出现了重复）。
这些流浪汉被临时安置在下标为i的空房子里，之所以有空房子是因为房子i的主人i+1失踪了（数字i+1缺失）。
因此通过原地构建哈希让各个数字回家，我们就可以找到原始数组中重复的数字还有消失的数字。

代码内有注释解释

class Solution {
    public int firstMissingPositive(int[] nums) {
        int n = nums.length;

        for (int i = 0; i < n; i++) {
            // 这里用while是因为交换回来的值不一定是"值配其位"的，那么就可能还需要进行交换
            // 比如[4,1,2,3]
            // 1.第一次将4与3交换，形成[3,1,2,4]，明显3是"值不配位"的，也满足条件，进入新的交换
            // 2.第二次将3与2交换，形成[2,1,3,4]，明显2也是"值不配位"的，且满足条件，进入新的交换
            // 3.第三次将2与1交换，形成[1,2,3,4]，值全都配位了，后面的while也就都不会进了
            // (此处也说明while循环不会每一次都把数组里面的所有元素都看一遍。如果有一些元素在这一次的循环中
            // 被交换到了它们应该在的位置，那么在后续的遍历中，由于它们已经在正确的位置上了，代码再执行到它们
            // 的时候，就会被跳过。----引用自@liweiwei1419的题解)
            //**所以此处不能用if**
            // num[i]-1 因为这是要配位的,例如正常是 1 2 3 4 所以num[i]-1 就对应数组的下标
            // nums[nums[i]-1] == ? nums[i]就是判断是否符合这个配对
            while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) {
                //将出现的值都交换到相应的位置上，组成一个近似排序的数组
                //其中的负数和大于数组长度的值都可以不用管，因为它是作为一个出口存在的
                //这里值1放在索引0上，即值(i)需要放在索引(i-1)上
                swap(nums, nums[i] - 1, i);
            }
        }

        for (int i = 0; i < n; i++) {
            if (nums[i] != i + 1) {
                return i + 1;
            }
        }
        // 全部满足条件返回 n + 1 (数组长度+1)
        return n + 1;
    }

    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}