题解 | #在旋转过的有序数组中寻找目标值# 这题虽然很简单，但需要重新做一下。边界感

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型vector 
     * @param target int整型 
     * @return int整型
     */
    /*
        二分法
        start  end mid
        while(start < end) {
            if (start < mid ) { // start 到mid是单调递增的
                if (target < mid) {
                    target就在start和mid之间
                    right = mid;
                } else {
                    target在 mid之后
                    left = mid;
                }
            } else {
                if (target > right) {
                    在mid左面。
                    right = mid;
                } else {
                    在mid右面
                    left = mid;
                    
                }
            }
        }
        
    */
    int search(vector<int>& nums, int target) {
        int len = nums.size();
        if (len == 0) {
            return -1;
        }
        int left = 0, right = len - 1;
        while(left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] == target) {
                return mid;
            }
            
            if (nums[left] <= nums[mid] ) { 
                /*
                   mid +1还是-1要注意的问题，如果target在当前mid的左面，要考虑[mid]和target的关系，
                   if(target == mid) {
                       right = mid;
                   }
                   但是这个上面已经做过约束了，所以要考虑left和targt的关系，也就是说，left是有可能等于target，
                   所以
                   [left] <= target && [mid] > target {
                       right = mid; right也可以等于mid - 1
                   } else {
                       left = mid + 1;
                   }
                */
                if (nums[left] <= target && nums[mid] > target) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            } else { // mid右面是有序递增的
                if(nums[mid] < target && target <= nums[right]) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
        }
        return -1;
        
    }
};