【剑指offer】面试题3：数组中的重复数字

 

题目1：找出数组中重复的数字

在一个长度为n的数组里的所有数字都在0到n-1的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。例如，如果输入长度为7的数组{2, 3, 1, 0, 2, 5, 3}，那么对应的输出是重复的数字2或者3。

解题思路：

从哈希表的思路拓展，重排数组：从头到尾依次扫描这个数组中的每个数字。当扫描到下标为 i 的数字时，首先比较这个数字 m 是不是等于器下标 i 。如果是，则接着扫描下一个数字；如果不是，则再拿它和下标为 m 位置上的元素进行比较，如果相等，则找到了一个重复的数字，因为该数字在下标为 i 和 m 的位置上都出现了；如果不相等，则就把下标为 i 的元素和 下标为 m 的元素交换，把 m 放到属于它的位置上，然后每个位置上的元素依次重复这个过程。 

测试用例：

　　1、数组中带一个或多个重复数字；

　　2、数组中不包含重复的数字；

　　3、无效输入测试用例（空数组，数组数字越界等）。

/**
 * 找出数组中任意一个重复的数字
 */
public class FindRepeatNum {

	/**
	 * @param nums ：数组
	 * @param length ：数组的长度
	 * @param duplication ：用来记录重复元素的数组
	 * @return
	 */
	public static boolean duplicate(int nums[], int length, int[] duplication) {

		if (nums == null || length <= 0) {
			return false;
		}

		for (int a : nums) {
			if (a < 0 || a >= length) {
				return false;
			}
		}

		int temp;
		for (int i = 0; i < length; i++) {
			// 下标为 i 位置上的元素值不为 i
			while (nums[i] != i) {
				// 判断下标为 nums[i] 位置上的元素值是否为 nums[i]
				if (nums[nums[i]] == nums[i]) {
					// 如果下标为nums[i]上的值等于nums[i]，则说明数字重复
					duplication[0] = nums[i];
					return true;
				}

				// 将下标为 i 和下标为 nums[i] 位置上的元素交换位置
				temp = nums[i];
				nums[i] = nums[temp];
				nums[temp] = temp;
			}
		}
		return false;
	}

	// 测试用例
	public static void test1() {
		System.out.print("test1:");
		int[] a = { 1, 2, 3, 4 };
		int[] dup = new int[a.length];
		boolean result = duplicate(a, a.length, dup);
		System.out.println(result);
	}

	// 测试用例
	public static void test2() {
		System.out.print("test2:");
		int[] a = { 1, 2, 3, 4, 2};
		int[] dup = new int[a.length];
		boolean result = duplicate(a, a.length, dup);
		System.out.println(result);
	}

	public static void main(String[] args) {
		test1();  // false
		test2();  // true
	}
}

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

题目2：不修改数组找出重复的数字

在一个长度为n+1的数组里的所有数字都在1~n的范围内，所以数组中至少有一个数字是重复的。请找出数组中任意一个重复的数字，但是不能修改输入的数组。例如，如果输入长度为8的数组{2,3,5,4,3,2,6,7}，那么对应的输出是重复的数字2或者3。

题目2和题目1的区别就是：不能修改输入的数组，下面提供两种解题思路。

• 思路1

由于不能修改输入的数组，我们可以创建一个长度为 n+1 的辅助数组，然后逐一把原数组的每个数字复制到辅助数组。如果原数组中被复制的数字是m，则把它复制到辅助数组中下标为m的位置。如果下标为m的位置上已经有数字了，则说明该数字重复了。由于使用了辅助空间，故该方案的空间复杂度是O(n)。

public class FindRepeatNum1 {

	public int getDuplication(int arr[]){
		
		int[] tempArr = new int[arr.length];
		for(int i = 0; i < arr.length; i++){
			if(arr[i] < 0 || arr[i] >= arr.length){
				throw new IllegalArgumentException("输入参数不合法");
			}else{
				tempArr[i] = -1;
			}
		}
		
		for(int i = 0; i < arr.length; i++){
			if(tempArr[arr[i]] != arr[i]){
				// 如果tempArr数组上下标为 arr[i]位置上的元素值不等于 arr[i]
				tempArr[arr[i]] = arr[i];
			}else{
				// 相等，则说明元素重复了
				return arr[i];
			}
		}
		return -1; // 没有重复的元素
	}
	
