leetcode:154. Find Minimum in Rotated Sorted Array II

Follow up for "Find Minimum in Rotated Sorted Array":
What if duplicates are allowed?

Would this affect the run-time complexity? How and why?

Suppose a sorted array is rotated at some pivot unknown to you beforehand.

(i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).

Find the minimum element.

The array may contain duplicates.

思路：先过滤重复元素，这是我目前能想到的方法，应该有更简便，以后再改进

public class Solution {
    public int findMin(int[] nums) {
        if(nums==null||nums.length==0)
            return 0;
        int start=0;
        int end=nums.length-1;
        int ret=nums[start+(end-start)/2];
        while(start<end){
            int startValue=nums[start];
            int endValue=nums[end];
            int i=start+1;
            while(nums[i]==startValue && i<end){
               i++;
            }
            start=i-1;
            
            i=end-1;
            while(nums[i]==endValue && i>start){
               i--;
            }
            end=i+1;
            /* 不能这样子乱跳，如 10 1 10 10 10 
            if(nums[start]==nums[mid]){
                start=mid;
                continue;
            }
            if(nums[mid]==nums[end]){
                end=mid;
                continue;
            }
            */
            int mid=start+(end-start)/2;
            //只有两个元素时
            if(mid==start){
                ret=ret<nums[mid]?ret:nums[mid];
                ret=ret<nums[end]?ret:nums[end];
                break;
            }

            
            //无折点---折点就是最小点   4 5 6 这种
            if(nums[start]<nums[mid]&&nums[mid]<nums[end]){
                return nums[start];
            }
            //无折点---折点就是最小点  6 5 4 这种
            if(nums[start]>nums[mid]&&nums[mid]>nums[end]){
                return nums[end];
            }
            //折点（最小点）在mid右边  4 5 6 7 0 1 2
            if(nums[start]<nums[mid]&&nums[mid]>nums[end])//
            {
                start=mid;//
            }
            //折点在mid左边  6 7 0 1 2 4 5
            if(nums[start]>nums[mid]&&nums[mid]<nums[end])//
            {
                end=mid;//不能是mid-1，不能把mid过滤了。如 3 1 3 这样
            }
        }
        return ret=ret<nums[end]?ret:nums[end];
    }
}

public class Solution {
    public int findMin(int[] nums) {
       return fimMin(nums,0,nums.length-1);
    }
    public int fimMin(int[] nums,int start ,int end){
         if(nums==null||nums.length==0)
            return 0;

        int ret=nums[start+(end-start)/2];
        while(start<end){
            int mid=start+(end-start)/2;
            //只有两个元素时
            if(mid==start){
                ret=ret<nums[mid]?ret:nums[mid];
                ret=ret<nums[end]?ret:nums[end];
                break;
            }
            /* 不能这样子乱跳，如 10 1 10 10 10 */
            if(nums[start]==nums[mid] || nums[mid]==nums[end]){
                int left=fimMin(nums,start,mid);
                int right=fimMin(nums,mid+1,end);
                ret=ret<left?ret:left;
                ret=ret<right?ret:right;
                return ret;
                
            }

            //无折点---折点就是最小点   4 5 6 这种
            if(nums[start]<nums[mid]&&nums[mid]<nums[end]){
                return nums[start];
            }
            //无折点---折点就是最小点  6 5 4 这种
            if(nums[start]>nums[mid]&&nums[mid]>nums[end]){
                return nums[end];
            }
            //折点（最小点）在mid右边  4 5 6 7 0 1 2
            if(nums[start]<nums[mid]&&nums[mid]>nums[end])//
            {
                start=mid;//
            }
            //折点在mid左边  6 7 0 1 2 4 5
            if(nums[start]>nums[mid]&&nums[mid]<nums[end])//
            {
                end=mid;//不能是mid-1，不能把mid过滤了。如 3 1 3 这样
            }
        }
        return ret=ret<nums[end]?ret:nums[end];
    }
}