（未实现）33. 搜索旋转排序数组——二分法

1.题目

33. 搜索旋转排序数组
升序排列的整数数组 nums 在预先未知的某个点上进行了旋转（例如， [0,1,2,4,5,6,7] 经旋转后可能变为 [4,5,6,7,0,1,2] ）。

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

 

示例 1：

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

输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1
示例 3：

输入：nums = [1], target = 0
输出：-1
 

提示：

1 <= nums.length <= 5000
-10^4 <= nums[i] <= 10^4
nums 中的每个值都 独一无二
nums 肯定会在某个点上旋转
-10^4 <= target <= 10^4

2.自我思路及实现

未AC
暴力解法一定可以，但过于简单，题目一定要求时间复杂度更低的算法
比遍历一次更简单的算法：ｌｏｇＮ的二分法
在二分法的判断中出现了问题

class Solution {
    public int search(int[] nums, int target) {
        if(nums == null || nums.length == 0)
            return -1;
        if(nums.length == 1)
            return nums[0] == target ? 0 : -1;

        int left = 0; 
        int right = nums.length - 1;

        while(left < right)
        {
            int mid = left + (right - left) / 2;
            if(nums[mid] < target)
            {
                if(nums[right] < target)
                    right = mid - 1;
                else
                    left = mid + 1;
            }
               
            else if(nums[mid] > target)
            {
                if(nums[left] > target)
                    left = mid + 1;
                else if(nums[left] < target)
                    right = mid - 1;
                else 
                    return left;

            }
            else
                return mid;
        }
        return -1;


    }
}

3.总结思路及实现

二分法

二分一定会将数组分为有序的一部分和错序的一部分,我们只需要判断target是否在有序的那部分，否则一定在无序的那部分，缩小区间
通过mid将数组分为三部分，mid, [left, mid - 1]和[mid+1, right]，当分为三部分时，循环条件为left <= right，这是因为搜索区间为[left, right]，循环跳出时left > right, 此区间为空，则找不到目标

通过判断nums[mid] 和 nums[0]的大小来确定哪个区间是有序的

• nums[mid] < nums[0]，那么[mid+1, right]是有序的，判断目标是否在此区间，若在，将区间缩为[mid+1, right]，若不在，将区间缩为[left, mid - 1]
• nums[mid] >= nums[0]，那么[left, mid - 1]是有序的，判断目标是否在此区间
• 此时要注意，因为我们选取中间角标是整数除法，即向下取整，当元素只有两个时，nums[mid] == nums[left]，
  此时若判断nums[mid] <= nums[0]，发现是成立的且循环结束，没有判断到nums[right]

class Solution {
    public int search(int[] nums, int target) {
        if(nums == null || nums.length == 0)
            return -1;
        if(nums.length == 1)
            return nums[0] == target ? 0 : -1;

        int left = 0; 
        int right = nums.length - 1;

        while(left <= right)
        {
            int mid = left + (right - left) / 2;
            if(nums[mid] == target)
                return mid;
            if(nums[mid] < nums[0])
            {
                if(nums[mid] < target && nums[right] >= target)
                    left = mid + 1;
                else
                    right = mid - 1;
            }
            else
            {
                if(nums[0] <= target && nums[mid] > target)
                    right = mid - 1;
                else
                    left = mid + 1;
            }
            
        }
        return -1;


    }
}

4.相关知识

• 整数除法为向下取整