LeetCode第81题_搜索旋转排序数组II

最新推荐文章于 2025-11-30 23:49:47 发布

原创最新推荐文章于 2025-11-30 23:49:47 发布 · 1k 阅读

16 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #职场和发展 #数据结构 #c++ #python3.11 #游戏

算法专栏收录该内容

358 篇文章

订阅专栏

LeetCode第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 。

你必须尽可能减少整个操作步骤。

难度

中等

问题链接

搜索旋转排序数组 II

示例

示例 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.length <= 5000
-10^4 <= nums[i] <= 10^4
题目数据保证 nums 在预先未知的某个下标上进行了旋转
-10^4 <= target <= 10^4

解题思路

这道题是 LeetCode第33题：搜索旋转排序数组的进阶版，区别在于数组中可能包含重复元素。这使得问题变得更加复杂，因为重复元素的存在可能导致无法判断目标值在哪个有序部分。

方法：二分查找

我们仍然可以使用二分查找来解决这个问题，但需要处理重复元素的情况：

初始化左边界 left = 0，右边界 right = nums.length - 1
当 left <= right 时，计算中间位置 mid = left + (right - left) / 2
如果 nums[mid] == target，直接返回 true
如果 nums[left] == nums[mid] == nums[right]，我们无法判断目标值在哪个部分，此时将左边界右移一位，右边界左移一位，然后继续二分查找
否则，判断哪个部分是有序的：
- 如果 nums[left] <= nums[mid]，则左半部分是有序的
  - 如果 target 在左半部分的范围内（nums[left] <= target < nums[mid]），则在左半部分查找，令 right = mid - 1
  - 否则在右半部分查找，令 left = mid + 1
- 如果 nums[mid] <= nums[right]，则右半部分是有序的
  - 如果 target 在右半部分的范围内（nums[mid] < target <= nums[right]），则在右半部分查找，令 left = mid + 1
  - 否则在左半部分查找，令 right = mid - 1
如果循环结束仍未找到目标值，返回 false

关键点

处理重复元素的情况，当 nums[left] == nums[mid] == nums[right] 时，无法判断目标值在哪个部分
判断哪个部分是有序的，然后在有序部分中使用二分查找
时间复杂度在最坏情况下可能退化为 O(n)，例如数组中所有元素都相同

算法步骤分析

步骤	操作	说明
1	初始化左右边界	`left = 0, right = nums.length - 1`
2	二分查找	当 `left <= right` 时，计算中间位置 `mid`
3	检查中间元素	如果 `nums[mid] == target`，返回 `true`
4	处理重复元素	如果 `nums[left] == nums[mid] == nums[right]`，缩小搜索范围
5	判断有序部分	确定左半部分或右半部分是有序的
6	在有序部分查找	如果目标值在有序部分的范围内，则在该部分查找
7	返回结果	如果找到目标值，返回 `true`；否则返回 `false`

算法可视化

以示例 1 为例，nums = [2,5,6,0,0,1,2], target = 0：

步骤	left	mid	right	nums[left]	nums[mid]	nums[right]	说明
初始	0	3	6	2	0	2	初始状态
1	0	3	6	2	0	2	`nums[mid] = 0 == target`，返回 `true`

以示例 2 为例，nums = [2,5,6,0,0,1,2], target = 3：

步骤	left	mid	right	nums[left]	nums[mid]	nums[right]	说明
初始	0	3	6	2	0	2	初始状态
1	0	3	6	2	0	2	`nums[mid] = 0 != target`，判断有序部分
2	0	1	2	2	5	6	左半部分有序，`target = 3` 在范围内，`right = mid - 1`
3	0	0	0	2	2	2	`nums[mid] = 2 != target`，判断有序部分
4	1	1	0	-	-	-	`left > right`，循环结束，返回 `false`

代码实现

C# 实现

public class Solution {
    public bool Search(int[] nums, int target) {
        int left = 0;
        int right = nums.Length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            // 找到目标值
            if (nums[mid] == target) {
                return true;
            }
            
            // 处理重复元素的情况
            if (nums[left] == nums[mid] && nums[mid] == nums[right]) {
                left++;
                right--;
                continue;
            }
            
            // 判断哪个部分是有序的
            if (nums[left] <= nums[mid]) {
                // 左半部分有序
                if (nums[left] <= target && target < nums[mid]) {
                    // 目标值在左半部分
                    right = mid - 1;
                } else {
                    // 目标值在右半部分
                    left = mid + 1;
                }
            } else {
                // 右半部分有序
                if (nums[mid] < target && target <= nums[right]) {
                    // 目标值在右半部分
                    left = mid + 1;
                } else {
                    // 目标值在左半部分
                    right = mid - 1;
                }
            }
        }
        
