搜索旋转排序数组 II

81. 搜索旋转排序数组 II

来源： LeetCode 81. 搜索旋转排序数组 II

题目描述

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

( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。

编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 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
进阶:

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

思路分析

直接来个排序，排序后二分搜索，对于小数据集一定可以跑过
不过我转念一想这和直接搜索有什么区别，笑哭

代码

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        if(nums.size() == 0) return false;
        sort(nums.begin(), nums.end());
        int l=0, r=nums.size() - 1;
        while(l < r){
            int mid = l +((r-l)>>1);
            if(nums[mid] < target) l = mid + 1;
            else r = mid;
        }
        return nums[l] == target ? true:false;
    }
};

算法分析

- 时间复杂度：O(nlgn)
- 空间复杂度：O(1)

代码改进

可不可以不用排序直接二分搜索
这道题是旋转排序数组的延伸
仍根据那道题的思路我们改变下二分查找指针的移动条件
大体思路我们仍然可以按照之前的处理
但我们主要需要考虑元素相同带来的一种特殊情况
[4,4,4,3,4] 与 [4,3,4,4,4] nums[0] = nums[mid] 这种特殊情况下 我们没法用二分法确定target = 3的所在
nums[mid] == nums[0] 时候我们回缩右边界 --j, 并判断 nums[j] 与 nums[mid] 的关系
i = 0，j = 4, mid = 2
nums[mid] == nums[0] --j -> j = 3
mid = 1
case 1 nums[mid] = 4 , nums[j] = 3 find
case 2 nums[mid] = 3 find
case 1 : same case 
在极端情况下O(n)

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        if(nums.size() == 0) return false;
        int l=0, r=nums.size() - 1;
        while(l < r){
            int mid = l +((r-l)>>1);
            if(nums[r] == target){
                l = r;
                break;
            }
            else if(nums[mid] == nums[0]) --r;
            else if((nums[mid] < target) ^ (nums[0] > target) ^ (nums[mid] < nums[0])) l = mid + 1; // 三个都成立或三个均不成立
            else r = mid; 
        }
        return nums[l] == target ? true:false;
    }
};

在考虑一种用分治法的情况，在nums[mid] == nums[0] 的时候
我们无法确定指针的移动，这时候我们可以选择缩小边界
分别判断nums[mid+1,r] 与 nums[l,mid]即可
但极端情况仍会退缩到O(n)

class Solution {
public:
    int search(vector<int>& nums, int target) {
        // 分段有序
        return nums.size() ? searchRecur(nums, 0, nums.size()-1, target) : false;
    }
    int searchRecur(vector<int>& nums,int l, int r, int target) {
        // 分段有序
        while(l<r){
            int mid = l + ((r-l)>>1);
            if(nums[mid] == nums[0]) return (searchRecur(nums, mid+1, r, target) || searchRecur(nums, l, mid, target)); // 分别判断两端
            if((nums[mid] < target) ^ (nums[0] > target) ^ (nums[mid] < nums[0])) l = mid + 1; // 三个都成立或三个均不成立
            else r = mid; 
        }
        return nums[l] == target ? true : false;
    }
};

相似扩展

• 相似题目
• 升级版本

归纳总结

二分查找要考虑许多情况