Search in Rotated Sorted Array

题目

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.

思路

二分搜索

At first look, we know that we can do a linear search in O(n) time. But linear search does not need the elements to be sorted in any way.

First, we know that it is a sorted array that's been rotated. Although we do not know where the rotation pivot is, there is a property we can take advantage of. Here, we make an observation that a rotated array can be classified as two sub-array that is sorted (i.e., [4 5 6 7 0 1 2] consists of two sub-arrays [4 5 6 7] and [0 1 2].

Do not jump to conclusion that we need to first find the location of the pivot and then do binary search on both sub-arrays. Although this can be done in O(lg n) time, this is not necessary and is more complicated.

In fact, we don't need to know where the pivot is. Look at the middle element (7). Compare it with the left most (4) and right most element (2). The left most element (4) is less than (7). This gives us valuable information -- All elements in the bottom half must be in strictly increasing order. Therefore, if the key we are looking for is between 4 and 7, we eliminate the upper half; if not, we eliminate the bottom half.

When left index is greater than right index, we have to stop searching as the key we are finding is not in the array.

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

最新java

public class Solution {
    public int search(int[] nums, int target) {
        
        if(nums == null || nums.length == 0){
            return -1;
        }
        int left = 0;
        int right = nums.length-1;
        while(left <= right){
            int mid = left + (right-left)/2;
            if(nums[mid] == target){
                return mid;
            }
            if(nums[left]<=nums[mid]){
                if(nums[left]<=target && target<nums[mid]){
                    right = mid-1;
                } else {
                    left = mid+1;
                }
            } else {
                if(nums[mid]<target && target<=nums[right]){
                    left = mid+1;
                } else {
                    right = mid-1;
                }
            }
        }
        return -1;
    }
}

如果允许重复

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

查找 pivot：

This time you have to search for the rotation pivot. There is a subtle observation. This problem is in fact the same as finding the minimum element's index. If the middle element is greater than the right most element, then the pivot must be to the right; if it is not, the pivot must be to the left.

int FindSortedArrayRotation(int A[], int N) {
    int L = 0;
    int R = N - 1;

    while (A[L] > A[R]) {
        int M = L + (R - L) / 2;
        if (A[M] > A[R])
            L = M + 1;
        else
            R = M;
    }
    return L;
}