【JAVA】二分查找&【Leetcode】33. 搜索旋转排序数组

1.题目

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 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

进阶：你可以设计一个时间复杂度为 O(log n) 的解决方案吗？

2.解决思路

   这个算法最重要的地方在于如何把旋转后无序的数组整合成有序的数组，然后运用二分法进行查找元素。一开始想到的是用遍历找出旋转的位置，再将数组划分为两个区域进行二分查找，也尝试使用了这个方法编写代码，于是就有了代码部分的第一份代码，后来感觉代码过于赘余，并且时间复杂度达到O(n)，就尝试进行优化,于是就有第二份的代码。

3.优化思路

因为nums[0]大于右区域的每一个元素，于是利用nums[0]的特性与target比较大小确定target所在区域，再通过二分查找的原理进行查找，省去了遍历环节，减小时间复杂度

4.代码和测试类

//第一份代码，运用遍历+二分查找，复杂度为O(n)
public class Rotate {
    public class Solution {
        public int search(int[] nums, int target) {
            int t1 = 0;
            int t2 = 0;
            for (int i = 0; i < nums.length-1; i++) {
                if (nums[i]>nums[i+1]){
                    t1 = i+1;
                    t2   = i;
                }
            }
            int start = 0;
            int end   = t2;

            /*难点：划分区域
            之前的二分法都不存在越界的问题
            需要对start <= end条件进行转化
            目前start == i+1;
            end == i;
            可以理解为到到达边界时跳回下标为0位置

             */
            while (start <= end){
                int mid = start + (end - start)/2;
                if (nums[mid] == target){
                    return mid;
                }else if (nums[mid] < target){
                    start = mid+1;
                }else if (nums[mid] > target){
                    end = mid -1;
                }
            }
            start = t1;
            end   = nums.length-1;

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

//第二份代码，运用二分查找，减小了时间复杂度
public class Rotate {
    public class Solution {
        public int search(int[] nums, int target) {
            int start = 0;
            int end   = nums.length-1;
            while (start <= end){
                int mid = start +(end-start)/2;
                if (nums[mid] == target){
                    return mid;
                }else if (nums[mid] >= nums[0]){
                    if(nums[mid]>target&&target>=nums[0]){
                        end = mid -1;
                    }else{
                        start = mid +1;
                    }
                }else{
                    if (nums[mid]< target&&target<=nums[nums.length-1]){
                        start = mid +1;
                    }else {
                        end = mid -1;
                    }
                }
            }
            return -1;
        }
    }
}

//测试类
public class Application {
    public static void main(String[] args) {
        int[] nums = {5,1,3};
        Rotate rotate = new Rotate();
        Rotate.Solution solution = rotate.new Solution();
        System.out.println(solution.search(nums,5));

    }
}