class Solution {
    public int search(int[] nums, int target) {
        // sanity check 
        if(nums == null || nums.length == 0) return -1;
        int left = 0;
        int right = nums.length - 1; 
        while(left <= right){ //  <=
            int mid = left + (right - left) / 2;
            if(nums[mid] == target) return mid;
            // right half is sorted
            if(nums[mid] < nums[right]){
                // if target is in between 
                if(target > nums[mid] && target <= nums[right]){ //  <=
                    left = mid + 1;
                }else{
                   // else
                    right = mid - 1;
                }
            }else{
                // left half is sorted
                if(target >= nums[left] && target < nums[mid]){ // >=
                    // target is in between 
                    right = mid - 1;
                }else{
                    left = mid + 1;
                }
            }
        }
        return -1;
    }
}

 

comment 的几个 等号 ，要注意为啥这么写

 

 

题目一看就知道是binary search。所以关键点在于每次要能判断出target位于左半还是右半序列。解这题得先在纸上写几个rotated sorted array的例子出来找下规律。Rotated sorted array根据旋转得多少有两种情况：

原数组：0 1 2 4 5 6 7
情况1：  6 7 0 1 2 4 5    起始元素0在中间元素的左边
情况2：  2 4 5 6 7 0 1    起始元素0在中间元素的右边

两种情况都有半边是完全sorted的。根据这半边，当target != A[mid]时，可以分情况判断：

当A[mid] < A[end] < A[start]：情况1，右半序列A[mid+1 : end] sorted
A[mid] < target <= A[end], 右半序列，否则为左半序列。

当A[mid] > A[start] > A[end]：情况2，左半序列A[start : mid-1] sorted
A[start] <= target < A[mid], 左半序列，否则为右半序列

Base case：当start + 1 = end时
假设 2 4:
A[mid] = A[start] = 2 < A[end]，A[mid] < target <= A[end] 右半序列，否则左半序列

假设 4 2:
A[mid] = A[start ] = 4 > A[end],  A[start] <= target < A[mid] 左半序列，否则右半序列

加入base case的情况，最终总结的规律是：

A[mid] =  target, 返回mid，否则

(1) A[mid] < A[end]: A[mid+1 : end] sorted
A[mid] < target <= A[end]  右半，否则左半。

(2) A[mid] > A[end] : A[start : mid-1] sorted
A[start] <= target < A[mid] 左半，否则右半。

 

http://bangbingsyb.blogspot.com/2014/11/leetcode-search-in-rotated-sorted-array.html

 

 

 

Suppose an array sorted in ascending order 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.

Your algorithm's runtime complexity must be in the order of O(log n).

Example 1:

Input: nums = [4,5,6,7,0,1,2], target = 0
Output: 4

Example 2:

Input: nums = [4,5,6,7,0,1,2], target = 3
Output: -1