【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有可能不在数组范围内。

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);
            }
        }
    }
}

 

我的解法，不是最优解

class Solution {
public:
    int search(int A[], int n, int target) {
        if(A==NULL||n<1) return -1;
        int index=0;
        for(int i=1;i<n;i++){
            if(A[i-1]>A[i]){
                index=i;
                break;
            }
        }
        int left,right;
        if(target>=A[0]&&target<=A[index-1]){
            left=0;
            right=index-1;
        }else if(target>=A[index]&&target<=A[n-1]){
            left=index;
            right=n-1;
        }else
            return -1;
        while(left<=right){
            int mid=(left+right)/2;
            if(target==A[left])
                return left;
            if(target==A[right])
                return right;
            if(target==A[mid])
                return mid;
            if(target>A[left]&&target<A[mid]){
                left++;
                right=mid-1;
            }else{
                right--;
                left=mid+1;
            }
        }
        return -1;
    }
};