题目：

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.

===========================================

两种思路：

1（未思考：直接做，仔细考虑各种情况来分析）

package leetcode;

public class SearchinRotatedSortedArray {

public static int search(int[] nums, int target) {
        int index = -1;    
        if (nums.length < 1 || nums == null)
            return -1;
        if (nums.length == 1) {
            if (target == nums[0])
                return 0;
            return -1;
        }        
         if (target == nums[0]) {
            index = 0;
        } else if (target == nums[nums.length - 1]) {
            index =  nums.length - 1;
        }
        
        if(nums[0]<nums[nums.length-1]){
        
        index = Erfen(target,nums);
                
        }else{
        
        if (target < nums[0] && target > nums[nums.length - 1]) {
            index = -1;
        } else if (target > nums[0]) {
            int i = 0;
            while(nums[i]<=nums[i+1] && i < nums.length - 1){
                if(nums[i]==target){
                    index = i;
                    break;
                }
                i++;
            }if(target == nums[i]){
                index=i;
            }
            
        } else if (target < nums[nums.length - 1]) {
            int j = nums.length-1;
            while(nums[j-1]< nums[j] && j > 0){
                if(nums[j]==target){
                    index = j;
                    break;
                }
                j--;
            }
            if(target == nums[j]){
                index=j;
            }
            
        }
    }
        return index;
    }

public static int Erfen(int target, int[] array) {
        int left = 0;
        int right = array.length - 1;
        while (left < right-1 ) {
            int mid = left + (right - left) / 2;
            if(target >= array[mid]){
                left = mid;
            }else{
                right = mid;
            }
        }
        if(target == array[left]){
            return left;
        }else if(target == array[right]){
            return right;
        }else {
            return -1;
        }
    }

public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = { 3,4,5,6,7,8,9 };
        System.out.println(search(array,5)); 
    }
}

2（借鉴网络，思考后，在数组上设定左右标，利用二分法+递归）

思路：在整个数组中，先二分，找到有序的那一边然后在有序的一边判断是否含有target；如果没有，继续在无序的一半二分，在有序的一边查找

package leetcode;

public class newSearchinRotatedSortedArray {

public static int search(int[] nums, int target) {
    return search(nums,0,nums.length-1,target);
    }

public static int search(int[] nums, int left, int right, int target) {
        // TODO Auto-generated method stub
        if(left > right) return -1;
        
        int mid = (left+right)/2;
        //78123456
        if(nums[mid]==target){
            return mid;
        }
        if(nums[left]<=nums[mid]){
            if(target<=nums[mid]&&target>=nums[left]) {
                return search(nums,left,mid-1,target);                      //二分法加上“=”号！当使用二分法时，可以在每个判断大小的地方加“=”？
            }else{
                return search(nums,mid+1,right,target);
            }
        }else if(nums[mid]<=nums[nums.length-1]){
            if(target>=nums[mid]&&target<=nums[right]){
                return search(nums,mid+1,right,target);
            }else{
                return search(nums,left,mid-1,target);
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = { 7,8,9,3,4,5,6 };
        System.out.println(search(array,3)); 
    }
}