Leetcode 33. 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.

---

解题思路：

高频题。

binary search 的本质就是每次扔掉一部分。只要确定答案不在这一部分，就扔掉这一部分。

与Leetcode Find Minimum in Rotated Sorted Array  Leetcode Find Minimum in Rotated Sorted Array II 是一个类型的题目。

用binary search，Complexity: O(logn), 关键点在于每次要能判断出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] 左半，否则右半。

方法一： recursive, 方法二： iterative, 对recursive 的简单改写。

---

Java code :
1. recursive

public class Solution {
    public int search(int[] nums, int target) {
        return binarySearch(nums, 0, nums.length-1, target);
    }
    
    public int binarySearch(int[] nums, int left, int right, int target){
        if(left > right) {
            return -1;
        }
        int mid = left + (right - left)/2;
        if(target == nums[mid]){
            return mid;
        }
        if(nums[mid] < nums[right]) { //right half sorted
            if(nums[mid] < target && target <= nums[right]){
                return binarySearch(nums, mid+1, right, target); 
            }else {
                return binarySearch(nums, left, mid-1, target); 
            }
        }else { //left half sorted
            if(nums[left] <= target && target < nums[mid]){
                return binarySearch(nums, left, mid-1, target); 
            }else{
                return binarySearch(nums, mid+1, right, target); 
            }
        }
    }    
}

2. iterative

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

3. 九章算法答案，画图解决，理解binary search 的本质，就是每次扔掉一部分。2016.01.15

public class Solution {
    public int search(int[] nums, int target) {
        if(nums == null || nums.length == 0) {
            return -1;
        }
        int start = 0, end = nums.length-1;
        int mid;
        while(start + 1 < end){
            mid = start + (end - start) / 2;
            if(nums[mid] == target) {
                return mid;
            }
            if(nums[start] < nums[mid]){
                if(nums[start] <= target && target <= nums[mid]){
                    end = mid;
                } else {
                    start = mid;
                }
            } else {
                if(nums[mid] <= target && target <= nums[end]){
                    start = mid;
                } else {
                    end = mid;
                }
            }
        }//while
        if(nums[start] == target){
            return start;
        }
        if(nums[end] == target){
            return end;
        }
        return -1;
    }
}

---

Reference:

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

2. http://www.programcreek.com/2014/06/leetcode-search-in-rotated-sorted-array-java/