2020-10-15

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        //二分查找
        //1.给的数据是有序的
        //2.给的数据支持随机访问
        //这道题是一种特殊的二分查找，不知道mid的值应与那个target值比较，所以应与右端值先进性比较
        //自己的选择是与右端值比较
        //也可以选择与左端值比较
        if(rotateArray.size()==0)
        {
            return 0;
        }
        int left=0;
            //int right=(sizeof(rotateArray)/sizeof(rotateArray[0]))-1;
        int right=rotateArray.size()-1;
           // int mid=left+((right-left)/2);
        while(left<right)
        {
            //int left=0;
            //int right=(sizeof(rotateArray)/sizeof(rotateArray[0]))-1;
            //int mid=(left+(right+left))/2;
            if(rotateArray[left]<rotateArray[right])
            {
                //提前退出
                return rotateArray[left];
            }
            int mid=left+((right-left)/2);
           // 情况1，arr[mid] > target：4 5 6 1 2 3
//arr[mid] 为 6，target为右端点 3， arr[mid] > target, 说明[first ... mid] 
            //都是 >= target 的，
//因为原始数组是非递减，所以可以确定答案为 [mid+1...last]区间,所以 first = mid + 1 
            if(rotateArray[mid]>rotateArray[right])
            {
                left=mid+1;
            }
            //情况2，arr[mid] < target:5 6 1 2 3 4 arr[mid] 为 1，
             //target为右端点 4， arr[mid] < target, 说明答案肯定不在[mid+1...last]，
              //但是arr[mid] 有可能是答案,所以答案在[first, mid]区间，所以last = mid; 
            else if(rotateArray[mid]<rotateArray[right])
            {
                right=mid;
                
            }
           // 情况3，arr[mid] == target:
// 如果是 1 0 1 1 1， arr[mid] = target = 1, 显然答案在左边
   // 如果是 1 1 1 0 1, arr[mid] = target = 1, 显然答案在右边
   // 所以这种情况，不能确定答案在左边还是右边，
       // 那么就让last = last - 1;慢慢缩少区间，同时也不会错过答案。 
            else
            {
                right=right-1;
            }
         
        }
        return rotateArray[left];
    }
};

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组[3,4,5,1,2]为[1,2,3,4,5]的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。