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) 的算法解决此问题。

示例 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

分析

对于两个有序的子数组拼接在一起，可以通过一次二分找到第二个数组的起始位置，然后分别对左数组和右数组二分寻找target。整体复杂度仍然是O(logn)。
注意判断边界。如果用r，要：r<右开区间边界 && 判断条件。

代码

class Solution {
public:
    int r_start;
    vector<int> q;
    int target;
    int q_n;
    int res;
    // 三次二分，先找分割数组位置，然后分别二分找target
    void bi_search_1() {
        int x = q[0]; // 找第一个比nums[0]小的数
        int l = -1, r = q_n;
        while(l+1 < r) {
            int mid = (l+r) >> 1;
            if (q[mid] < x) {
                r = mid;
            } else {
                l = mid;
            }
        }
        if (r < q_n && q[r] < q[0]) {r_start = r;}
        else {r_start = q_n; } // no r
    }
    void bi_search_2() {
        int l = -1, r = r_start;
        while(l+1 < r) {
            int mid = (l+r) >> 1;
            if (q[mid] >= target) {
                r = mid;
            } else {
                l = mid;
            }
        }
        if (r < r_start && q[r] == target) {
            res = r;
            return ;
        }
        l = r_start-1; r = q_n;
        while(l+1 < r) {
            int mid = (l+r) >> 1;
            if (q[mid] >= target) {
                r = mid;
            } else {
                l = mid;
            }
        }
        if (r < q_n && q[r] == target) {res = r; return ;}
        else {res = -1; return ;}
    }
    int search(vector<int>& nums, int target) {
        this->q = nums;
        this->q_n = nums.size();
        this->target = target;
        bi_search_1();
        bi_search_2();
        return res;
    }
};