33.search in rotated sorted array leetcode java

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.

博主表示看题看了很久之后，找规律喽～ debug N久之后总算得到的正确的结果把自己都绕晕了～～

这是一道binary search的变体，总有一边是有序的～～

package leetcode2;

public class Search_in_Rotated {
   public static int search(int[] A, int target) {
        int location;      
        location=binarysearch(A,target,0,A.length-1);
        return location;
        
    }
   public static int binarysearch(int[] A, int target,int left,int right) {
      int mid=(int)(left+right)/2;
      if(A[mid]==target){
          return mid;
      }
      if(left<=right){
      if(target>A[mid]){
          if(A[mid]<A[right] && target<=A[right]){
              return binarysearch(A,target,mid+1,right); // 一定注意！！(mid+1,right)
          }else if(A[mid]>A[left]){
              return binarysearch(A,target,mid+1,right);  // (mid+1,right)
          }else{
              return binarysearch(A,target,left,mid-1);  //（left,mid-1）!!!
          }
      }
      if(target<A[mid]){
          if(A[mid]>A[left] && target>=A[left]){
              return binarysearch(A,target,left,mid-1);
          }else if(A[mid]<A[right]){
              return binarysearch(A,target,left,mid-1);
          }else{
              return binarysearch(A,target,mid+1,right);
          } 
      }
      }
      return -1;
   }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
      int[] a={2,3,4,5,7,0,1};
      System.out.println(search(a, 4));
    }

}

然后看了看别人的代码，博主表示自己真是too young too naive！！其实自己是在练习迭代是吧orz！QAQ

int rotated_binary_search(int A[], int N, int key) {
  int L = 0;
  int R = N - 1;
 
  while (L <= R) {
    // Avoid overflow, same as M=(L+R)/2
    int M = L + ((R - L) / 2);
    if (A[M] == key) return M;
 
    // the bottom half is sorted
    if (A[L] <= A[M]) {
      if (A[L] <= key && key < A[M])
        R = M - 1;
      else
        L = M + 1;
    }
    // the upper half is sorted
    else {
      if (A[M] < key && key <= A[R])
        L = M + 1;
      else 
        R = M - 1;
    }
  }
  return -1;
}