LeetCode—33.搜索旋转排序数组(Search in Rotated Sorted Array)——分析及代码（C++）

一、题目

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

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

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

你可以假设数组中不存在重复的元素。

你的算法时间复杂度必须是 O(log n) 级别。

示例 1:

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

示例 2:

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

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

二、分析及代码

1. 两次二分查找

（1）思路

根据题目信息（复杂度O(log n)，有序数组查找）：提示可以通过二分查找解决。
两次二分查找：
1）二分查找旋转位置；
2）在子序列中二分查找目标值。

（2）代码

class Solution {
public:
    int search(vector<int>& nums, int target) {
   		//特殊情况处理
        int isize = nums.size() - 1;
        if (isize == -1) return -1;
        if (isize == 1)
            if (target == nums[0])
                return 0;
            else if (target == nums[1])
                return 1;
            else
                return -1;
        //查找旋转位置
        int l = 0, r = isize;
        if (nums[l] > nums[r]) {
            while (r - l > 1) {
                int m = (l + r) / 2;
                if (nums[m] > nums[l])
                    l = m;
                else
                    r = m;
            }
            //确定目标区间
            if (target >= nums[0]) {
                l = 0;
                r--;
            }
            else {
                l = r;
                r = isize;
            }
        }
        //查找目标值
        while (l < r) {
            int m = (l + r) / 2;
            if (target > nums[m])
                l = m + 1;
            else
                r = m;
        }
 
        return (nums[l] == target) ? l : -1;
    }
};

（3）结果

执行用时 ：4 ms, 在所有 C++ 提交中击败了 91.26% 的用户；
内存消耗 ：8.7 MB, 在所有 C++ 提交中击败了 84.18% 的用户。

2. 极简解法

（1）思路

查看题解后，发现一种极简解法。

以二分搜索为基本思路，直接缩小区间，此时向左缩小区间有3种情况：
1）nums[0] < nums[mid]，且 nums[0] <= target <= nums[mid]（不包含旋转，target在左区间）；
2）nums[mid] < nums[0]，且 target <= nums[mid] < nums[0]（包含旋转，target在旋转位置到mid之间）；
3）nums[mid] < nums[0]0 - mid 包含旋转，且 nums[mid] < nums[0] <= target（包含旋转，target在0到旋转位置之间）。

其他情况向右缩小区间，即 nums[mid] < nums[0]，nums[0] > target，target > nums[mid] 三项或一项为真时向右缩小区间，可以采用异或操作。

（2）代码

class Solution {
public:
    int search(vector<int>& nums, int target) {
        if (nums.size() == 0) return -1;
        int l = 0, r = nums.size() - 1;
        while (l < r) {
            int m = (l + r) / 2;
            if (((nums[l] > nums[m]) ^ (nums[l] > target)) ^ (target > nums[m]))
                l = m + 1;
            else
                r = m;
        }
        return (nums[l] == target) ? l : -1;
    }
};

（3）结果

执行用时 ：8 ms, 在所有 C++ 提交中击败了 59.74% 的用户；
内存消耗 ：8.7 MB, 在所有 C++ 提交中击败了 84.18% 的用户。

三、其他

有序数组查找，或 O(logn) 复杂度，考虑二分查找等。