LeetCode 33.搜索旋转排序数组

题目描述：
假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

你可以假设数组中不存在重复的元素。

你的算法时间复杂度必须是 O(log n) 级别。

示例 1:

输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4

示例 2:

输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1
这道题目有两种解法，一种是找出旋转点，另一种是不需要旋转点。都需要使用二分查找的思想，时间复杂度都是O(log n) 级别。
解法一：
该方法需要找出旋转点，比较容易累计理解一些。

/**
     * 给定一个排序后但是旋转过的数据，寻找 target 的 index，要求复杂度 O(log n)
     * 先找到旋转点，也就是最小值点
     * 将数组分为两个递增数组，根据边界条件的判断，来确定要在哪个数组区间内搜索 target
     *
     * @param nums
     * @param target
     * @return
     */
    public static int search(int[] nums, int target) {
        int n = nums.length;
        if (n == 0) return -1;
        if (n == 1) return nums[0] == target ? 0 : -1;

        int l = 0, r = n - 1, mid;
        while (r > l) {
            mid = (l + r) >>> 1;
            if (nums[mid] < nums[r]) r = mid;
            else l = mid + 1;
        }
        int min = l;
        if (min == 0) return binarySearch(nums, 0, n - 1, target);
        if (target >= nums[min] && target <= nums[n - 1]) {
            return binarySearch(nums, min, n - 1, target);
        } else {
            return binarySearch(nums, 0, min - 1, target);
        }
    }

    private static int binarySearch(int[] nums, int l, int r, int target) {
        int mid;
        while (r - l > 1) {
            mid = (l + r) >>> 1;
            if (nums[mid] == target) return mid;
            else if (nums[mid] > target) r = mid;
            else l = mid;
        }
        return nums[l] == target ? l : nums[r] == target ? r : -1;
    }

解法二：
来自于：LeetCode（33）：搜索旋转排序数组
解题思路：
这道题让在旋转数组中搜索一个给定值，若存在返回坐标，若不存在返回-1。我们还是考虑二分搜索法，但是这道题的难点在于我们不知道原数组在哪旋转了，我们还是用题目中给的例子来分析，对于数组[0 1 2 4 5 6 7] 共有下列七种旋转方法：

0　　1　　2　　 4　　5　　6　　7 #这种情况前半段和后半段都是有序的

7　　0　　1　　 2　　4　　5　　6

6　　7　　0　　 1　　2　　4　　5

5　　6　　7　　0　　1　　2　　4

4　　5　　6　　7　　0　　1　　2

2　　4　　5　　6　　7　　0　　1

1　　2　　4　　5　　6　　7　　0
0 　　1　　2　　4　　5　　6　　7 #这种情况前半段和后半段都是无序的，需要特殊处理。网上看到的很多方法对于这种用例通不过
二分搜索法的关键在于获得了中间数后，判断下面要搜索左半段还是右半段，我们观察上面红色加粗的数字都是升序的，由此我们可以观察出规律，如果中间的数小于最右边的数，则右半段是有序的，若中间数大于最右边数，则左半段是有序的，我们只要在有序的半段里用首尾两个数组来判断目标值是否在这一区域内，这样就可以确定保留哪半边了，代码如下

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int len = nums.size();
        int i = 0;
        int j  = nums.size()-1;
        if(len == 0)
            return j;
        if(target == nums[0]) return i;
        
        while(i <= j){
            int mid = (i+j) >> 1;
            if(nums[mid] == target)
                return mid;
            else if (nums[mid] > nums[i]){ //左半段有序
                if(target < nums[mid] && target >= nums[i]) //左半段有序，且target在左半段
                    j = mid -1;
                else //target在右半段
                    i = mid + 1; 
                
            }else if (nums[mid] < nums[j]){ //右半段有序
                if(target <= nums[j] && target > nums[mid]) //右半段有序，且target在右半段
                    i = mid + 1;
                else //target在左半段
                    j = mid - 1;
                    //j = mid==0?mid : mid-1;
            }else{ //数组逆序，如[3,2,1],此时左半段和右半段都无序
                i =  mid + 1;
            }    
        }
        return -1;
        
    }
};

参考文章：

1. 33.搜索旋转排序数组
2. LeetCode（33）：搜索旋转排序数组