力扣81. 搜索旋转排序数组 II----部分有序也可二分

81. 搜索旋转排序数组 II

已知存在一个按非降序排列的整数数组 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
-104 <= nums[i] <= 104
题目数据保证 nums 在预先未知的某个下标上进行了旋转
-104 <= target <= 104
 

进阶：

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

题解：

方法一：憨憨方法–复原数组再二分

原先看到题目标签是二分于是想也没想强行使用二分，后来发现复杂度还不如直接遍历。。。

代码：

bool search(int* nums, int numsSize, int target){
    int*arr = (int*)malloc(sizeof(int)*numsSize);
    if(numsSize==1)
    {
        if(nums[0]==target)
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }
    int i = 1;
    int temp;
    while(i!=numsSize)
    {
        if(nums[i]>=nums[i-1])
        {
            i++;
            continue;
        }
        else
        {
            temp = i;
            break;
        }
    }

    int top = 0;
    for(int i=temp;i<numsSize;i++)
    {
        arr[top++] = nums[i];
    }

    for(int i=0;i<temp;i++)
    {
        arr[top++] = nums[i];
    }

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

    return 0;
}

方法二：憨憨方法2----找到断点，分别二分

我们可以遍历找到断点位置，然后对前面的有序序列和后面的有序序列分别二分查找即可。

方法三：直接二分

注意，这道题中，数组本身不是有序的，进行旋转后只保证了数组的局部是有序的，这还能进行二分查找吗？答案是可以的。

我们可以直接二分，但是在查找的过程中与传统二分并不相同**，因为二分的本质还是要在有序序列中查找**，因此我们在求得mid后需要比对一下左右边界来判断一下其在被分割成的左右两个序列中哪个有序。找到后在有序序列中再进行查找。

需要注意的是，由于此题会出现元素相等的状况，因此可能出现对于数组中有重复元素的情况，二分查找时可能会有 a[left] = a[mid] = a[right]，因此为了避免这种情况，我们只能将当前二分区间的左边界加一，右边界减一，然后在新区间上继续二分查找。

注意的是除了找到哪个区间有序在哪个区间比较之外，如果target在该有序区间内，那么我们根据题意动left或right即可；若不在该有序区间内，我们需要动left或right来让我们的有序区间偏移到另一个本来不有序的区间内。

并且注意由于给定数组的特殊性导致其只可能在一个序列中有序。

代码：

bool search(int* nums, int numsSize, int target){
    if (numsSize == 0)
    {
        return false;
    }
    if (numsSize == 1) 
    {
        return nums[0] == target;
    }
    int left = 0;
    int right = numsSize-1;
    int mid;
    while(left<=right)
    {
        mid = right-(right-left)/2;
        if(nums[mid]==target)
        {
            return 1;
        }
        if(nums[left]==nums[mid]&&nums[mid]==nums[right])
        {
            left++;
            right--;
            continue;
        }
        if(nums[mid]>=nums[left])
        {
            if(nums[mid]>target&&target>=nums[left])
                right=mid-1;//说明此时target在给定的有序区间内
            else
                left=mid+1;
        }
        else
        {
            if(nums[mid]<target&&target<=nums[right])
                left=mid+1;
            else
                right=mid-1;
        }
    }
    return 0;
}