33.搜索旋转排序数组 python

题目

题目描述

整数数组 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 。

你必须设计一个时间复杂度为 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

示例 3：

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

提示：

1 <= nums.length <= 5000
-10^4 <= nums[i] <= 10^4
nums 中的每个值都 独一无二
题目数据保证 nums 在预先未知的某个下标上进行了旋转
-10^4 <= target <= 10^4

题目链接

搜索旋转排序数组

题解

解题思路

这个问题可以通过修改二分查找算法来解决。由于数组是经过旋转的有序数组，我们不能直接使用标准的二分查找，但是我们可以利用数组的特性来进行调整。具体来说，通过检查中间点与边界的关系，我们可以确定哪一半是有序的，并据此决定在哪个半区进行下一步搜索。

以下是具体的步骤：

1. 初始化：设置两个指针 left 和 right 分别指向数组的起始和结束位置。
2. 循环条件：当 left <= right 时继续循环。
3. 计算中间点：计算中间点 mid 的索引。
4. 检查中间点：如果 nums[mid] 等于目标值 target，则返回 mid。
5. 判断哪边有序：
   • 如果左半部分有序（即 nums[left] <= nums[mid]），检查目标值是否在这个范围内。如果是，则调整 right 到 mid - 1；否则，调整 left 到 mid + 1。
   • 否则，右半部分有序（即 nums[mid] < nums[right]），检查目标值是否在这个范围内。如果是，则调整 left 到 mid + 1；否则，调整 right 到 mid - 1。
6. 未找到目标值：如果循环结束后仍未找到目标值，则返回 -1。

python实现

下面是 Python 实现代码：

def search(nums, target):
    left, right = 0, len(nums) - 1
    
    while left <= right:
        mid = (left + right) // 2
        
        if nums[mid] == target:
            return mid
        
        # Check if left part is sorted
        if nums[left] <= nums[mid]:
            if nums[left] <= target < nums[mid]:
                right = mid - 1
            else:
                left = mid + 1
        # Otherwise, the right part must be sorted
        else:
            if nums[mid] < target <= nums[right]:
                left = mid + 1
            else:
                right = mid - 1
                
    return -1

代码解释：

• 初始化：设置 left 和 right 指针。
• 循环条件：确保我们在有效的范围内进行搜索。
• 计算中间点：避免溢出，使用 (left + right) // 2 计算 mid。
• 检查中间点：如果找到了目标值，立即返回其索引。
• 判断哪边有序：根据中间点与左右边界的比较，确定哪一部分是有序的，并进一步缩小搜索范围。
• 未找到目标值：如果循环结束还没有找到目标值，说明目标不在数组中，返回 -1。

这种方法的时间复杂度为 O(log n)，因为它基于二分查找的思想，在每次迭代中将搜索空间减半。

提交结果