LeetCode33：搜索旋转排序数组，java实现

题目：       

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

( 例如，数组 [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

思路：

        先用二分查找，找出左边升序和右边升序的分界点
        再判断出target在左边还是在右边，若target < nums[0],则在右边，target > nums[0]则在左边
        最后再用二分查找法找trget的位置，找不到则返回-1

代码：

class Solution {
    public int search(int[] nums, int target) {
        //特殊情况先判断
        if(nums.length == 0){
            return -1;
        }
        if (nums.length == 1){
            if (target == nums[0]){
                return 0;
            }else{
                return -1;
            }
        }
        //先用二分查找，找出左边升序和右边升序的分界点
        //再判断出target在左边还是在右边，若target < nums[0],则在右边，target > nums[0]则在左边
        //最后再用二分查找法找trget的位置，找不到则返回-1
        int left = 0;
        int right = nums.length-1;
        int mid = (left+right) / 2;
        int limit = -1;
        //找到分界线，注意mid,left,right不要越界
        while (left <= right && right >= 0 && limit == -1 && mid+1 < nums.length){
            if (nums[mid] > nums[mid+1] && nums[mid] >= nums[left]){//注意等号
                limit = mid;
                continue;
            }
            if(nums[mid] < nums[mid+1] && nums[mid] >= nums[left]){
                left = mid +1;
                mid = (left + right) / 2;
                continue;
            }
            if (nums[mid] < nums[mid+1] && nums[mid] < nums[right] && mid > 0){
                right = mid-1;
                mid = (left + right) / 2;
                continue;
            }
        }
        //若没有分界线，则limit没有被赋值，则limit为0
        if(limit < 0){
            limit = 0;
        }
        //特殊情况先判断
        if (target == nums[limit]){
            return limit;
        }
        if (target == nums[0]){
            return 0;
        }
        //若target < nums[0],去右边找，用二分法，target < nums[0]，一定是有分界的，所以只有一种情况
        if (target < nums[0]){
            int l = limit +1;
            int r = nums.length-1;
            int m = (l + r) / 2;
            while(l <= r){
                if (nums[m] == target){
                    return m;
                }
                if (nums[m] > target){
                    r = m-1;
                    m = (l + r) / 2;
                    continue;
                }
                if (nums[m] < target){
                    l = m+1;
                    m = (l + r) / 2;
                    continue;
                }
            }

        }
        //若target > nums[0],有两种情况：有分界，去分界的左边找，或者没分界，在整个范围找。
        // 两种情况用limit是否为0来区分
        if (target > nums[0]) {
            //limit >= 1，说明有分界线
            if (limit >= 1) {
                int l = 0;
                int r = limit - 1;
                int m = (l + r) / 2;
                while (l <= r) {
                    if (nums[m] == target) {
                        return m;
                    }
                    if (nums[m] > target) {
                        r = m - 1;
                        m = (l + r) / 2;
                        continue;
                    }
                    if (nums[m] < target) {
                        l = m + 1;
                        m = (l + r) / 2;
                        continue;
                    }
                }
            }else{//limit是0的情况，limit是0和不是0的情况下，l和r的初始值不一样
                int l = 0;
                int r = nums.length-1;
                int m = (l+r)/2;
                while(l <= r){
                    if (target == nums[m]){
                        return m;
                    }
                    if (target > nums[m]){
                        l = m +1;
                        m = (l+r)/2;

                    }
                    if (target < nums[m]){
                        r = m-1;
                        m = (l+r)/2;
                    }
                }
            }
        }
        return -1;

    }
}