力扣33. 搜索旋转排序数组（二分查找）

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为
[nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …,
nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为
[4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的索引，否则返回 -1
。

示例 1：

输入：nums = [4,5,6,7,0,1,2], target = 0 输出：4 示例 2：

输入：nums = [4,5,6,7,0,1,2], target = 3 输出：-1 示例 3：

输入：nums = [1], target = 0 输出：-1

提示：

1 <= nums.length <= 5000
-10^4 <= nums[i] <= 10^4 nums 中的每个值都 独一无二 nums 肯定会在某个点上旋转
-10^4 <= target <= 10^4

进阶：你可以设计一个时间复杂度为 O(log n) 的解决方案吗？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1. 解题思路：
   //变种二分查找
   //循环数组的性质,可以以数组中间点划分成一个有序数组和一个循环数组。
   //若起始数小于中间划分值,说明是一个有序数组,否则是一个循环数组
   //如果要查找的数在有序数组中，则使用二分查找即可，否则继续划分数组边界

class Solution {
    //变种二分查找
    //循环数组的性质,可以以数组中间点划分成一个有序数组和一个循环数组。
    //若起始数小于中间划分值,说明是一个有序数组,否则是一个循环数组
    //如果要查找的数在有序数组中，则使用二分查找即可，否则继续划分数组边界
public:

    int binarySearch(vector<int>& nums,int low,int high,int target)
    {
        while(low <= high)
        {
            int mid = low + ((high - low)>>1);
            if(target < nums[mid])
            {
                high = mid - 1;
            }
            else if(target > nums[mid])
            {
                low = mid + 1;
            }
            else
            {//找到了
                return mid;
            }
        }
        return -1;
    }

    int search(vector<int>& nums, int target) {

        int low = 0,high = nums.size()-1;
        while(low <= high)
        {
            int mid = low + ((high - low)>>1);
            if(nums[low] <= nums[mid])
            {//有序
                if(target >= nums[low] && target <= nums[mid])
                {
                    return binarySearch(nums,low,mid,target);
                }
                else
                {
                    low = mid + 1;
                }
            }
            else 
            {//循环数组
                if(target >= nums[mid] && target <= nums[high])
                {
                     return binarySearch(nums,mid,high,target);
                }
                else
                {
                    high = mid - 1;
                }
            }

        }
        return -1;

       

    }
};