LeetCode 算法：寻找旋转排序数组中的最小值 c++

原题链接🔗：寻找旋转排序数组中的最小值
难度：中等⭐️⭐️

题目

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：
若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]
注意，数组 [a[0], a[1], a[2], …, a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], …, a[n-2]] 。

给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

示例 1：
输入：nums = [3,4,5,1,2]
输出：1
解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。

示例 2：
输入：nums = [4,5,6,7,0,1,2]
输出：0
解释：原数组为 [0,1,2,4,5,6,7] ，旋转 3 次得到输入数组。

示例 3：
输入：nums = [11,13,15,17]
输出：11
解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。

提示：

n == nums.length
1 <= n <= 5000
-5000 <= nums[i] <= 5000
nums 中的所有整数 互不相同
nums 原来是一个升序排序的数组，并进行了 1 至 n 次旋转

题解

1. 解题思路：

LeetCode上的这个问题通常被称为"Find Minimum in Rotated Sorted Array"。这个问题的关键在于理解数组是经过旋转的，但仍然是部分有序的。解题的基本思路如下：

• 理解问题：首先，要明白题目中的数组是经过旋转的，例如数组 [4,5,6,7,0,1,2] 是 [0,1,2,4,5,6,7] 旋转了3个位置得到的。

• 二分查找：由于旋转后的数组仍然是部分有序的，我们可以使用二分查找来找到最小值。二分查找的关键在于如何确定中间元素与数组两端的关系。

• 确定中间元素：设数组长度为 n，中间索引为 mid = (left + right) / 2。

• 比较中间元素与两端：

  • 如果 nums[mid] 小于 nums[right]，说明最小值在 mid 到 right 之间，更新 left 为 mid + 1。
  • 如果 nums[mid] 大于 nums[right]，说明最小值在 left 到 mid 之间，包括 mid，更新 right 为 mid - 1。

• 特殊情况处理：当数组包含重复元素时，二分查找可能需要额外的逻辑来避免无限循环。如果 nums[mid] 等于 nums[left] 或者 nums[right]，可以选择将 left 或者 right 移动一位。

• 循环结束条件：当 left 大于 right 时，循环结束。

• 返回结果：循环结束后，nums[left] 就是数组中的最小值。

2. c++ demo：

#include <iostream>
#include <vector>

// 函数声明
int findMin(const std::vector<int>& nums);

int main() {
    // 测试用例
    std::vector<int> test1 = { 3, 4, 5, 1, 2 };
    std::vector<int> test2 = { 4, 5, 6, 7, 0, 1, 2 };
    std::vector<int> test3 = { 1, 0 };

    // 调用函数并打印结果
    std::cout << "Minimum in test1: " << findMin(test1) << std::endl;
    std::cout << "Minimum in test2: " << findMin(test2) << std::endl;
    std::cout << "Minimum in test3: " << findMin(test3) << std::endl;

    return 0;
}

// 函数定义
int findMin(const std::vector<int>& nums) {
    int left = 0, right = nums.size() - 1;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] > nums[right]) {
            left = mid + 1;
        }
        else if (nums[mid] < nums[right]) {
            right = mid;
        }
        else {
            --right; // nums[mid] == nums[right]，移动right避免死循环
        }
    }
    return nums[left];
}

• 输出结果：

Minimum in test1: 1
Minimum in test2: 0
Minimum in test3: 0

3. 代码仓库地址： findMin