Recursion 在数组中寻找神奇下标 @CareerCup

当数组里的元素没有重复时，因为数组已经是排序好的了，自然想到用二分法。

如果数组里的元素有重复时，magic index可能出现在左侧也可能出现在右侧，这个画图举个例子就知道了。

可以优化的是，无论是在左侧还是右侧，总有一些元素可以直接排除，从而缩短查找时间！

这个是没有重复元素的版本：

package Recursion;

import java.util.Arrays;

import CtCILibrary.AssortedMethods;

/**
 * A magic index in an array A[l.. .n-l] is defined to be an index such that
 * A[i] = i. Given a sorted array of distinct integers, write a method to find a
 * magic index, if one exists, in array A. 
 * 
 * FOLLOW UP What if the values are not distinct?
 * 
 * 在A[l...n-l]中有一个神奇的下标：它满足A[i] = i 如果给定一个排序过的且里面元素
 * 各不相同的数组，写一个方法来找到这个神奇的下标。
 * 
 * Follow Up: 假如这个数组的元素有重复的？那该如何找到？
 * 
 */
public class S9_3 {

	public static void main(String[] args) {
		for (int i = 0; i < 1000; i++) {
			int size = AssortedMethods.randomIntInRange(5, 20);
			int[] array = getDistinctSortedArray(size);
			int v2 = findMagicIndexBS(array, 0, array.length-1);
//			System.out.println(findMagicIndex(array, 0));
			if (v2 == -1 && findMagicIndex(array, 0) != -1) {
				int v1 = findMagicIndex(array, 0);
				System.out.println("Incorrect value: index = -1, actual = " + v1 + " " + i);
				System.out.println(AssortedMethods.arrayToString(array));
				break;
			} else if (v2 > -1 && array[v2] != v2) {
				System.out.println("Incorrect values: index= " + v2 + ", value " + array[v2]);
				System.out.println(AssortedMethods.arrayToString(array));
				break;
			}
		}
	}
	
	public static int findMagicIndex(int[] A, int start){
		if(start >= A.length){
			return -1;
		}
		
		if(A[start] == start){
			return start;
		}
		
		return findMagicIndex(A, start+1);
	}
	
	// 在没有重复递增的数组中找到Magic index
	public static int findMagicIndexBS(int[] A, int low, int high){
		if(low > high){
			return -1;
		}
		int mid = low + (high-low)/2;
		if(A[mid] == mid){		// 找到了
			return mid;
		}
		if(A[mid] < mid){			// 要在右侧找
			low = mid+1;
		}else{						// 要在左侧找
			high = mid - 1;
		}
		
		return findMagicIndexBS(A, low, high);
	}
	
	/* Creates an array that is distinct and sorted */
	private static int[] getDistinctSortedArray(int size) {
		int[] array = AssortedMethods.randomArray(size, -1 * size, size);
		Arrays.sort(array);
		for (int i = 1; i < array.length; i++) {
			if (array[i] == array[i-1]) {
				array[i]++;
			} else if (array[i] < array[i - 1]) {
				array[i] = array[i-1] + 1;
			}
		}
		return array;
	}

}

这个是有重复元素的版本：

package Recursion;

import java.util.Arrays;

import CtCILibrary.AssortedMethods;

public class S9_3_2 {

	/* Creates an array that is sorted */
	public static int[] getSortedArray(int size) {
		int[] array = AssortedMethods.randomArray(size, -1 * size, size);
		Arrays.sort(array);
		return array;
	}
	
	public static void main(String[] args) {
		for (int i = 0; i < 1000; i++) {
			int size = AssortedMethods.randomIntInRange(5, 20);
			int[] array = getSortedArray(size);
			int v2 = findMagicIndexBS2(array, 0, array.length-1);
			if (v2 == -1 && magicSlow(array) != -1) {
				int v1 = magicSlow(array);
				System.out.println("Incorrect value: index = -1, actual = " + v1 + " " + i);
				System.out.println(AssortedMethods.arrayToString(array));
				break;
			} else if (v2 > -1 && array[v2] != v2) {
				System.out.println("Incorrect values: index= " + v2 + ", value " + array[v2]);
				System.out.println(AssortedMethods.arrayToString(array));
				break;
			}
		}
	}
	
	
	public static int findMagicIndexBS2(int[] A, int low, int high){
		if(low > high){
			return -1;
		}
		int mid = low + (high-low)/2;
		if(A[mid] == mid){		// 找到了
			return mid;
		}
		
		int index = -1;
		// 先搜索左侧，观察规律可发现可跳过一些数，直接从A[mid]开始往前
		index = findMagicIndexBS2(A, low, Math.min(mid-1, A[mid]));
		if(index == -1){
			index = findMagicIndexBS2(A, Math.max(mid+1, A[mid]), high);
		}
		
		return index;
	}

	public static int magicSlow(int[] array) {
		for (int i = 0; i < array.length; i++) {
			if (array[i] == i) {
				return i;
			}
		}
		return -1;
	}
}