[LeetCode]25. Search in Rotated Array旋转数组查找I

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.

解法1：顺序查找，时间复杂度O(n)。

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

解法2：旋转数组是分为两个有序数组，因此可以使用二分查找。若数组首元素小于数组尾元素，则数组没有旋转，直接使用二分查找binarySearch即可；否则（1）初始化left=0，right=n-1，取mid=(left+right)/2；（2）如果target==nums[mid]，则直接返回mid；否则若nums[left]<nums[mid]，说明nums[left, ..., mid-1]是有序的，而nums[mid+1, ... , n-1]是旋转的，对前者调用binarySearch，若没找到再对后者调用search；若nums[left]>nums[mid]，说明nums[left, ..., mid-1]是旋转的，而nums[mid+1, ... , n-1]是有序的，对后者调用binarySearch，若没找到再对前者调用search。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int n = nums.size();
        if (n < 2)
            return n == 1 ? (target == nums[0] ? 0 : -1) : -1;

        int res, left = 0, right = n - 1;
        if (nums[left] < nums[right])
            res = binarySearch(nums, left, right, target);
        else
        {
            int mid = (left + right) >> 1;
            if (target == nums[mid])
                res = mid;
            else if (nums[left] < nums[mid])
            {
                if ((res = binarySearch(nums, left, mid - 1, target)) == -1)
                {
                    vector<int> tmp(nums.begin() + mid + 1, nums.end());
                    res = search(tmp, target);
                    res = res == -1 ? -1 : res + mid + 1;
                }
            }
            else
            {
                if ((res = binarySearch(nums, mid + 1, right, target)) == -1)
                {
                    vector<int> tmp(nums.begin(), nums.begin() + mid);
                    res = search(tmp, target);
                }
            }
        }
        return res;
    }
private:
    int binarySearch(vector<int>& nums, int left, int right, int key)
    {
        if (left > right)
            return -1;

        int mid = (left + right) >> 1;
        if (key == nums[mid])
            return mid;
        else if (key > nums[mid])
            return binarySearch(nums, mid + 1, right, key);
        else
            return binarySearch(nums, left, mid - 1, key);
    }
};

上面的代码可以进一步优化。首先根据nums[mid]和nums[right]的关系可以确定数组的哪部分是有序的：如果中间的数小于最右边的数，则右半段是有序的，若中间数大于最右边数，则左半段是有序的。然后再根据有序部分首尾两个数字和target的大小关系来判断target存在于哪一部分。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int n = nums.size();
        int res = -1, left = 0, right = n - 1;
        
        while(left <= right)
        {
            int mid = (left + right) >> 1;
            if(target == nums[mid])
            {
                    res = mid;
                    break;
            }
            else if(nums[mid] < nums[right]) //后半部分有序
            {
                if(target > nums[mid] && target <= nums[right])
                    left = mid + 1;
                else
                    right = mid - 1;
            }
            else //前半部分有序
            {
                if(target >= nums[left] && target < nums[mid])
                    right = mid - 1;
                else
                    left = mid + 1;
            }
        }    
        return res;
    }
};

或者nums[mid]和nums[left]比较也可以，但是要注意mid=left的情况得单独拿出来讨论

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int n = nums.size();
        int res = -1, left = 0, right = n - 1;
        
        while(left <= right)
        {
            int mid = ((left + right) >> 1);
            if(target == nums[mid])
            {
                    res = mid;
                    break;
            }
            else if(nums[mid] > nums[left]) //前半部分有序
            {
                if(target >= nums[left] && target < nums[mid])
                    right = mid - 1;
                else
                    left = mid + 1;
            }
            else if(nums[mid] < nums[left]) //后半部分有序
            {
                if(target > nums[mid] && target <= nums[right])
                    left = mid + 1;
                else
                    right = mid - 1;
            }
            else //nums[mid]==nums[left]的情况，包括mid=left和存在重复值两种情况
                left++;
        }
        return res;
    }
};