Search in Rotated Sorted Array II

题目

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

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

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

思路

递归

class Solution {
public:
    bool search(int A[], int n, int target) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        return fun(A,0,n-1,target);
               
    }
    
    bool fun(int A[], int left, int right, int target)
    {
        if(left>right)
            return false;
        int mid = (left+right)/2;
        if(A[mid]==target)
            return true;
            
        if(A[left]<A[mid])  
        {  
            if(A[left]<=target && target<A[mid])  
                return fun(A,left,mid-1,target);  
            else  
                return fun(A,mid+1,right,target);
        }
        else if(A[left]>A[mid])   
        {  
                if(A[mid]<target && target<=A[right])  
                    return fun(A,mid+1,right,target);  
                else   
                    return fun(A,left,mid-1,target);     
            }  
        else
             return fun(A,left+1,right,target);
    }    
};

迭代

bool search(int A[], int n, int key) {
    int l = 0, r = n - 1;
    while (l <= r) {
        int m = l + (r - l)/2;
        if (A[m] == key) return true; //return m in Search in Rotated Array I
        if (A[l] < A[m]) { //left half is sorted
            if (A[l] <= key && key < A[m])
                r = m - 1;
            else
                l = m + 1;
        } else if (A[l] > A[m]) { //right half is sorted
            if (A[m] < key && key <= A[r])
                l = m + 1;
            else
                r = m - 1;
        } else l++;
    }
    return false;
}

 

代码三

public boolean search(int[] A, int left, int right, int target) {
      while (left <= right && left >= 0 && right < A.length) {
           int mid = (left + right) / 2;
           if (A[mid] == target)
                return true;
           if (A[left] == A[right]) {
                return search(A, left, mid - 1, target)
                          || search(A, mid + 1, right, target);
           }

           if (A[mid] >= A[left]) { // left is sorted
                if (target >= A[left] && target <= A[mid])
                     right = mid - 1;
                else
                     left = mid + 1;
           } else { // right is sorted
                if (target >= A[mid] && target <= A[right])
                     left = mid + 1;
                else
                     right = mid - 1;
           }
      }
      return false;

 }

 public boolean search(int[] A, int target) {
      return search(A, 0, A.length - 1, target);
 }