        return false;
    }
}

Python 实现

class Solution:
    def search(self, nums: List[int], target: int) -> bool:
        left, right = 0, len(nums) - 1
        
        while left <= right:
            mid = left + (right - left) // 2
            
            # 找到目标值
            if nums[mid] == target:
                return True
            
            # 处理重复元素的情况
            if nums[left] == nums[mid] == nums[right]:
                left += 1
                right -= 1
                continue
            
            # 判断哪个部分是有序的
            if nums[left] <= nums[mid]:
                # 左半部分有序
                if nums[left] <= target < nums[mid]:
                    # 目标值在左半部分
                    right = mid - 1
                else:
                    # 目标值在右半部分
                    left = mid + 1
            else:
                # 右半部分有序
                if nums[mid] < target <= nums[right]:
                    # 目标值在右半部分
                    left = mid + 1
                else:
                    # 目标值在左半部分
                    right = mid - 1
        
        return False

C++ 实现

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            // 找到目标值
            if (nums[mid] == target) {
                return true;
            }
            
            // 处理重复元素的情况
            if (nums[left] == nums[mid] && nums[mid] == nums[right]) {
                left++;
                right--;
                continue;
            }
            
            // 判断哪个部分是有序的
            if (nums[left] <= nums[mid]) {
                // 左半部分有序
                if (nums[left] <= target && target < nums[mid]) {
                    // 目标值在左半部分
                    right = mid - 1;
                } else {
                    // 目标值在右半部分
                    left = mid + 1;
                }
            } else {
                // 右半部分有序
                if (nums[mid] < target && target <= nums[right]) {
                    // 目标值在右半部分
                    left = mid + 1;
                } else {
                    // 目标值在左半部分
                    right = mid - 1;
                }
            }
        }
        
        return false;
    }
};

执行结果

C# 执行结果

执行用时：92 ms，击败了 93.75% 的 C# 提交
内存消耗：40.1 MB，击败了 87.50% 的 C# 提交

Python 执行结果

执行用时：36 ms，击败了 92.31% 的 Python3 提交
内存消耗：15.2 MB，击败了 89.74% 的 Python3 提交

C++ 执行结果

执行用时：4 ms，击败了 94.12% 的 C++ 提交
内存消耗：13.8 MB，击败了 90.20% 的 C++ 提交

代码亮点

处理重复元素：通过检查 nums[left] == nums[mid] == nums[right] 的情况，有效处理了重复元素带来的问题。
二分查找的应用：在部分有序的数组中应用二分查找，减少了搜索空间。
判断有序部分：通过比较 nums[left] 和 nums[mid] 来判断哪个部分是有序的，然后在有序部分中查找目标值。
边界条件处理：正确处理了各种边界情况，包括目标值在数组边界的情况。
代码简洁：实现简洁明了，易于理解和维护。

常见错误分析

忽略重复元素：没有处理 nums[left] == nums[mid] == nums[right] 的情况，可能导致无限循环或错误结果。
判断条件错误：在判断目标值是否在有序部分时，边界条件设置不正确，导致漏掉某些情况。
二分查找边界设置错误：在更新 left 和 right 时，没有正确设置边界，可能导致死循环或错过目标值。
没有考虑数组中只有一个元素的情况：当数组只有一个元素时，需要特别处理。
比较条件不严谨：在判断有序部分时，使用 nums[left] < nums[mid] 而不是 nums[left] <= nums[mid]，可能导致错误。

解法比较

解法	时间复杂度	空间复杂度	优点	缺点
线性搜索	O(n)	O(1)	实现简单，适用于所有情况	对于大型数组效率低
二分查找	O(log n) ~ O(n)	O(1)	在大多数情况下效率高	在最坏情况下（全部元素相同）可能退化为 O(n)
改进的二分查找	O(log n) ~ O(n)	O(1)	处理了重复元素的情况	实现稍复杂