【LeetCode】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.

【二分思路】

分情况讨论，数组可能有以下三种情况：

然后，再看每一种情况中，target在左边还是在右边，其中第一种情况还可以直接判断target有可能不在数组范围内。

【Java代码】

public class Solution {
    public int search(int[] A, int target) {
        int len = A.length;
        if (len == 0) return -1;
        return binarySearch(A, 0, len-1, target);
    }
    
    public int binarySearch(int[] A, int left, int right, int target) {
        if (left > right) return -1;
        
        int mid = (left + right) / 2;
        if (A[left] == target) return left;
        if (A[mid] == target) return mid;
        if (A[right] == target) return right;
        
        //图示情况一
        if (A[left] < A[right]) { 
            if (target < A[left] || target > A[right]) {    //target不在数组范围内
                return -1;
            } else if (target < A[mid]) {                   //target在左边
                return binarySearch(A, left+1, mid-1, target);
            } else {                                        //target在右边
                return binarySearch(A, mid+1, right-1, target);
            }
        } 
        //图示情况二
        else if (A[left] < A[mid]) { 
            if (target > A[left] && target < A[mid]) {      //target在左边
                return binarySearch(A, left+1, mid-1, target);
            } else {                                        //target在右边
                return binarySearch(A, mid+1, right-1, target);
            }
        } 
        //图示情况三
        else { 
            if (target > A[mid] && target < A[right]) {     //target在右边
                return binarySearch(A, mid+1, right-1, target);
            } else{                                         //target在左边
                return binarySearch(A, left+1, mid-1, target);
            }
        }
    }
}

下面是参考网上的思路，其中if (target == A[left]) 和 if (target == A[right]) 两个判断是我自己加上的，因为加上这两个判断后，下面分情况讨论时就不用考虑target等于边界的情况了。

public class Solution {
    public int search(int[] A, int target) {
        int len = A.length;
        if (len == 0) {
            return -1;
        } else if (len == 1) {
            return target==A[0] ? 0 : -1;
        }
        
        int left = 0, right = len-1;
        while (left < right) {
            int mid = left + (right-left)/2;
            if (target == A[mid]) {
                return mid;
            } else if (target == A[left]) {
                return left;
            } else if (target == A[right]) {
                return right;
            }
            
            //第一种情况中，target不在数组范围内
            if (A[left]<A[right] && (target<A[left] || target>A[right])) {
                return -1;
            }
            
            //第一、二种情况的左边，即连续上升的左边，且target在这段内
            if (A[left]<A[mid] && target>A[left] && target<A[mid]) {
                right = mid - 1;
                continue;
            }
            
            //第一、三种情况的右边，即连续上升的右边，且target在这段内
            if (A[mid]<A[right] && target>A[mid] && target<A[right]) {
                left = mid + 1;
                continue;
            }
            
            //如果上面情况都不满足，那么可能在第二种情况的右边
            if (A[mid] > A[right]) {
                left = mid + 1;
                continue;
            }
            
            //如果上面情况都不满足，第三种情况的左边
            if (A[left] > A[mid]) {
                right = mid - 1;
                continue;
            }
        }
        
        return -1;
    }
}

个人感觉还是自己那样写思路比较清晰。

2015/3/30更新

---

public class Solution {
    public int search(int[] A, int target) {
        int l = 0;
        int r = A.length - 1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (target == A[mid]) return mid;
            if (A[l] <= A[r]) {
                if (target < A[mid]) r = mid - 1;
                else l = mid + 1;
            } else if (A[l] <= A[mid]) {
                if (target > A[mid] || target < A[l]) l = mid + 1;
                else r = mid - 1;
            } else {
                if (target < A[mid] || target > A[r]) r = mid - 1;
                else l = mid + 1;
            }
        }
        return -1;
    }
}