Leetcode[二分查找] 思路清晰 33. 搜索旋转排序数组

审题

33. 搜索旋转排序数组
给你一个整数数组 nums ，和一个整数 target 。

该整数数组原本是按升序排列，但输入时在预先未知的某个点上进行了旋转。（例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] ）。

请你在数组中搜索 target ，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

 
示例 1：

输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4
示例 2：

输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1
示例 3：

输入：nums = [1], target = 0
输出：-1
 

提示：

1 <= nums.length <= 5000
-10^4 <= nums[i] <= 10^4
nums 中的每个值都 独一无二
nums 肯定会在某个点上旋转
-10^4 <= target <= 10^4

看到这道题，一时间头绪很少，因为这道题我们如果想要优化时间复杂度到$O(log(n))$的话，当然依旧是要用到二分查找。然而，这道题用传统的二分查找是不能够很快看出解法的（要不能叫中等题吗）。因此，我们看看这个数组的特点，可以知道，这道题的旋转可以看成是数组元素不断出队入队的过程，不过我们还是不能够用队列，因为时间复杂度的要求。

苦思冥想之后，我想到了一种可行的方法，也就是加一个分情况讨论，我们可以猜测这个数组有这样一个特点，因为只有一个位置的两侧是左侧元素大于右侧元素的，因此，我们把这两个元素同时出现的一侧叫做异常侧，而另一侧自然就是正常侧，基于只有一个旋转位置，我们可以知道异常侧的出现次数不可能大于1。

因此，我们代码实现如下：

代码实现

方案一（上文提到的的方法）：

我们判断正常侧的方法是nums[mid]>=nums[l]而对应的，如果不符合这个条件，那么就是右区间正常。

判断出了正常侧之后，我们根据两种情况分别决定区间右移或者左移，对于左区间正常的情况，我们只需要判断target是不是在左区间里就可以了，相对应地，对于右区间正常的情况，我们只需要判断target是不是在右区间里就可以了，如果不在，自然就是在另一个区间，以此类推，直到l>r或者mid=target。

然而，在这里有一个细节要注意，在这段判断代码中：nums[l] <= target && target < nums[mid]第一个条件的小于等于我最开始写的是小于，然而这样就会导致可能nums[l]明明是等于target，区间却向右缩小，因此要加等号。而后一个条件为什么不用加等号呢，因为即使target==nums[mid]，在后面无论如何我们也会用一个if去判断这个nums[mid]是否符合我们的要求的。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l=0, r=nums.size()-1, mid, flag=0;
        while ( l<=r ) {
            int tag = 0; // 右区间正常
            mid = l + (r-l)/2;
            if ( nums[mid] >= nums[l] ) tag=1; // 左区间正常
            if ( tag ) {
                if ( nums[l] <= target && target < nums[mid] ) {
                    r = mid - 1;
                } else {
                    l = mid + 1;
                } 
                if ( nums[mid] == target ) {
                    flag = 1;
                    break;
                }
            } else {
                if ( nums[r] >= target && target > nums[mid] ) {
                    l = mid + 1;
                } else {
                    r = mid - 1; 
                } 
                if ( nums[mid] == target ) {
                    flag = 1;
                    break;
                }
            }
            cout << mid << endl;
        }
        if ( flag ) return mid;
        else return -1;
    }
};

方案2：
看了官方题解，发现思路竟然是一样的…在此不做赘述了，习惯哪个用哪个方法就好。官方题解比较好的一点就是把mid放在最前面判断，最后直接return -1，代码比较清晰，可以学习。少用了个flag变量，稍作修改如下：

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l=0, r=nums.size()-1, mid;
        while ( l<=r ) {
            int tag = 0; // 右区间正常
            mid = l + (r-l)/2;
            if ( nums[mid] == target ) return mid;
            if ( nums[mid] >= nums[l] ) tag=1; // 左区间正常
            if ( tag ) {
                if ( nums[l] <= target && target < nums[mid] ) {
                    r = mid - 1;
                } else {
                    l = mid + 1;
                } 
            } else {
                if ( nums[r] >= target && target > nums[mid] ) {
                    l = mid + 1;
                } else {
                    r = mid - 1; 
                } 
            }
        }
        return -1;
    }
};

嗯，确实是清爽多啦！

反思

二分并不难，难的是细节，只有通过多做，才能够获取到经验与教训，作为提高篇的思想之一，需要多多练习去掌握，与你共勉。