leetcode【81】Search in Rotated Sorted Array II

问题描述：

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

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

You are given a target value to search. If found in the array return true, otherwise return false.

Example 1:

Input: nums = [2,5,6,0,0,1,2], target = 0
Output: true

Example 2:

Input: nums = [2,5,6,0,0,1,2], target = 3
Output: false

Follow up:

• This is a follow up problem to Search in Rotated Sorted Array, where nums may contain duplicates.
• Would this affect the run-time complexity? How and why?

源码：

这题和33题几乎一摸一样leetcode【33】Search in Rotated Sorted Array。就使用一种改进的分治法找。但是需要多加考虑的就是相等的情况，因为有重复元素，我想了很久，也没找到规律，最后直接遍历了。加了不少复杂度。空间上还是100%，毕竟也没开辟啥新的空间。时间上50%左右。试了几次都不一样。

class Solution {
public:
     bool find_index(vector<int>& nums, int left, int right, int target){
        if(left>right)     return false;
        // cout<<left<<" "<<right<<endl;
        int med = (left + right) / 2;
        // cout<<med<<endl;
        if(nums[med] == target)  return true;
        if(nums[med]<nums[right]){
            if(nums[med]<target && target<=nums[right])
                left = med+1;
            else
                right = med-1;
        }
        else if(nums[med]>nums[right]){
            if(nums[left]<=target && target<nums[med])
                right = med-1;
            else
                left = med+1;
        }
        else{
            int tmp=0;
            for(int j=med; j<=right; j++)
                if(nums[j]!=nums[med]){
                    left = med+1;
                    tmp = 1;
                    break;
                }
            if(tmp==0)  right = med-1;
        }
        return find_index(nums, left, right, target);
    }
    bool search(vector<int>& nums, int target) {
        int N = nums.size();
        if(N==1)    return nums[0]==target? true:false;
        return find_index(nums, 0, N-1, target);
    }
};

我在网上找了一些方法，发现都是大同小异，比如这个，他也就是每次遇到相等的时候right--。时间复杂度没有质的改变。

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

还有一种从两头开始找的方法，貌似效果很好，空间上100%，时间上98.31%，非常规做法，感觉了解一哈就可。

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