搜索旋转排序数组

搜索旋转排序数组

解法：二分查找

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 。

对于数组 0,1,2,3,4,5,6
旋转后的结果一共有一下7种：

中间数比最右边数小，右边部分有序

• 0,1,2, 3,4,5,6
• 6,0,1, 2,3,4,5
• 5,6,0, 1,2,3,4
• 4,5,6, 0,1,2,3
• 中间数比最右边数大，左边部分有序
• 3,4,5,6 ,0,1,2
• 2,3,4,5 ,6,0,1
• 1,2,3,4 ,5,6,0
  通过判断目标数是否在有序区间内，从而进行二分查找，代码如下：

/**
 *
 *  搜索旋转排序数组
 *
 * https://leetcode-cn.com/problems/search-in-rotated-sorted-nums/
 *
 * 整数数组 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 。
 *
 * 中间数比最右边数小，右边部分有序
 * 0,1,2, 3,4,5,6
 * 6,0,1, 2,3,4,5
 * 5,6,0, 1,2,3,4
 * 4,5,6, 0,1,2,3
 *
 * 中间数比最右边数大，左边部分有序
 * 3,4,5,6 ,0,1,2
 * 2,3,4,5 ,6,0,1
 * 1,2,3,4 ,5,6,0
 *
 * @author fengyurong
 * @date 2021-10-28 5:36 PM
 */
public class SearchRotateArray {

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(resolve(new int[]{3,4,5,6 ,0,1,2}, i));
        }
    }

    public static int resolve(int[] nums, int target) {
        int begin = 0;
        int end = nums.length - 1;
        int mid = (end - begin) / 2 + begin;
        while(begin <= end) {
            if(nums[mid] == target) {
                return mid;
            }
            //判断有序区间在左边还是在右边
            if(nums[mid] < nums[end]) {
                if(nums[mid] < target && nums[end] >= target) {
                    begin = mid + 1;
                } else {
                    end = mid - 1;
                }
            } else{
                if(nums[mid] > target && nums[begin] <= target) {
                    end = mid - 1;
                } else {
                    begin = mid + 1;
                }
            }
            mid = (end - begin) / 2 + begin;
        }
        return -1;
    }
}

时间复杂度：O(log(n))
空间复杂度：O(log(n))

进阶：已知存在一个按非降序排列的整数数组 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,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。给你 旋转后 的数组 nums 和一个整数 target ，请你编写一个函数来判断给定的目标值是否存在于数组中。如果 nums 中存在这个目标值 target ，则返回 true ，否则返回 false 。

由于存在相同的数字，使用上述代码不能准确判断，目标值在左还是右边，比如：1,1,1,1,1,1,1,1,1,13,1,1,1,1,1,1,1,1,1,1,1,1。其中nums[begin] == nums[end] = nums[mid]。此时如果 nums[mid] 与 nums[begin] 相等，移动begin++，如果 nums[mid]和 nums[end] 相等，移动end–来缩减范围。此时时间复杂度最坏为O(n)，相当于挨个遍历数组。

 * 搜索旋转排序数组
 * <p>
 * https://leetcode-cn.com/problems/search-in-rotated-sorted-nums/
 * <p>
 * 整数数组 nums 按升序排列，数组中的值 互不相同 。
 * <p>
 * 在传递给函数之前，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] 。
 * <p>
 * 给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。
 * <p>
 * 中间数比最右边数小，右边部分有序
 * 0,1,2, 3,4,5,6
 * 6,0,1, 2,3,4,5
 * 5,6,0, 1,2,3,4
 * 4,5,6, 0,1,2,3
 * <p>
 * 中间数比最右边数大，左边部分有序
 * 3,4,5,6 ,0,1,2
 * 2,3,4,5 ,6,0,1
 * 1,2,3,4 ,5,6,0
 *
 * @author fengyurong
 * @date 2021-10-28 5:36 PM
 */
public class SearchRotateArray {

    public static void main(String[] args) {
        System.out.println(resolve1(new int[]{1,1,1,1,1,1,1,1,1,13,1,1,1,1,1,1,1,1,1,1,1,1}, 13));
    }

    /**
     * 有重复的元素怎么办？会提高复杂度吗
     *
     * @param nums
     * @param target
     * @return
     */
    public static boolean resolve1(int[] nums, int target) {
        int begin = 0;
        int end = nums.length - 1;
        int mid = (end - begin) / 2 + begin;
        while (begin <= end) {
            if (nums[mid] == target) {
                return true;
            }
            if(nums[mid] == nums[begin]) {
                begin++;
                //判断有序区间在左边还是在右边
            }else if(nums[mid] == nums[end]) {
                end--;
            } else if(nums[mid] < nums[end]) {
                if (nums[mid] < target && nums[end] >= target) {
                    begin = mid + 1;
                } else {
                    end = mid - 1;
                }
            } else {
                if (nums[mid] > target && nums[begin] <= target) {
                    end = mid - 1;
                } else {
                    begin = mid + 1;
                }
            }
            mid = (end - begin) / 2 + begin;
        }
        return false;
    }
}