[leetcode]81. Search in Rotated Sorted Array II

题目链接：https://leetcode.com/problems/search-in-rotated-sorted-array-ii/#/description

 

 

Follow up for "Search in Rotated Sorted Array":
What if duplicates are allowed?

Would this affect the run-time complexity? How and why?

 

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).

Write a function to determine if a given target is in the array.

The array may contain duplicates.

 

最终版

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

            else if(nums[mid] > nums[left])
            {
                if(nums[mid] > target && nums[left] > target)
                    left = mid + 1;
                else if(nums[mid] > target && nums[left] < target)
                    right = mid - 1;
                //else if(nums[mid] < target && nums[left] > target)
                else if(nums[mid] < target && nums[left] < target)
                    left = mid + 1;
 
            }

            else if(nums[mid] < nums[left])
            {
                if(nums[mid] > target && nums[left] > target)
                    right = mid - 1;
                //else if(nums[mid] > target && nums[left] < target)
                else if(nums[mid] < target && nums[left] > target)
                    left = mid + 1; 
                else if(nums[mid] < target && nums[left] < target)
                    right = mid - 1;
            }
            else if(nums[mid] == nums[left])
            {
                left ++;
            }
        }
        return target==nums[left]?left:-1;
    }

};

 

 

class Solution {
public:
    /**
     * @param A: an integer ratated sorted array and duplicates are allowed
     * @param target: An integer
     * @return: a boolean 
     */
    bool search(vector<int> &A, int target) {
        // write your code here
        
        if(A.empty()) return false;
        
        int l=0,r=A.size()-1,mid=0;
        while(l<=r)
        {
            mid=l+(r-l)/2;
            if(A[l]==target || A[r]==target || A[mid]==target)
            {
                return true;
            }
            else if(A[mid]==A[l])  //importance
            {
                l++;
            }
            else if(A[A.size()-1]>A[0] && A[mid]>target)
            {
                r=mid-1;
            }
            else if(A[A.size()-1]>A[0] && A[mid]<target)
            {
                l=mid+1;
            }
            else if(A[mid]>=A[0] && A[mid]>target && target<=A[A.size()-1])
            {
                l=mid+1;
            }
            else if(A[mid]>=A[0] && A[mid]>target && target>A[A.size()-1])
            {
                r=mid-1;
            }
            else if(A[mid]>=A[0] && A[mid]<target && target>A[A.size()-1])
            {
                l=mid+1;
            }
            else if(A[mid]<A[0] && A[mid]<target && target>A[0])
            {
                r=mid-1;
            }
            else if(A[mid]<A[0] && A[mid]<target && target<A[0])
            {
                l=mid+1;
            }
            else if(A[mid]<A[0] && A[mid]>target && target<A[0])
            {
                r=mid-1;
            }
            
        }
        return false;
    }
};

 

 

 

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


            }
            else if(nums[mid]<nums[left])
            {
                if(nums[mid]>target && nums[left]>target)
                    right=mid-1;
                //else if(nums[mid]>target && nums[left]<target) // bu cun zai
                else if(nums[mid]<target && nums[left]>target)
                    left=mid+1;
                else if(nums[mid]<target && nums[left]<target)
                    right=mid-1;


            }
            else if(nums[mid]==nums[left])
                left++;
        }
        return target==nums[left]?true:false;
    }
};

 

 

 

 

 

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

        }
        return nums[lo] == target ? true : false;
    }
};