旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。

思路

采用二分法来查找
- 使用两个指针分别指向数组的第一个元素和最后一个元素(lo,hi)
- 中间元素(mid)>=前面的元素(lo) 说明前面递增 mid=lo
- 中间元素(mid)<=后面的元素(lo) 说明后面递增 mid=hi
- 两只指针距离是1,
表明第一个指针指向第一个递增子数组的末尾,
第二个指针指向第二个递增子数组的开头,
第二个子数组的第一个数就是最小的数组
因此hi就是我们查找的结果
但是这里面有一些陷阱：
　　1.如果数组的全部元素都旋转,即 旋转后的数组就是原数组，则最小数字是第一个数字
　　2.中间数字与首尾数字大小相等，如{1,0,1,1,1,1}和{1,1,1,1,0,1}，无法采用二分法，只能顺序查找。

实现

public int Min(int arr[]) {
	if (arr == null || arr.length <= 0) {
		return 0;
	}
	int lo = 0;
	int hi = arr.length - 1;
	int mid = lo;
	//如果数组的全部元素都旋转,即 旋转后的数组就是原数组
	//此时第一个数字就是最小的数字,可以直接返回,这也是mid初始值是lo的原因
	while (arr[lo] >= arr[hi]) {
		if (hi - lo == 1) {
			mid = hi;
			break;
		}
		mid = (lo + hi) / 2;
		//解决陷阱2
		if (arr[lo] == arr[hi] && arr[hi] == arr[mid]) {
			return minInOrder(arr, lo, hi);
		}
		if (arr[mid] >= arr[lo]) {
			lo = mid;
		} else if (arr[mid] <= arr[hi]) {
			hi = mid;
		}

	}
	return arr[mid];
}
private int minInOrder(int[] arr, int lo, int hi) {
	int result = arr[lo];
	for (int i = lo + 1; i <= hi; i++) {
		if (result > arr[i]) {
			result = arr[i];
		}
	}
	return result;
}

测试用例

public void test01() {
	//1,2,3,4,5
	int[] ints = {3, 4, 5, 1, 2};
	int i = Min02(ints);
	System.out.println("test01:" + i);
}

public void test02() {
	//0,1,1,1,1
	int[] ints = {1, 0, 1, 1, 1};
	int i = Min02(ints);
	System.out.println("test02:" + i);
}

输出

test01:1
test02:0