面试题3：数组中重复的数
题目要求：
在一个长度为n的数组中，所有数字的取值范围都在[0,n-1]，但不知道有几个数字重复或重复几次，找出其中任意一个重复的数字。
解法比较：
| 解法 | 解法介绍 | 是否改变原数组 | 时间复杂度 | 空间复杂度 |
|---|---|---|---|---|
| 解法一 | 暴力求解 | 否 | o(n^2) | o(1) |
| 解法二 | 借助快排 | 是 | o(nlogn) | o(1) |
| 解法三 | 借助哈希表 | 否 | o(n) | o(n) |
| 解法四 | 根据数字特点排序 | 是 | o(n) | o(1) |
| 解法五 | 二路计数 | 否 | o(nlogn) | o(1) |
package chapter2;
/**
* Created by ryder on 2017/6/11.
* 一个长度为n的数组，值的范围在0~n-1内，有一个或多个数字重复，求其中任意一个
*/
public class P39_DuplicationInArray {
//方法一：暴力求解，不会修改原始数据，时间复杂度o(n^2)，空间复杂度o(1)
public static int getDuplication(int[] data){
if(data==null || data.length<2)
return -1;
for(int i=0;i<data.length-1;i++){
for(int j=i+1;j<data.length;j++){
if(data[i]==data[j])
return data[i];
}
}
return -1;
}
//方法二：排序，会修改原始数据，时间复杂度o(nlogn)，空间复杂度o(1)
public static int getDuplication2(int[] data){
if(data==null || data.length<2)
return -1;
//Arrays.sort(data); //或者使用内置函数进行排序
quickSort(data,0,data.length-1);
if(data.length<2)
return -1;
int prev = data[0];
for(int i=1;i<data.length;i++){
if(data[i]==prev)
return prev;
else
prev = data[i];
}
return -1;
}
public static void quickSort(int[] data,int start,int end){
if(start>=end)
return;
int bound = partion(data,start,end);
quickSort(data,start,bound-1);
quickSort(data,bound+1,end);
}
public static int partion(int[] data,int start,int end){
if(start>=end)
return end;
int pivot = data[start];
int left = start, right = end;
while(left<right){
while(left<right && data[right]>=pivot)
right--;
if(left<right)
data[left++] = data[right];
while(left<right && data[left]<pivot)
left++;
if(left<right)
data[right--] = data[left];
}
data[left] = pivot;
return left;
}
//方法三：借助哈希表，不会修改原始数据，时间复杂度o(n),空间复杂度o(n)
public static int getDuplication3(int[] data){
if(data==null || data.length<2)
return -1;
int[] hashTable = new int[data.length];
for(int item:data){
if(hashTable[item]>=1)
return item;
else{
hashTable[item] = 1;
}
}
return -1;
}
//方法四：根据数字特点排序，会修改原始数据，时间复杂度o(n),空间复杂度o(1)
public static int getDuplication4(int[] data){
if(data==null || data.length<2)
return -1;
for(int i=0;i<data.length;i++){
while(data[i]!=i){
if(data[i]==data[data[i]])
return data[i];
else{
int temp = data[i];
data[i] = data[temp];
data[temp] = temp;
}
}
}
return -1;
}
//方法五：类似于二路归并，这个思路应该说是二路计数，不修改原始数据，时间复杂度o(nlogn),空间复杂度o(1)
public static int getDuplication5(int[] data){
if(data==null || data.length<2)
return -1;
//数组值在[start,end]间
int start = 0;
int end = data.length-2;
while(start<=end){
int middle = (end-start)/2+start;
int count = countRange(data,start,middle);
if(start==end){
if(count>1)
return start;
else
return -1;
}
if(count>middle-start+1)
end = middle;
else
start = middle+1;
}
return -1;
}
public static int countRange(int[] data,int start,int end){
int count = 0;
for(int i=0;i<data.length;i++){
if(start<=data[i] && end>=data[i])
count++;
}
return count;
}
public static void main(String[] args){
int[] data = {2,3,1,0,2,5,3};
System.out.println(getDuplication(data));
System.out.println(getDuplication2(data));
System.out.println(getDuplication3(data));
System.out.println(getDuplication4(data));
System.out.println(getDuplication5(data));
int[] data1 = {2,3,1,0,4,5,5};
System.out.println(getDuplication(data1));
System.out.println(getDuplication2(data1));
System.out.println(getDuplication3(data1));
System.out.println(getDuplication4(data1));
System.out.println(getDuplication5(data1));
}
}
运行结果(前面几个方法会更改原数组，但不影响测试功能)
2
2
2
2
2
5
5
5
5
5
