算法备忘录~二分法搜索旋转排序数组的元素

题目：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[left]，中值为nums[mid]

（1）：先判断nums[mid] 是否等于 target ，等于即返回true

（2）：若nums[left] == nums[mid]，说明存在重复元素的情况，此时默认缩小左边界，缩小幅度为1个元素，left++

（3）：nums[left] < nums[mid]  说明左半部分有序，那么此时要分情况看target是否在左半区间             ①：若target >= nums[left] && target < nums[mid],说明target在左半区间，                          那么right  = mid - 1,缩小右边界（注意：能进入这一判断说明target 不等于nums[mid]了，因此不加=号）；

         ②：否则就在右半区间，left = mid + 1,缩小左边界

（4）：若不满足（2）(3)条件，即nums[left] > nums[mid],说明右半部分有序，那么此时要分情况看target是否在右半区间 

        ①：若target > nums[mid] && target <= nums[mid],说明target在右半区间，                          那么left  = mid + 1,缩小左边界（注意：能进入这一判断说明target 不等于nums[mid]了，因此不加=号）；

        ②：否则就在左半区间，right  = mid - 1,缩小右边界

2.注意循环判断条件是left <= right,选取left == 0,right == nums.size() - 1初值左闭右闭，当left == right时依然要判断该值是否等于target

3.最终如果没找到返回false

举例说明：这篇题解举例说明的很好

第一类
10111 和 11101 这种。此种情况下 nums[left] == nums[mid]，分不清到底是前面有序还是后面有序，此时 left++ 即可。相当于去掉一个重复的干扰项。
第二类
2345671 这种，也就是 nums[left] < nums[mid]。此例子中就是 2 < 5；
这种情况下，左半部分有序。因此如果 nums[left] <=target<nums[mid]，则在前半部分找，否则去右半部分找。
第三类
6712345 这种，也就是 nums[start] > nums[mid]。此例子中就是 6 > 2；
这种情况下，右半部分有序。因此如果 nums[mid] <target<=nums[right]。则在右半部分找，否则去左半部分找。

代码实现：

bool search(vector<int>& nums, int target) {
        int left = 0,right = nums.size() - 1;
        while(left <= right)
        {
            
            int mid = (right - left)/2 + left;
            if(nums[mid] == target)
                return true;
            else if(nums[left] == nums[mid])
            {
                left ++;
            }
            else if(nums[left] < nums[mid]) //左半部分有序
            {
                //target在左半部分
                if(nums[left] <= target && target < nums[mid])
                    right = mid - 1;
                else//否则，去右半部分找
                    left = mid + 1;
            }
            else//右半部分有序
            {
                if(nums[mid] < target && target <= nums[right])//target在右半部分
                    left = mid + 1;
                else//否则，去左半部分找
                    right = mid - 1;
            }
        }
        return false;
    }

解决了这道题，可以顺道解决一下面试题 10.03. 搜索旋转数组

这道题是前一道的变种，若有多个相同元素，需要返回索引值最小的一个

因此用二分找到目标元素时，不能直接返回，而是要缩小右边界，直到找到最左边的目标值，返回时需要判断left是否已经超界或者是否找到目标值，当nums[0] == nums[right]时，说明左右两边相同，这时要缩小右边界，直到不再相同，贴出代码

int search(vector<int>& nums, int target) {
        int left = 0,right = nums.size() - 1;
        while(nums[0] == nums[right]) right--;//如果左右边界元素相同，则缩小右边界去除该元素
        while(left <= right)
        {
            
            int mid = (right - left)/2 + left;
            if(nums[mid] == target)
                right = mid - 1;
            else if(nums[left] == nums[mid])
            {
                left ++;
            }
            else if(nums[left] < nums[mid]) //前半部分有序
            {
                //target在前半部分
                if(nums[left] <= target && target < nums[mid])
                    right = mid - 1;
                else//否则，去后半部分找
                    left = mid + 1;
            }
            else//后半部分有序
            {
                if(nums[mid] < target && target <= nums[right])//target在后半部分
                    left = mid + 1;
                else//否则，去后半部分找
                    right = mid - 1;
            }
        }
        if(left >= nums.size() || nums[left] != target)    
            return -1;
        return left;
    }