LeetCode

Search in Rotated Sorted Array II

2013.12.26 20:07

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.

Solution1:

　　First comes the link to the old original problem: Search in Rotated Sorted Array.

　　The first solution wasn't quite satisfactory, with a time complexity of O(n). First we find out the rotation offset with O(n) time, and do a rotated binary search with another O(log(n)) time. Space complexity is O(1).

Accepted code:

// 1AC, simple variation of binary search, even simpler
class Solution {
public:
    bool search(int A[], int n, int target) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        int offset;
        
        if(A == nullptr || n <= 0){
            return false;
        }
        
        for(offset = 0; offset < n; ++offset){
            if(A[offset] > A[(offset + 1) % n]){
                break;
            }
        }
        
        int left, mid, right;
        
        offset = (offset + 1) % n;
        left = offset;
        right = n - 1 + offset;
        while(left <= right){
            mid = (left + right) / 2;
            if(target < A[mid % n]){
                right = mid - 1;
            }else if(target > A[mid % n]){
                left = mid + 1;
            }else{
                return true;
            }
        }
        
        return false;
    }
};

Solution2:

　　Think about this case: [2, 2, 2, 2, 0, 2, 2]

　　If we apply the previous O(log(n)) solution from the original problem, there will be a problem:

　　　　1. left = 0;

　　　　2. right = 6;

　　　　3. mid = 3;

　　　　4. A[left] == A[mid], A[mid] == A[right]

　　　　Then, how do I find out the rotation offset using bi-search if I'm unable to decide which path to go next?

　　Thus we can apply binary search on an interval only when it is strictly ascending, use linear search otherwise.

　　Time complexity is between O(log(n)) and O(n), space complexity is O(1).

Accepted code:

// 1AC, not as efficient, but good solution
class Solution {
public:
    bool search(int A[], int n, int target) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        int offset;
        
        if(A == nullptr || n <= 0){
            return false;
        }
        
        int left, mid, right;
        
        left = 0;
        right = n - 1;
        while(left <= right){
            mid = (left + right) / 2;
            // normal binary search cannot deal with cases like this
            // [2, 2, 0, 0, 2, 2, 2]
            if(A[left] < target && target < A[mid]){
                right = mid - 1;
            }else if(A[mid] < target && target < A[right]){
                left = mid + 1;
            }else{
                if(A[left] == target){
                    return true;
                }else{
                    ++left;
                }
                if(A[right] == target){
                    return true;
                }else{
                    --right;
                }
            }
        }
        
        return false;
    }
};