33. Search in Rotated Sorted Array

题目：

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.

链接：https://leetcode.com/problems/search-in-rotated-sorted-array/#/description

4/14/2017

23ms，4%

注意：

第13行开始的情况不能简单的判断，整体被划分了3个区间。如果没有第9，10行的判断，就需要在第14，15行跟首尾比较时加上相等的情况。(!不是那么简单的，＝要在连续区间里，比如说按照下面的写法第14行不应该＝，第17行应该＝，原因是14行是2段区间，17行是连续的)

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

按照直观的写法：15ms, 58%。排除网络因素，为什么performance变化这么大？我做的改变：

1. 去掉了和lo，hi相等的判断，并且更改了第12行，15行的判断（没有大变化）

2. 将第12行，13行调整顺序（大变化，也许就是or --> and少判断一步的区别？）

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

别人相同思路，但是performance好很多，15ms，主要是最后第23行的判断

public int search(int[] A, int target) {
    if (A.length == 0) return -1;
    int lo = 0;
    int hi = A.length - 1;
    while (lo < hi) {
        int mid = (lo + hi) / 2;
        if (A[mid] == target) return mid;
        
        if (A[lo] <= A[mid]) {
            if (target >= A[lo] && target < A[mid]) {
                hi = mid - 1;
            } else {
                lo = mid + 1;
            }
        } else {
            if (target > A[mid] && target <= A[hi]) {
                lo = mid + 1;
            } else {
                hi = mid - 1;
            }
        }
    }
    return A[lo] == target ? lo : -1;
}

其他人的解法：

非常好的思路，将不合格的区间视为-inf, inf，不需要改值，但是可以以＝作为nums[mid]来判断。

https://discuss.leetcode.com/topic/34491/clever-idea-making-it-simple

https://discuss.leetcode.com/topic/34467/pretty-short-c-java-ruby-python

int search(vector<int>& nums, int target) {
    int lo = 0, hi = nums.size();
    while (lo < hi) {
        int mid = (lo + hi) / 2;
        
        double num = (nums[mid] < nums[0]) == (target < nums[0])
                   ? nums[mid]
                   : target < nums[0] ? -INFINITY : INFINITY;
                   
        if (num < target)
            lo = mid + 1;
        else if (num > target)
            hi = mid;
        else
            return mid;
    }
    return -1;
}

更多讨论：

https://discuss.leetcode.com/category/41/search-in-rotated-sorted-array

4/25/2017

算法班

思路
用二分法，判断target的区间。

用这个方法来做这道题！
如果A[mid] > A[start]并且target在它们之间，往前找。否则往后找。注意后面还是一个Sorted Array！
如果A[mid] < A[end]并且target在它们之间，往后找。否则往前找。注意前面还是一个Sorted Array！

public class Solution {
    /** 
     *@param A : an integer rotated sorted array
     *@param target :  an integer to be searched
     *return : an integer
     */
    public int search(int[] A, int target) {
        // write your code here
        if (A == null || A.length == 0) return -1;
        
        int start = 0, end = A.length - 1;
        
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (A[mid] == target) return mid;
            else if (A[start] < A[mid]) {
                if (A[start] <= target && target < A[mid]) {
                    end = mid;
                } else {
                    start = mid;
                }
            } else {
                if (A[mid] < target && target <= A[end]) {
                    start = mid;
                } else {
                    end = mid;
                }
            }
        }
        if (A[start] == target) return start;
        if (A[end] == target) return end;
        return -1;
    }
}