二分查找搜索旋转排序数组

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 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/search-in-rotated-sorted-array

示例

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

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

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

思路

1. 旋转排序的数组，查找数组中的target，且要求时间复杂度不超过O(log n),很容易想到使用二分查找。
2. 难点在于该数组并不是完全有序的，只是部分有序的。
3. 所以我们要找到这个数组的偏移量bias。
4. 如何找到这个数组偏移了多少？其实本质还是一个二分查找。
   二分查找其实并不一定用于查找某一个特定的数或值，同样适用于寻找满足某一性质的分界点，而这里我们要寻找的偏移其实就是nums[i] > nums[i+1]的地方,所以我们应该使用二分查找的方式来搜索那个前一个数大于后一个数的地方，这就是我们要寻找的分界点！

        int size = nums.size();
       //首先确定bias的值
       int bias;
       int fi = 0,fj =size;
       while(fi!=fj)
       {
           if(nums[(fi+fj)>>1]<=nums[fi])
           {
               fj = (fi+fj)>>1;
           }
           else{
               fi = (fi+fj)>>1;
           }
       }
   

5. 接下来就是对确定了分界点的数组再次进行一个二分查找，注意要对nums的部分数据进行取余操作
6. array： 4 5 6 7 0 1 2 4 5 6 7
   index： 0 1 2 3 4 5 6 7 8 9 10
   map_arr: 0 1 2 4 5 6 7
   array[(i+4)%7] == map_arr[i]
   ===
   完整代码

int search(vector<int>& nums, int target) {
    int size = nums.size();
        //首先确定bias的值
        int fi = 0,fj =size;
        while(fi!=fj)
        {
            if(nums[(fi+fj)>>1]<=nums[fi])
            {
                fj = (fi+fj)>>1;
            }
            else{
                fi = (fi+fj)>>1;
            }
        }
        int bias = fi+1;

        //进行2分查找
        int i = bias;
        int j = size+bias-1;
        while(i<j)
        {
            //特殊情况（懒得想怎么化简，就全写了）
            if(i == j-1&&nums[i%size]!=target&&nums[j%size]!=target)
            {
                return -1;
            }
            if(i == j-1&&nums[i%size]==target)
            {
                return i%size;
            }
            if(i == j-1&&nums[j%size]==target)
            {
                return j%size;
            }
            // 二分主体
            if(nums[((i+j)>>1)%size]>target)
            {
                j=(i+j)>>1 ;
            }
            if(nums[((i+j)>>1)%size]<target)
            {
                i = (i+j)>>1;
            }
            if(nums[((i+j)>>1)%size]==target)
            {
                return ((i+j)>>1)%size;
            }

        }
        if(nums.size()==1&&nums[0] == target)
        {
            return 0;
        }
        return -1;
    }