数组中重复的数字

1.字符串的做法
public class Solution {
    public boolean duplicate(int numbers[],int length,int [] duplication) {
StringBuffer sb=new StringBuffer();
for(int i=0;i<length;i++) {
sb.append(numbers[i]+"");
}
for(int j=0;j<length;j++) {
if(sb.indexOf(numbers[j]+"")!=sb.lastIndexOf(numbers[j]+"")) {
duplication[0]=numbers[j];
return true;
}
}
return false;
    }
}

2. 排序+扫描O(nlogn)，Arrays.sort()对于基本数据类型是快速排序，对对象类型是优化后的归并排序
   因此排序的时间复杂度是O(nlogn)
import java.util.Arrays;
public class Solution {
    public boolean duplicate(int numbers[],int length,int [] duplication) {
if(numbers==null || numbers.length==0) return false;
        Arrays.sort(numbers);
        for(int i=1;i<numbers.length;i++){
            if(numbers[i-1]==numbers[i]){
                duplication[0]=numbers[i];
                return true;
            }
        }
        return false;
    }

}
3. 哈希表：时间复杂度O(n) 空间复杂度O(n) 判断哈希表中是否包含O(1)
import java.util.*;
public class Solution {
    public boolean duplicate(int numbers[],int length,int [] duplication) {
if(numbers==null || numbers.length==0) return false;
        HashSet<Integer> set=new HashSet<Integer>();
        for(int i=0;i<numbers.length;i++){
            if(set.contains(numbers[i])){
                duplication[0]=numbers[i];
                return true;
            }else{
                set.add(numbers[i]);
            }
        }
        return false;
    }

}
4.挖掘数组特点，时间复杂度O(n)，空间复杂度O(1)，每个数组最多只要交换两次就能找到属于它自己的位置，且不需要额外分配空间，因为所有的操作都是在输入数组上进行的，这里带来的影响是对输入数组进行了修改，这个不一定是可以的，需要问面试官。
import java.util.*;
public class Solution {
    public boolean duplicate(int numbers[],int length,int [] duplication) {
if(numbers==null || numbers.length==0) return false;
        for(int i=0;i<numbers.length;i++){
            while(numbers[i]!=i){
                if(numbers[numbers[i]]!=numbers[i]){
                    int temp=numbers[i];
                    numbers[i]=numbers[temp];
                    numbers[temp]=temp;
                }else{
                    duplication[0]=numbers[i];
                    return true;
                }
            }
        }
        return false;
    }

}
将交换数组中两个位置的代码写成了一个函数的情况，更简洁和直观。
import java.util.*;
public class Solution {
    public boolean duplicate(int numbers[],int length,int [] duplication) {
if(numbers==null || numbers.length==0) return false;
        for(int i=0;i<numbers.length;i++){
            while(numbers[i]!=i){
                if(numbers[numbers[i]]!=numbers[i]){
                    swap(numbers,i,numbers[i]);
                }else{
                    duplication[0]=numbers[i];
                    return true;
                }
            }
        }
        return false;
    }
    public void swap(int[] array,int m,int n){
        int temp=array[m];
        array[m]=array
;
        array
=temp;
    }
}