【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<) return -;
         int index=;
         for(int i=;i<n;i++){
             if(A[i-]>A[i]){
                 index=i;
                 break;
             }
         }
         int left,right;
         if(target>=A[]&&target<=A[index-]){
             left=;
             right=index-;
         }else if(target>=A[index]&&target<=A[n-]){
             left=index;
             right=n-;
         }else
             return -;
         while(left<=right){
             int mid=(left+right)/;
             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-;
             }else{
                 right--;
                 left=mid+;
             }
         }
         return -;
     }
 };