一、旋转数组中的最小数字

题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小元素为1。

解法一：顺序查找，复杂度O(n)

var search = function(nums){
    var min = nums[0];
    for(var i=1;i<nums.length;i++){
        if(nums[i]<=min){
            min = nums[i];
        }
    }
    return min;
}

解法二：二分查找，复杂度O(logn)

var search = function(nums){
    var left = 0,
    right = nums.length-1,
    mid = 0;
    while(right-left > 1 && nums[right] <= nums[left]){
         mid = parseInt((left+right)/2);
         // 左区间是递增序列，最小元素在右区间
         if(nums[left]<=nums[mid]){
             left = mid;
         }
         // 右区间是递增序列，最小元素在左区间
         if(nums[mid]<=nums[right]){
             right = mid;
         }
     }
    return nums[right];
}

二、搜索旋转数组中的元素

题目：在旋转数组中搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。假定数组中没有重复元素。

思路：二分查找，复杂度O(logn)

参考https://leetcode-cn.com/problems/search-in-rotated-sorted-array/solution/ji-bai-liao-9983de-javayong-hu-by-reedfan/

取区间的中间值mid后：

1. 如果nums[mid] == target，直接返回mid值；
2. 如果nums[mid] >= nums[left]，说明左半区间是递增序列；如果target落在左半区间，则在左半区间内搜索，否则在右半区间内搜索
3. 如果nums[mid] <= nums[left]，说明右半区间是递增序列；如果target落在右半区间，则在右半区间内搜索，否则在左半区间内搜索

var search = function(nums,target){
    var left = 0,
        right = nums.length-1,
        mid = 0;
    if(nums.length == 0) return -1;
    while(right >= left){
        mid = parseInt((left+right)/2);
        if(nums[mid] == target) return mid;
        // 左半区间是递增序列
        if(nums[left] <= nums[mid]){
            if(nums[left] <= target && target < nums[mid]){
                right = mid-1;
            }else{
                left = mid+1;
            }
        }else{ //右半区间是递增序列
            if(nums[mid] < target && target <= nums[right]){
                left = mid+1;
            }else{
                right = mid-1;
            }
        }
    }
    return -1;
}

三、搜索旋转数组中的元素

题目：在旋转数组中搜索一个给定的目标值，如果数组中存在这个目标值，则返回true，否则返回false。数组中可能存在重复元素。

思路：二分查找，复杂度O(logn)

思路基本同上题，只是要考虑到[1,0,1,1,1] 和 [1,1,1,0,1]的情况：

1. 如果nums[mid] == target，直接返回mid值；
2. 如果nums[left] == nums[mid]，无法判断递增区间的位置，则需要将left++，去掉干扰元素；
3. 如果nums[mid] >= nums[left]，说明左半区间是递增序列；如果target落在左半区间，则在左半区间内搜索，否则在右半区间内搜索
4. 如果nums[mid] <= nums[left]，说明右半区间是递增序列；如果target落在右半区间，则在右半区间内搜索，否则在左半区间内搜索

var search = function(nums, target) {
    var left = 0,
    right = nums.length-1,
    mid = 0;
    if(nums.length == 0) return false;
    while(right >= left){
        mid = parseInt((left+right)/2);
        if(nums[mid] == target) return true;
        // 去掉重复项的干扰
        if(nums[left] == nums[mid]){
            left++;
            continue;
        }

        if(nums[left] <= nums[mid]){
            if(nums[left] <= target && target < nums[mid]){
                right = mid-1;
            }else{
                left = mid+1;
            }
        }else{
            if(nums[mid] < target && target <= nums[right]){
                left = mid+1;
            }else{
                right = mid-1;
            }
        }
    }
    return false;
};