旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{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

转载于:https://www.cnblogs.com/aiguozou/p/11536416.html