旋转数组的最小数字

public int minNumberInRotateArray (int[] nums) {
        int m = minNumberInRotateArray2(nums);
        return nums[m];
    }

    public int minNumberInRotateArray2 (int[] nums) {
        int s = 0,e = nums.length-1;
        int m = 0;
        while(s < e){
             m = (s+e) / 2;
            if(nums[m] > nums[e]){
                s = m+1;
            }else if(nums[m] < nums[e]){
                e = m;
            }else{
                e--;
            }
        }
        return s;
    }

    public int minNumberInRotateArray1 (int[] nums) {
        int m = minNumberInRotateArray1_1(nums,0,nums.length-1);
        return nums[m];
    }

    public int minNumberInRotateArray1_1 (int[] nums,int s,int e) {
        if(s >= e) return s;
        int m = (s+e)/2;
        int n1 = minNumberInRotateArray1_1(nums,s,m);
        int n2 = minNumberInRotateArray1_1(nums,m+1,e);
        if(nums[n1] < nums[n2])
            return n1;
        else
            return n2;
    }

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param nums int整型一维数组
     * @return int整型
     */
    public int minNumberInRotateArray (int[] nums) {
        // write code here
        // 整个问题本是上是在找数组中唯一存在的极小值，采取二分法解决

        // 算法的时间复杂度O(logN)，额外空间复杂度O(1)

        int n = nums.length;
        if (n == 1) {
            // 如果只有一个元素
            return nums[0];
        }
        if (n == 2) {
            // 如果只有两个元素
            return Math.min(nums[0], nums[1]);
        }
        // 确保有三个以上的元素
        int l = 0;
        int r = n - 1;

        // 采用二分思想，任务是找到这样一个转折点[↗……↗（↘index）↗……↗]，其特征是左边比它大，右边也比它大
        int min = nums[l];
        while (l < r) {
            // 因为数组非递减，且涉及到右划l
            // 所以采用一个变量min时刻与当前最左的l元素比较总不是坏事
            min = Math.min(min, nums[l]);
            int mid = (l + r) / 2;
            if (nums[l] > nums[mid]) {
                // 如果mid处比最左处要小，即[↗……↗（↘index）↗……mid……↗]，说明局部最小值一定在左半区（或mid本身）
                r = mid;
            } else if (nums[l] < nums[mid]) {
                // 如果mid处比最左处要大，即[↗……mid……↗（↘index）↗……↗]，说明局部最小值一定在右半区（必不包括mid）
                l = mid + 1;
            } else {
                // 如果mid处与最左处相等，即[-->……mid……-->（↘index）↗……-->]，或[-->……-->（↘index）↗……-->……mid……-->]，在左还是在右不能确定
                // 但是！至少说明l处一定不是极小值点，此时l往右移一位，缩小范围即可
                l++;
            }
        }

        return Math.min(min, nums[l]);
    }
}

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型一维数组 
     * @return int整型
     */
    public int minNumberInRotateArray (int[] nums) {
        // 这里可以将数组分解为两部分
        // 这两部分均为 从小到大排序的数组，以 12345 为例
        // 会有 34512、45123 等

        // write code here
        // 先来判断一下数组为空的情况
        if(nums.length == 0) {
            return 0;
        }

        // 使用二分法来解决
        int start = 0;
        int end = nums.length - 1;
        // 这里是旋转数组，先来考虑第一种情况
        // 当这里的第一个元素的值 比 最后一个元素的值小
        // 对于上面的例子，可以断定这里的第一个值 就一定是 最小值
        if(nums[start] < nums[end]) {
            return nums[start];
        }

        // 之后通过 二分法来判断最小值
        // 先来说明没有重复值的情况
        // 不断的通过 左、右 侧加逼 
        // 最终会使得 start 在左侧部分的最大值(最后一个位置) 上
        // 并且会使得 end 在右侧部分上达到其中的 最小值(这个就是我们需要的值)
        // 此时 start 和 end 就是一个相邻的关系，所以对于 while 设定这样一个判断条件
        while(start != end-1) {
            int mid = (start + end) / 2;
            // 在这之中还需要处理多个重复数据的情况，并且处理三个指针重叠后的情况
            // 如题例：1,0,1,1,1
            if(nums[start] == nums[end] && nums[start] == nums[mid]) {
                // 这里定义一个方法专门来处理这个问题
                return minNum(nums,start,end);
            }
            if(nums[mid] >= nums[start]) {
                start = mid;
            }else if(nums[mid] <= nums[end]){
                end = mid;
            }
        }
        // 在完成上面的判断后，这里的 end 位置的值就是我们要找到的最小值
        return nums[end];
    }

    private int minNum(int[] nums, int start, int end) {
        // 这里需要注意的是，要将值设置为 当前重合处的值，不能设置为 0 ！！！
        int re = nums[start];
        for (int i=0; i < nums.length; i++) {
            if(re > nums[i]) {
                // 将这里的最小值记录下来并返回
                re = nums[i];
            }
        }
        return re;
    }
}

public int minNumberInRotateArray (int[] nums) {
        // write code here
        if(nums.length <= 0){
            return 0;
        }
        int rt = nums[0];
        for(int info : nums){
            if(rt > info){
                rt = info;
            }
        }
        return rt;
    }

不考虑二分是不是更快？

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型一维数组 
     * @return int整型
     */
    public int minNumberInRotateArray (int[] nums) {
        // write code here
        a(nums,0,nums.length-1);
        return nums[0];
    }
    public void a(int[] nums,int left,int right){
        if(left>=right)
            return;
        int mid=(left+right)/2;
        a(nums,left,mid);
        a(nums,mid+1,right);
        b(nums,left,mid,right);
    }
     public void b(int[] nums,int left,int mid,int right){
        if(nums[left]>nums[mid+1]){
            nums[left]=nums[mid+1];
        }
    }
}