	public static void main(String[] args) {
		FindRepeatNum1 findRepeatNum = new FindRepeatNum1();
		int[] arr = {2,3,5,4,3,2,6,7};
		int value = findRepeatNum.getDuplication(arr);
		System.out.println(value);  // 3
	}
}

• 思路2

由于思路1的空间复杂度是O(n)，因此我们需要想办法避免使用辅助空间。我们可以想：如果数组中有重复的数，那么n+1个1~n范围内的数中，一定有几个数的个数大于1。那么，我们可以利用这个思路解决该问题。

我们把从1~n的数字从中间的数字m分为两部分，前面一半为1~m，后面一半为m+1~n。如果1~m的数字的数目等于m，则不能直接判断这一半区间是否包含重复的数字，反之，如果大于m，那么这一半的区间一定包含重复的数字；如果小于m，另一半m+1~n的区间里一定包含重复的数字。接下来，我们可以继续把包含重复的数字的区间一分为二，直到找到一个重复的数字。

由于如果1~m的数字的数目等于m，则不能直接判断这一半区间是否包含重复的数字，我们可以逐步减少m，然后判断1~m之间是否有重复的数，即，我们可以令m=m-1，然后再计算1~m的数字的数目是否等于m，如果等于m，再令m=m-1，如果大于m，则说明1~m的区间有重复的数，如果小于m，则说明m+1~n有重复的数，不断重复此过程。

public class FindRepeatNum3 {
	
	public int getDuplication(int[] arr){
		
		for(int i = 0; i < arr.length; i++){
			if(arr[i] < 0 || arr[i] >= arr.length){
				throw new IllegalArgumentException("参数输入不合法");
			}
		}
		
		int start = 0;
		int end = arr.length - 1;
		int flag = 0;   // 有无重复元素的标识
		int middle = 0;
		while(end >= start){
			if(flag == 0){
				middle = (end + start) / 2;
			}
			int count = countRange(arr, start, middle);
			if(end == start){
				if(count > 1){
					// 说明 end 和 start 位置上的元素值相等
					return start;
				}else{
					break;
				}
			}
			
			if(count > (middle - start + 1)){
				// 说明（start, middle）这个区间有重复的数
				end = middle;
				flag = 0;
			}else if(count == (middle - start + 1)){
				middle = middle - 1;   // 缩小区间
				if(middle < start){
					// 说明(start,middle)这个区间没有重复的数
					start = (start + end) / 2 + 1;
					flag = 0;
				}else{
					flag = 1;
				}
			}else{
				// 说明(middle+1,end)这个区间有重复的数
				start = middle + 1;
				flag = 0;
			}
		}
		return -1;
	}

	// 统计元素值在[start,end]区间中的个数
	private int countRange(int[] arr, int start, int end) {

		int count = 0;
		for (int i = 0; i < arr.length; i++) {
			if(arr[i] >= start && arr[i] <= end){
				++count;
			}
		}
		return count;
	}
	
	// 测试
	public static void main(String[] args) {
		FindRepeatNum3 findRepeatNum = new FindRepeatNum3();
		int[] arr = {0,3,5,4,1,2,6,7,6};
		int value = findRepeatNum.getDuplication(arr);
		System.out.println(value);
	}
}

上述代码按照二分查找的思路，如果输入长度为n的数组，那么函数countRange最多将被调用O(logn)次，每次需要O(n)的时间，因此总的时间复杂度是O(nlogn)。但是如果区间无重复的数，则时间复杂度将变为O()。

• 总结

从上诉分析我们可以看出，如果面试官提出不同的功能需求（找出任意一个重复的数字、找出所有重复的数字）或者性能要求（时间效率优先、空间效率优先），那么我们最终选取的算法也将不同。这也说明在面试中和面试官交流的重要性，我们一定要动手写代码之前弄清楚面试官的需求。