【LeetCode】搜索旋转排序数组【两次二分】

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -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

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array

分析：时间复杂度要求是O（log N）,原数组又是通过有序的数组变换得来的，所以我们可以联想到二分

先二分得到分割点k，分割点具有这样的特征:nums[k]>=nums[k+1]

找到了分割点k，我们可以得到两个区间:[0，k】，【k+1,n-1]

通过比较两个区间端点和target的大小关系，我们可以确定target位于两个区间中的哪一个

区间中的数肯定是有序的，这样我们可以在区间中继续通过二分来寻找target

总结：

两个二分，第一次寻找分割点，第二次寻找target

时间复杂度:O（log N）

空间复杂度:O（1）

class Solution {
public:
int search(vector<int>& v, int t)
{
    int k=-1;
    int n=v.size();
    if(n==0)
        return -1;
    if(n==1)
    {
        if(v[0]==t)
            return 0;
        else
            return -1;
    }

    int l,h;
    l=0;
    h=n-1;
    if(v[l]<v[h])//不存在分割点
    {
        k=-1;
    }
    else
    {
        while(l<=h)//寻找分割点
        {
            int mid=(l+h)/2;
            if(mid+1<=n-1&&v[mid]>v[mid+1])
            {
                k=mid;
                break;
            }
            else
            {
                if(v[mid]<v[l])
                    h=mid-1;
                else
                    l=mid+1;
            }
        }
    }
    //通过分割点确定target所属区间
    if(k==-1)
    {
        if(t>v[n-1])
            return -1;
        if(t<v[0])
            return -1;
        l=0;
        h=n-1;
    }
    if(t>v[n-1])
    {
        l=0;
        h=k;
    }
    else if(t<v[0])
    {
        l=k+1;
        h=n-1;
    }
    while(l<=h)//在区间中二分寻找target
    {
        int mid=(l+h)/2;
        if(v[mid]>t)
        {
            h=mid-1;
        }
        else if(v[mid]<t)
        {
            l=mid+1;
        }
        else if(v[mid]==t)
        {
            return mid;
        }
    }
    return -1;
}
};