Leetcode 81.搜索选择排序数组Ⅱ-CSDN博客

本文链接：https://blog.csdn.net/tang7mj/article/details/134384978

已知存在一个按非降序排列的整数数组 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 。

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

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

进阶：

这是搜索旋转排序数组的延伸题目，本题中的 nums 可能包含重复元素。
这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？

通过次数

208.8K

提交次数

509.1K

通过率

41.0%

我的答案：

一、信息

题目描述了一个整数数组 nums，它首先按非降序排列，然后在未知下标 k 处进行了旋转。数组中的元素可以重复。要求编写一个函数，判断给定的目标值 target 是否存在于数组中。

二、分析

数组旋转：数组在某个下标 k 处旋转意味着数组被分为两部分，并且每部分内部仍然保持原有的排序。
存在重复元素：与普通的二分查找不同，重复元素的存在使得我们无法直接判断哪部分是有序的。
二分查找的应用：虽然数组被旋转，我们仍然可以尝试使用二分查找，但需要添加额外的条件来处理重复元素。

三、算法设计

初始化左右指针：设定左右边界 left 和 right。
二分查找：
- 循环直到 left 大于 right。
- 计算中间位置 mid。
- 如果 nums[mid] 等于 target，返回 true。
- 如果 nums[left]、nums[mid] 和 nums[right] 相等，不能判断哪部分有序，此时将 left 和 right 分别向内移动。
- 如果左侧有序（nums[left] <= nums[mid]）：
  - 判断 target 是否在左侧，调整 right。
  - 否则，调整 left。
- 如果右侧有序：
  - 判断 target 是否在右侧，调整 left。
  - 否则，调整 right。
找不到目标值时返回 false。

四、代码实现（C++）

#include <vector>
using namespace std;

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        int left = 0, 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;
            } else 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;
    }
};

五、实现代码过程中可能遇到的问题

边界处理：在处理边界条件时需要非常小心，尤其是在调整 left 和 right 时，以免错过目标值。
重复元素的处理：当遇到 nums[left]、nums[mid] 和 nums[right] 相等的情况，需要特别处理，此时简单地移动边界可能会影响查找效率。
时间复杂度：由于重复元素的存在，最坏情况下的时间复杂度可能退化到 O(n)。

Leetcode官方题解：

class Solution {
public:
    bool search(vector<int> &nums, int target) {
        int n = nums.size();
        if (n == 0) {
            return false;
        }
        if (n == 1) {
            return nums[0] == target;
        }
        int l = 0, r = n - 1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (nums[mid] == target) {
                return true;
            }
            if (nums[l] == nums[mid] && nums[mid] == nums[r]) {
                ++l;
                --r;
            } else 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[n - 1]) {
                    l = mid + 1;
                } else {
                    r = mid - 1;
                }
            }
        }
        return false;
    }
};