缺失的第一个正整数

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param nums int整型一维数组
     * @return int整型
     */
    public int minNumberDisappeared (int[] nums) {
        // write code here
        // 算法核心思想：通过按正整数顺序的方式创建哈希记录，遍历数组登记哈希，然后遍历哈希
        // 算法时间复杂度O(N)，额外空间复杂度O(N)（没做到O(1)）

        // 1.遍历数组，记录数组中出现过的最小正整数值，并将所有正整数记录哈希表
        // 记录最小值是为了简化判断，若最小值>1可以直接返回1
        int min = Integer.MAX_VALUE;
        HashMap<Integer, Boolean> hm = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > 0) {
                hm.put(nums[i], true);
                if (nums[i] < min) {
                    min = nums[i];
                }
            }
        }
        if (min > 1) {
            // 若数组中出现过的最小正整数比1大，则可直接输出最小正整数1
            return 1;
        }
        // 其余情况均为从1开始出现，直到某个值没有出现

        // 2.从1开始遍历HashMap，输出最早未登记的key
        int i = 2;
        while (hm.containsKey(i)) {
            i++;
        }
        return i;
    }
}

public int minNumberDisappeared (int[] nums) {
    // write code here
    Arrays.sort(nums);
    int index=1;
    for(int num:nums){
        if(num>=1 && num!=index++){
            return index-1;
        }
    }
    return index;
}

public int minNumberDisappeared (int[] nums) {
    // write code here
    if (nums == null || nums.length == 0) return -1;

    Arrays.sort(nums);
    
    int min = 1;
    for (int i = 0; i < nums.length; i++) {
        if (nums[i] < 1) {
            continue;
        } else if (nums[i] == min) {
            min++;
            continue;
        }
    }
    return min;
}

import java.util.*;
import java.util.stream.Collectors;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param nums int整型一维数组
     * @return int整型
     */
    public int minNumberDisappeared (int[] nums) {
        List<Integer> collect = Arrays.stream(nums).boxed()
                                .filter(item -> item > 0)
                                .sorted(Comparator.naturalOrder())
                                .collect(Collectors.toList());
        boolean isFirst = true;
        if (collect.size() == 0) {
            return 1;
        } else if (collect.size() == 1) {
            return (collect.get(0) != 1) ? 1 : 2;
        }
        for (int i = 0; i < collect.size() - 1; i++) {
            int val1 = collect.get(i);
            int val2 = collect.get(i + 1);
            if (isFirst && val1 > 1) return 1;
            if (val2 - val1 > 1) return val1 + 1;
            isFirst = false;
            if (i == collect.size() - 2) return val2 + 1;
        }
        return 1;
    }
}

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param nums int整型一维数组
     * @return int整型
     */
    public int minNumberDisappeared (int[] nums) {
        // 1. 参数校验
        if (nums == null || nums.length == 0) {
            return -1;
        }

        // 2. 对数组进行排序
        Arrays.sort(nums);

        // 3. 创建 ans 表示缺失的第一个正数
        // 初始化成 1
        int ans = 1;

        // 4. 遍历数组
        for (int x : nums) {
            // 如果当前元素 == res,那就代表当前正整数出现过
            if (x == ans) {
                ans++;
            }
        }

        // 5. 最后返回 ans 的值
        return ans;
    }
}

public int minNumberDisappeared (int[] nums) {
        // 缺失的  最小  正 正数  所以最小的结果只可能是1
        //先存入Map,
        //再遍历Map
        if(nums==null||nums.length==0) return -1;
        Map<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<nums.length;i++){
            map.put(nums[i],1);//map存的  k-number[i]  v-1
        }
        int ans=1;
        for(int i=0;i<map.size();i++){//遍历map
            if(map.containsKey(ans)){//这里的containsKey(ans)  括号中是ans
                ans++;
            }
        }
        return ans;
    }

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型一维数组 
     * @return int整型
     */
    public int minNumberDisappeared (int[] nums) {
        int i = 0;
        int j = 0;
        while (i < nums.length && j < nums.length) {
            if (nums[j] == i + 1) {
                //找到了当前位置下的数字
                swap(nums, i, j);
                ++i;
                j = i;
            } else {
                ++j;
            }
        }
        return i + 1;
    }

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

public int minNumberDisappeared (int[] nums) {
        int temp = 0;
        ArrayList<Integer> arr = new ArrayList<>();
        for(int i=0;i<nums.length;i++){
            arr.add(nums[i]);
        }
        Collections.sort(arr);
        for(int i=0;i<arr.size();i++){
            if(arr.get(i) == temp+1){
                temp = arr.get(i);
            }
        }
        return temp+1;
    }

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型一维数组 
     * @return int整型
     */
    public int minNumberDisappeared (int[] nums) {
        // write code here
        HashMap<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<nums.length;i++){
            map.put(nums[i],1);//用hashMap存储nums中的元素
        }
        int res=1;
        for(int i=0;i<map.size();i++){
            if(map.containsKey(res)){
                res++;//如果res都存在与map的key中，则1到res的值都存在，返回res+1即可，如果第一次不存在于hashMap中，则返回第一次的res值
            }
        }
        return res;
    }
}

 public int minNumberDisappeared (int[] nums) {
                  Arrays.sort(nums);
            for(int i=1;i<nums.length+2;i++){
               int a = Arrays.binarySearch(nums,i);
              if(a<0){
                  return i;
              }
            }
          return 0;
    }
太简单了，不会有人不会吧

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型一维数组 
     * @return int整型
     */
    public int minNumberDisappeared (int[] nums) {
        // write code here
        Arrays.sort(nums);
        int length=nums.length;
        int max=nums[length-1];
        int min=nums[0];
        if(min>1||max<1)return 1;
        for(int index=0;index<length;index++){
            if(index==length-1){
                return nums[index]+1;
            }else if(nums[index+1]-nums[index]>1){
               for(int tmp=nums[index]+1;tmp<nums[index+1];tmp++){
                   if(tmp>0){
                       return tmp;
                   }
               }
            }
        }
        return -1;
       
    }
}