算法面试题之数组中重复的数字

题目

找出数组中重复的数字，其中，长度为n的数组里的所有数字都在0~n-1的范围内

例如：如果输入长度为7的数组{2,4,1,4,5,6,1}，那么对应的输出是重复的数字4或者1。

解决思路

解决任何问题的思路都是由简到难，由大到小。衡量一个算法优劣的标准是其时间复杂度和空间复杂度的大小，时间复杂度以及空间复杂度越小，说明该算法越好。

思路1

解决该问题最简单也是最容易想到的方法是先把数组进行排序，然后遍历排序的数组，那就很容易找出重复的数字了。该算法的时间复杂度主要产生于排序中，而当前的排序算法时间复杂度小的算法有快速排序、堆排序和归并排序，时间复杂度均为O(nlogn)，因此该算法的时间复杂度为O(nlogn)。下面是该算法选择快速排序作为排序算法的Java程序：

package TempFile;

/**
* Created by 余沾.
*/
public class Test {

/*
* 利用排序思路求出数组中重复的数字
*/
int duplicate(int sortedArr[])
{
if(sortedArr[0] < 0 || sortedArr[sortedArr.length-1] >= sortedArr.length)//数组的所有值都必须在0~n-1内
throw new IllegalArgumentException("数组不合法");
int i;
for(i = 1;i < sortedArr.length;i++)
{
if(sortedArr[i] == sortedArr[i-1])
break;
}
if(i != sortedArr.length)
return sortedArr[i];
else
return -1;
}

/*
*快速排序
1．先从数列中取出一个数作为基准数。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。
*/
void quickSort(int arr[], int start, int end)
{
if(start < end)//判断start是否等于end,如果等于则说明各区间只有一个数
{
int i = start;
int j = end;
int x = arr[start];//将start作为基准数
while(i < j)//如果i=j,则结束
{
while(i < j && arr[j] >= x) // 从右向左找第一个小于x的数
j--;
//此时,arr[j] < x,则令arr[i]=arr[j],且i向前移动一格
if(i < j)
arr[i++] = arr[j];

while(i < j && arr[i] < x)// 从左向右找第一个大于等于x的数
i++;
//此时,arr[i] >= x,则令arr[j]=arr[i],且j向后移动一格
if(i < j)
arr[j--] = arr[i];
}
//此时,arr[i]=arr[j]=x,且比x大的数全在它的右边，小于或等于它的数全在其左边。下面则再对其左右区间重复这个步骤
arr[i] = x;
quickSort(arr,start,i-1);//对其左边区间重复上述操作
quickSort(arr,i+1,end);//对其右边区间重复上述操作
}
}

public static void main(String[] args) {

int[] arr = {2,4,1,4,5,6,1};
Test t = new Test();
t.quickSort(arr,0,6);
int dupValue = t.duplicate(arr);
}
}

思路2

另一个简单的解决思路是哈希表。可以从头到尾按顺序扫描数组的每个数字，每次扫描，先判断该数字是否在哈希表中，如果存在，则该数为重复的数，如果不存在，则把该数字添加到哈希表中。这个算法的时间复杂度是O(n)，但是它使用了哈希表，所以空间复杂度是O(n)。这是一种以空间换时间的算法。下面是利用利用哈希表解决数组中重复的数字的Java程序：

package TempFile;
import java.util.HashSet;
import java.util.Set;

/**
* Created by 余沾.
*/
public class Test {

/*
* 利用哈希表求出数组中重复的数字
*/
int duplicate(int arr[])
{
Set set = new HashSet<Integer>();
int i;
for(i = 0;i < arr.length;i++)
{
if(arr[i] < 0 || arr[i] >= arr.length)
throw new IllegalArgumentException("数组不合法");
}
for(i = 0;i < arr.length;i++)
{
if(set.contains(arr[i]))
break;
else
set.add(arr[i]);
}
if(i != arr.length)
return arr[i];
else
return -1;
}

public static void main(String[] args) {

int[] arr = {2,4,1,4,5,6,1};
Test t = new Test();
t.quickSort(arr,0,6);
int dupValue = t.duplicate(arr);
}
}

思路3

前面的算法都没有很理想，理想的算法是时间复杂度为O(n)，空间复杂度为O(1)。注意到，数组中的数字都在0~n-1的范围内，所以，如果数组中没有重复的数，那么，当数组排序后，数字i将出现在下标为i的位置。由于数组中有重复的数字，有些位置可能存在多个数字，同时，有些位置可能没有数字。所以，我们可以利用这个思路高效解决这个问题。现在我们重排这个数组，从头到尾扫描每个数字，当扫描到下标为i的数字时，首先比较这个数字(记为m)是不是等于i。如果是，则接着扫描下一个数字；如果不是，则再拿它和第m个数字进行比较。如果它和第m个数字相等，就找到了一个重复的数字（该数字在下标为i和m的位置都出现了）；如果它和第m个数字不相等，就把第i个数字和第m个数字交换，把m放到属于它的位置。接下来再重复这个比较、交换的过程。下面则为该思路的Java实现程序：

package TempFile;

/**
* Created by 余沾.
*/
public class Test {

/*
* 利用数组中的数只能在0~n-1解决问题
*/
int duplicate(int arr[])
{
int i;
for(i = 0;i < arr.length;i++)
{
if(arr[i] < 0 || arr[i] >= arr.length)
throw new IllegalArgumentException("数组不合法");
}
for(i = 0;i < arr.length;i++)
{
while(arr[i] != i)
{
if(arr[i] == arr[arr[i]])//有重复的数
{
return arr[i];
}
//如果arr[i]的值与arr中下标为arr[i]的值不相等,则互换两个值
int temp = arr[i];
arr[i] = arr[temp];
arr[temp] = temp;
}
}
return -1;
}

public static void main(String[] args) {

int[] arr = {2,4,1,4,5,6,1};
Test t = new Test();
int dupValue = t.duplicate(arr);
}
}

由于代码中有一个两重循环，但每个数字最多只要交换两次就能找到属于它自己的位置，因此总的时间复杂度是O(n)。另外，所有的操作步骤都是在输入数组上进行的，不需要额外分配内存，因此空间复杂度为O(1)。