leetcode 33. 搜索旋转排序数组

题目描述

整数数组 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,5,6,7]在下标3处经旋转后可能变为[4,5,6,7,0,1,2]。

给你旋转后的数组nums和一个整数target，如果nums中存在这个目标值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
• -10^4 <= target <= 10^4
• nums中的每个值都独一无二
• nums肯定会在某个点上旋转

题解

（一） 常规解法

按顺序遍历，从数组的第一个元素开始，找到target就返回索引，若遍历完数组还未找到，返回-1。

• 时间复杂度：$O(N)$，$N$为数组nums的大小。
• 空间复杂度：$O(1)$

（二） 二分查找

解题关键：常规的二分查找利用数组的有序性来调整查找范围。在本题中，有序数组经过旋转后虽然数组整体无序，但找到中间元素后，其左右两部分至少有一个是有序的，利用有序的一边来确定目标元素在左边还是右边。
例如：

nums = [5,6,7,8,9,11,0,1,3],target = 1

step1. 二分查找的范围为 l = 0, r = 8, mid = 4
step2. nums[mid] = 9 ≠ target,观察nums[mid]左边
step3. nums[l]<=nums[mid],nums[mid]左边部分有序,但target<nums[l],即不在左边部分
step4. l = mid + 1 = 5, mid = (l+r)//2 = 6,nums[mid] = 0 ≠ target,继续观察左右两边
step5. nums[l] > nums[mid],左边部分无序，则右边有序nums[mid]<=nums[l]
step6. nums[mid] < target = 1 < nums[r] ，即目标元素在右边部分
step7. l = mid + 1 = 7, mid = (l+r)//2 = 7, nums[mid] = 1 = target，找到目标元素,返回索引mid

完整的代码实现：

class Solution
{
public:
    int search(vector<int> &nums, int target)
    {
        int l = 0;
        int r = nums.size() - 1;
        int mid;
        while (l <= r)
        {
            mid = l + (r - l) / 2;
            if (nums[mid] == target)
                return mid;
            if (nums[l] <= nums[mid]) //若左边有序
            {
                if ((nums[l] <= target) && (target <= nums[mid]))//且目标元素在左边
                    r = mid - 1;//进入左边查找
                else//目标元素在右边
                    l = mid + 1;//进入右边查找
            }
            else//若右边有序
            {
                if ((nums[mid] <= target) && (target <= nums[r]))//且目标元素在右边
                    l = mid + 1;//进入右边查找
                else//目标元素在左边
                    r = mid - 1;//进入左边查找
            }
        }
        return -1;
    }
};

• 时间复杂度：$O(logN)$，$N$为数组nums的大小，二分查找的复杂度为$logN$。
• 空间复杂度：$O(1)$