645.错误的集合

1.题目描述

集合 S 包含从1到 n 的整数。不幸的是，因为数据错误，导致集合里面某一个元素复制了成了集合里面的另外一个元素的值，导致集合丢失了一个整数并且有一个元素重复。

给定一个数组 nums 代表了集合 S 发生错误后的结果。你的任务是首先寻找到重复出现的整数，再找到丢失的整数，将它们以数组的形式返回。

示例 1:

	输入: nums = [1,2,2,4]
	输出: [2,3]
	注意:

给定数组的长度范围是 [2, 10000]。
给定的数组是无序的。

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

代码

第一种：暴力解法

			暴力解法不用多说了，遍历数组给数组中的元素计数
			①count == 2--->重复
			②count  == 0--->缺失

//暴力解法一
    public int[] findErrorNums(int[] nums) {
        int dup = -1, missing = -1;
        int len = nums.length;
        //第一层循环，是正确的数组元素
        for (int i = 1; i < len + 1; i++) {
            //count要每次都初始化为0
            int count = 0;
            for (int j = 0; j < len; j++) {
                if (nums[j] == i) {
                    count++;
                }
            }
            if (count == 2) {
                dup = i;
            } else if (count == 0) {
                missing = i;
            }

        }

        return new int[]{dup, missing};

    }

第二种：优化暴力解法

			与第一种不同的区别就是找到了就停止查找

 public int[] findErrorNums(int[] nums) {
        int dup = -1, missing = -1;
        int len = nums.length;
        //第一层循环，是正确的数组元素
        for (int i = 1; i < len + 1; i++) {
            //count要每次都初始化为0
            int count = 0;
            for (int j = 0; j < len; j++) {
                if (nums[j] == i) {
                    count++;
                }
            }
            if (count == 2) {
                dup = i;
            } else if (count == 0) {
                missing = i;
            }
            //优化的暴力解法
            if (dup > 0 && missing > 0) {
                break;
            }
        }

        return new int[]{dup, missing};

    }

第三种：使用排序

			①数组的数据范围是1~·10000，可以用循环代表数组中的数据
			
			②前提是nums是递增有序的
			
			③判断重复的方法就是数组中相邻的两个元素是相等的
			
			④缺失的元素是相邻的两个数据的差 > 1
			
			⑤如果没有差大于1的就判断数组中的最后一个元素是否和数组的长度相等
			结论是不相等的，eg：[1,2,2]此时缺失的就是数组中理应最大的数即数组的长度

 //使用排序
    public int[] findErrorNums(int[] nums) {
        Arrays.sort(nums);
        int dup = -1, missing = 1;
        int len = nums.length;
        for (int i = 1; i < len; i++) {
            if (nums[i] == nums[i - 1]) {
                dup = nums[i];
            } else if (nums[i] > nums[i - 1] + 1) {
                missing = nums[i - 1] + 1;
            }
        }

        return new int[]{dup, nums[len - 1] == len ? missing : len};

    }

第四种：Map

public int[] findErrorNums(int[] nums) {
        //使用map
        int dup = -1, missing = -1;
        int len = nums.length;

        Map<Integer,Integer> map = new HashMap();

        //存入map中并计数
        for (int n:nums){
            map.put(n,map.getOrDefault(n,0) + 1);//map.getOrDefault第一个参数是在map中找个键，没找到就将对应的值设为0+1，找到了就是对应的值再+1，即将map中的键进行技术

        }

        for (int i = 1; i <= len; i++) {
            if(map.containsKey(i)){//(map.containsKey(i)是判断map中的键是否有i
                if(map.get(i) == 2){//map.get(i)获取键为i的值
                    dup = i;
                }
            }else{
                missing = i;
            }
        }
        return new int[]{dup, missing};

    }

第五种：使用额外数组

public static int[] findErrorNums(int[] nums) {
        //使用额外数组
        //arr的长度是nums.length + 1,是因为nums这个数组中的数据下标是从1开始的
        int[] arr = new int[nums.length + 1];//声明一个数组，初始值为0
        int dup = -1,missing = 1;
        //求各个元素的个数，将他存到数组
        //索引代表数字，eg：arr[2]代表数字2出现的个数

        for (int i = 0; i <nums.length ; i++) {
            arr[nums[i]] += 1;
        }
        int ch = 0;

        //下标从1开始是因为nums这个数组中的数据范围是1~10000，没有0
        for (int i = 1; i < arr.length; i++) {
            if(arr[i] == 0){
                missing = i;
            }
            if(arr[i] == 2){
                dup = i;
            }
        }

        return new int[]{dup, missing};

    }

第六种：额外空间

public static int[] findErrorNums(int[] nums) {
        //使用额外空间
        int dup = -1, missing = 1;

        //遍历数组，如果大于0就使用额外空间将他转成负数,找到重复的元素
        //eg:[1，2，2，4]---->>(num[1 - 1] = 1)>0,转成负数
//                      (num[2 - 1] = 2)>0,转成负数
//                      (num[2 - 1] = -2)<0,dup = 2
//                      (num[4 - 1] = 3)>0,转成负数
        for (int n : nums) {
            //nums[1 - 1]大于0，将他转成负数
            if (nums[Math.abs(n) - 1] < 0) {//判断nums[1 - 1]是否小于0，true就是重复的
                dup = Math.abs(n);
            } else {
                nums[Math.abs(n) - 1] = nums[Math.abs(n) - 1] * -1;
            }
        }

        //找到缺失的元素，因为范围是1~10000，上述for循环遍历过的都转成了负数，所以在下面找到的整数就是缺失的元素
        //nums[0] = -1,nums[1] = -2,nums[2] = 2,nums[3] = -4
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > 0) {
                missing = i + 1;
            }
        }
//        System.out.println("dup = " + dup + "missing =" + missing);
        return new int[]{dup, missing};

    }