数组中重复的数字

1.题目

2.解法1（空间复杂度nlogn）

先使用排序算法，接着看相邻元素是不是相等

import java.util.*;
public class Solution {
    public boolean duplicate(int numbers[],int length,int [] duplication) {
        if(numbers == null || length == 0){
            return false;
        }
        Arrays.sort(numbers);
        for(int i=0;i<length-1;i++){
            if(numbers[i] == numbers[i+1]){
                duplication[0] = numbers[i];
                return true;
            }
        }
        return false;
    }
}

时间复杂度为O（nlogn），空间复杂度为O(n),因为归并排序会创建一个数组

3.解法2(空间复杂度n）

因为很明确数组的所有的数字都在0到n-1的范围内，所以可以创建一个arr[n]的数组，首先遍历一遍，计算每个数的count，然后再遍历一遍找到只出现1次的数字。

public class Solution {
    public boolean duplicate(int numbers[],int length,int [] duplication) {

        if(numbers == null || length == 0) return false;

        // 安排一个数组，用来存储0-（n-1)之间的值
        int[] countArr = new int[length];
        for (int i = 0; i < length; i++) {
            countArr[numbers[i]]++;
        }

        for (int i = 0; i < length; i++) {
            if(countArr[i] == 2){
                // 任意一个，所以i可以从0开始，如果要求第一个，那么就用numbers[i]做下标
                duplication[0] = i;
                return true;
            }
        }
        return false;
    }
}

时间复杂度为O(n), 空间复杂度为O(n) （推荐这个方法！！！）

或者使用哈希表，利用HashSet

import java.util.*;
public class Solution {
   
    public boolean duplicate(int numbers[],int length,int [] duplication) {

        if(numbers == null || length == 0) return false;

        Set<Integer> set = new HashSet<>();
        
        for(int i = 0; i < length; i++){
            
           // 如果已经包含这个数，说明重复出现了两次 
           if(set.contains(numbers[i])){
                duplication[0] = numbers[i];
               return true;
            }else{
               set.add(numbers[i]);
           }
        }
        return false;
    }
}

4.解法3(根据下标，将值换到自己对应的位置）

数组的长度为 n 且所有数字都在 0 到 n-1 的范围内，我们可以将每次遇到的数进行"归位"，当某个数发现自己的"位置"被相同的数占了，则出现重复。
扫描整个数组，当扫描到下标为 i 的数字时，首先比较该数字（m）是否等于 i，如果是，则接着扫描下一个数字；如果不是，则拿 m 与第 m 个数比较。如果 m 与第 m 个数相等，则说明出现重复了；如果 m 与第 m 个数不相等，则将 m 与第 m 个数交换，将 m “归位”，再重复比较交换的过程，直到发现重复的数

import java.util.*;
    public class Solution {
        public boolean duplicate(int numbers[],int length,int [] duplication) {
            if(numbers == null || length == 0){
                return false;
            }
            int tmp = -1;
            for (int i = 0; i < length; i++) {
                // 首先判断此值，是否应该在i的位置
                while(numbers[i] != i){
                    // 如果不是在i的位置，判断它和原来位置的值是否相等
                    if(numbers[i] == numbers[numbers[i]]){
                        // 相等说明重复了
                        duplication[0] = numbers[i];
                        return true;
                    }else{
                        // 未重复，交换两者的值
                        tmp = numbers[i];
                        numbers[i] = numbers[tmp];
                        numbers[tmp] = tmp;
                    }
                }
            }
            return false;
        }
    }

时间复杂度为O(n),这个比上两种解法耗时，空间复杂度为O(1)