递增数组旋转后找最小值

递增数组旋转array，即把前N项挪到后面。

示例{1，2，3，4，5}变为{3，4，5，1，2}

可以通过一次扫描得到分界点，时间复杂度O（n）；

更快捷的方法即可考虑二分查找：

由于数组分成了两块，可以用两个标示符标识两部分；

如：用i标识{3，4，5}这一块，j标识{1，2}这一块，即令i = 0，j = length -1；

接下来可二分查找分界点，令mid = （i+j）/2.

条件分析：

若mid〉i说明分界点在mid右侧，可将左边界i移至mid处缩小范围。

若mid〈i说明分界点在mid左侧或者就是该mid点，可将右边界移至j处缩小范围。

mid=i需单独分析：

若mid = i，则可以将mid相邻且与mid相等的点视为一个整体，即可将mid向左移至与i不等（前提是mid〉=i）：

如{1，3，0，1，1，1，1，1，1}，mid=4，array[mid]=1即可使mid--，至array[mid]！=array[i]，此时mid=2，array[mid]=0，此时可按上述条件进行操作。

当mid移至array[mid]！=array[i]时共有两种情况：

array[mid]〈array[i]，如上例所示；

也有可能为array[mid]〈array[i]，如{1，2，1，1，1}，此时mid刚好越过分界线，即分界点序号为mid-1；

若情况为{1，1，1}则mid移至i处，条件为mid==i，即可返回array[0]。

递归结束的条件：

由于i，j始终处于两个不同的块上并且一直缩小，最终会有i+1==j；既判断结束的条件为：i与j相邻。

边界分析：当数组长度为1时，结果显而易见；长度为2时，无需判断mid值，直接比较array[i]与array[j]；

JAVA代码：

public class Main {
	private int[] array ;

	public int searchMin(int[] array) {
		this.array = array;
		int n = array.length;
		if (n <= 0)
			return -1;
		if (n == 1)
			return array[0];
		return array[binarySearch(n, 0, n - 1)];
	}

	public int binarySearch(int n, int i, int j) {
		if (i + 1 == j) {
			if (array[i] < array[j])
				return i;
			else
				return j;
		}
		int mid = (i + j) / 2;
		if (array[mid] < array[i]) {
			return binarySearch(n, i, (i + j) / 2);
		} else if (array[mid] > array[j - 1]) {
			return binarySearch(n, mid, j);
		} else {
			while (mid > 0 && array[mid] == array[mid - 1])
				mid--;
			if (mid == 0)
				return mid;
			if(array[mid]>array[i])return mid+1;
			return binarySearch(n, i, mid);
		}
	}

	public static void main(String[] args) {
		Main m = new Main();
		int[] array = new int[] { 3, 5, 8, 1, 2 };
		System.out.println(m.searchMin(array));
	}
}

边界分析：当数组长度为1时，结果显而易见，