33. Search in Rotated Sorted Array

Suppose a sorted array 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.

第一种是直接顺序查找，时间复杂度O（N）

class Solution {
public:
    int search(vector<int>& nums, int target) 
    {
        int i;
        for(i=0;i<nums.size();i++)
        {
            if(target==nums[i])
                return i;
        }
        return -1;
    }
};

第二种方法是类似二分查找，先找到旋转后左边升序序列的最后一个最大数的位置pivot，如果target大于第一个数，则在0~pivot中二分查找target，否则在pivot+1到最后一个位置查找。

class Solution {
public:
    int search(vector<int>& nums, int target) 
    {
        int left=0,right=nums.size()-1,pivot,result;
        if(nums[left]<nums[right])
            result=twodivide(nums,target,0,nums.size()-1);
        else
        {
            pivot=searchhelp(nums);
            if(target>=nums[left])
                result=twodivide(nums,target,left,pivot);
            else
                result=twodivide(nums,target,pivot+1,right);
        }
        return result;
    }
    int twodivide(vector<int>& nums,int target,int left,int right)
    {
        int mid;
        while(left<=right)
        {
            mid=(left+right)/2;
            if(nums[mid]==target)
                return mid;
            else if(nums[mid]<target)
                left=mid+1;
            else
                right=mid-1;
        }
        return -1;
    }
    int searchhelp(vector<int>& nums)
    {   
        int left=0;
        int right=nums.size()-1;
        while(left<right-1)
        {
            int mid=(left+right)/2;
            if(nums[mid]<nums[left]) 
                right=mid;
            else
                left=mid;       
        }
        return left;
    }
};

第三种方法也是类似二分法，看到别人写的，主要分三种情况，写的很简洁易懂

class Solution {
public:
    int search(vector<int>& nums, int target) 
    {
        int l=0,r=nums.size()-1,mid;
        while(l<=r)
        {
            mid=(l+r)/2;
            if(target==nums[mid])
                return mid;
            if(nums[l]<=nums[r])
            {
                if(nums[mid]>target)
                    r=mid-1;
                else
                    l=mid+1;
            }
            else if(nums[l]<=nums[mid])
            {
                if(target>nums[mid]||target<nums[l])
                    l=mid+1;
                else
                    r=mid-1;
            }
            else
            {
                if(target<nums[mid]||target>=nums[l])
                    r=mid-1;
                else
                    l=mid+1;
            }
        }
        return -1;
    }
};

第四种方法：
循环递增数组有这么一个性质：以数组中间元素将循环递增数组划分为两部分，则一部分为一个严格递增数组，而另一部分为一个更小的循环递增数组。
当中间元素大于首元素时，前半部分为严格递增数组，后半部分为循环递增数组；当中间元素小于首元素时，前半部分为循环递增数组；后半部分为严格递增数组。

class Solution {
public:
    int search(vector<int>& nums, int target) 
    {
        int l=0,r=nums.size()-1,mid;
        while(l<=r)
        {
            mid=(l+r)/2;
            if(target==nums[mid])
                return mid;
            else if(nums[l]<=nums[mid])//左边部分为有序数组
            {
                if(target>=nums[l]&&target<nums[mid])
                    r=mid-1;
                else
                    l=mid+1;
            }
            else//右边部分为有序数组
            {
                if(target>nums[mid]&&target<=nums[r])
                    l=mid+1;
                else
                    r=mid-1;
            }
        }
        return -1;
    }
};