LeetCode——81. 搜索旋转排序数组 II(Search in Rotated Sorted Array II)[中等]——分析及代码（Java）

一、题目

已知存在一个按非降序排列的整数数组 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：

输入：nums = [2,5,6,0,0,1,2], target = 0
输出：true

示例 2：

输入：nums = [2,5,6,0,0,1,2], target = 3
输出：false

提示：

• 1 <= nums.length <= 5000
• -10^4 <= nums[i] <= 10^4
• 题目数据保证 nums 在预先未知的某个下标上进行了旋转
• -10^4 <= target <= 10^4

进阶：

• 这是 搜索旋转排序数组 的延伸题目，本题中的 nums 可能包含重复元素。
• 这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、分析及代码

1. 二分查找

（1）思路

根据数组特点，可进行两次二分查找，第一次找到数组旋转前的首尾位置，第二次在对应区间内查找目标值。

（2）代码

class Solution {
    public boolean search(int[] nums, int target) {
        if (nums.length == 0)
            return false;
        
        //求出旋转位置
        int n = nums.length, l = 0, r = n - 1, posi = r;//[0,posi]为一部分，[posi+1, n-1]为另一部分
        while (l < r && nums[r] == nums[0])
            r--;
        if (r > 0 && nums[0] >= nums[n - 1]) {//数组中间存在旋转位置
            while (l < r) {
                int m = (l + r + 1) >> 1;
                if (nums[m] >= nums[0])
                    l = m;
                else
                    r = m - 1;
            }
            posi = l;
        }

        //寻找目标值
        if (target > nums[posi])
            return false;
        if ((posi == n - 1 && target < nums[0]) || (posi < n - 1 && target < nums[posi + 1]))
            return false;
        if (target == nums[0])
            return true;
        if (target > nums[0])
            return binSearch(nums, 0, posi, target);
        return binSearch(nums, posi + 1, n - 1, target);
    }

    //二分查找
    public boolean binSearch(int[] nums, int l, int r, int target) {
        while (l < r) {
            int m = (l + r) >> 1;
            if (nums[m] < target)
                l = m + 1;
            else
                r = m;
        }
        return (nums[l] == target);
    }
}

（3）结果

执行用时 ：1 ms，在所有 Java 提交中击败了 88.78% 的用户；
内存消耗 ：38.4 MB，在所有 Java 提交中击败了 21.40% 的用户。

三、其他

暂无。