LeetCode第33题——search in rotated array的O(logn)解法

问题描述
Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

(i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]).

You are given a target value to search. If found in the array return its index, otherwise return -1.

You may assume no duplicate exists in the array.

Your algorithm’s runtime complexity must be in the order of O(log n).

Example 1:

Input: nums = [4,5,6,7,0,1,2], target = 0
Output: 4
Example 2:

Input: nums = [4,5,6,7,0,1,2], target = 3
Output: -1
解法思路
时间复杂度O(logn)很容易联想到二分查找。但此序列不是严格的递增或者递减序列，不能直接用。但可以利用二分查找，找到序列的旋转点，将序列分为两个单调递增的序列，再分别进行二分查找，总时间复杂度为O(logn)。此题注意二分查找的循环操作！
C++代码

class Solution {
public:
    int search(vector<int>& nums, int target) {
        //二分查找思想
        int n=nums.size();
        if(n==0) return -1;
        if(n==1)
        {
            if(nums[0]==target) return 0;
            else return -1;
        }
        if(n==2)
        {
            if(nums[0]==target) return 0;
            else if(nums[1]==target) return 1;
            else return -1;
        }
        int pivot=FindPivot(nums);
        int res1=-1,res2=-1;
        res1=BinarySearch(nums,0,pivot,target);
        if(pivot+1<n)
        {
            res2=BinarySearch(nums,pivot+1,n-1,target);
        }
        
        if(res1!=-1) return res1;
        else if(res2!=-1) return res2;
        else return -1;
       
    }
    int FindPivot(vector<int> &nums)
    {
        int n=nums.size();
        int left=0,right=n-1;
        while(left<right-1)
        {
            int a=(left+right)/2;
            if(nums[a]>nums[right])
            {
                left=a;
            }
            else
            {
                right=a;
            }
        }
        return left;
    }
    int BinarySearch(vector<int>&nums,int left,int right,int target)
    {
        int n=right-left+1;
        if(n==0) return -1;
        if(n==1)
        {
            if(nums[left]==target) return left;
            else return -1;
        }
        if(n==2)
        {
            if(nums[left]==target) return left;
            else if(nums[right]==target) return right;
            else return -1;
            
        }
        while(left<right-1)//当left和right相邻的时候跳出
        {
            int a=(left+right)/2;
            if(nums[a]<target)
            {
                left=a;
            }
            else if(nums[a]>target)
            {
                right=a;
            }
            else return a;
        }
        //与最后相邻的left和right比较，避免遗漏
        if(nums[left]==target) return left;
        else if(nums[right]==target) return right;
        else return -1;
    }
};

算法结果
Runtime: 4 ms, faster than 100.00% of C++ online submissions for Search in Rotated Sorted Array.
Memory Usage: 8.8 MB, less than 98.94% of C++ online submissions for Search in Rotated Sorted Array.