刷题之搜索旋转排序数组（leetcode）

搜索旋转排序数组

时间复杂度O(n)的版本：
直接把数组分为有序的两个数组，然后分别进行双指针查找。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l=0;
        int r=nums.size()-1;

        while(l<nums.size()-1&&nums[l+1]>nums[l])
        {
            l++;
        }
        int mid=l;
        l=0;
        r=nums.size()-1;

        int left=find(nums,l,mid,target);
        int right=find(nums,mid+1,r,target);
        if(left!=-1)
            return left;
        if(right!=-1)
            return right;
        return -1;
    }
    int  find(vector<int>&nums,int l,int r,int target)
    {
        while(l<=r)
        {
            int mid=(r-l)/2+l;
            if(nums[mid]==target)
                return mid;
            else if(nums[mid]<target)
            {
                l=mid+1;
            }else
            {
                r=mid-1;
            }
        }
        return -1;
    }
};

时间复杂度为O(logn)的版本，先区分出有序的一部分，看target是否在这部分，否则再从无序到那部分中再区分有序的部分进行查找。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l=0;
        int r=nums.size()-1;

        while(l<=r)
        {
            int mid=(r-l)/2+l;
            if(nums[mid]==target)
                return mid;
            //如果左边(包括mid)是有序的
            if(nums[mid]>=nums[l])
            {
                //target在mid左边部分
                if(target>=nums[l]&&target<nums[mid])
                {
                    r=mid-1;
                }else//target不在左边部分
                {
                    
                    l=mid+1;
                }
            }
            else//右边部分是有序的
            {
                //target在mid右边部分
                if(target<=nums[r]&&target>nums[mid])
                {
                    l=mid+1;
                }else//target不在右边部分
                {
                    r=mid-1;
                }

            }
        }
        return -1;
    }
};