LeetCode

LeetCode - Search in Rotated Sorted Array

2013.12.14 18:29

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.

Solution1:

　　My first solution is to find the smallest element in the array first, and do an "offset" binary search.

　　Finding the smallest element requires O(n) time, the rotated binary search requires O(log(n)) time.

　　Thus time complexity is O(n), space complexity is O(1).

Accepted code:

// 1AC, simple variation of binary search
class Solution {
public:
    int 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 -1;
        }
        
        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 mid % n;
            }
        }
        
        return -1;
    }
};

Solution2:

　　Apparently you won't impress anyone with an O(n) solution when the data given is somewhat "sorted", right? Let's find out how to make it O(log(n)).

　　See the three examples below:

　　　　1 2 3 4 5 6 7

　　　　[7 1] 2 3 4 5 6

　　　　4 5 6 [7 1] 2 3

　　The three examples above are all rotated sorted array, rotated by 0, 1, 4 elements. For the latter two, the pair marked with "[]" is where the minimal element is followed by the maximal, that's where the pivot is. We're supposed to find it out using O(log(n)) time. Then do the binary search in an extra O(log(n)) time.

　　See the code below, time complexity is O(log(n)), space complexity is O(1).

Accepted code:

// 1AC, simple variation of binary search, time complexity O(log(n))
class Solution {
public:
    int 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 -1;
        }
        
        int left, mid, right;
        if(A[0] < A[n - 1]){
            offset = n - 1;
        }else{

            left = 0;
            right = n - 1;
            while(right - left > 1){
                mid = (left + right) / 2;
                if(A[left] > A[mid]){
                    right = mid;
                }else{
                    left = mid;
                }
            }
            offset = left;
        }

        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 mid % n;
            }
        }
        
        return -1;
    }
};

Solution 3:

　　The solution above is already O(log(n)) in time, but performed 2 binary searches, let's try do this in one pass.

　　Note that whenever you do a binary search, your goal is to limit the target within one interval, and shrink the size of interval with every iteration.

　　So we'll need a few more "if" statements to ensure that the target value doesn't run out of the searching scope.

　　Time complexity is O(log(n)), space complexity is O(1). This version of code is not very easy to understand, thus I'd still prefer the 2nd version, as simple code is easy to understand and maintain.

Accepted code:

// 1AC, simple variation of binary search, the code is not beautiful, though...
class Solution {
public:
    int 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 -1;
        }
        
        int left, mid, right;
        
        left = 0;
        right = n - 1;
        while(left <= right){
            mid = (left + right) / 2;
            if(A[left] <= A[right]){
                // the interval is already monotonous
                if(target < A[mid]){
                    right = mid - 1;
                }else if(target > A[mid]){
                    left = mid + 1;
                }else{
                    return mid;
                }
            }else{
                // the interval includes the 'pivot', containing two monotonous sub-array
                if(target < A[mid]){
                    if(target >= A[left]){
                        right = mid - 1;
                    }else{
                        if(A[mid] >= A[left]){
                            left = mid + 1;
                        }else{
                            right = mid - 1;
                        }
                    }
                }else if(target > A[mid]){
                    if(target <= A[right]){
                        left = mid + 1;
                    }else{
                        if(A[mid] >= A[left]){
                            left = mid + 1;
                        }else{
                            right = mid - 1;
                        }
                    }
                }else{
                    return mid;
                }
            }
        }
        
        return -1;
    }
};