【码道初阶】二分再秒一道困难题：Leetcode154寻找旋转排序数组中的最小值 II ，不禁感叹证明一个思路错误，有时比找到正确的思路更加困难

问题回顾

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,4,4,5,6,7] 在变化后可能得到：
若旋转 4 次，则可以得到 [4,5,6,7,0,1,4]
若旋转 7 次，则可以得到 [0,1,4,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 ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

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

示例 1：

输入：nums = [1,3,5]
输出：1
示例 2：

输入：nums = [2,2,2,0,1]
输出：0

提示：

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

方法思路

1. 问题分析
   旋转排序数组由两个非递减子数组组成，最小值位于这两个子数组的交界处。由于存在重复元素，传统的二分查找需要调整以处理无法确定有序区间的情况。

2. 关键策略

   • 比较中间值与右边界：通过比较 nums[mid] 和 nums[r] 决定搜索方向。
   • 处理相等情况：当 nums[mid] == nums[r] 时，无法确定最小值位置，但可以安全地缩小右边界。

解决代码

class Solution {
public:
    int findMin(vector<int>& nums) {
        int left = 0, right = nums.size() - 1;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] < nums[right]) {
                // 右半部分有序，最小值在左侧或mid处
                right = mid;
            } else if (nums[mid] > nums[right]) {
                // 最小值在右半部分
                left = mid + 1;
            } else {
                // 无法确定，缩小右边界
                right--;
            }
        }
        return nums[left];
    }
};

代码解释

1. 初始化边界
   left 和 right 初始化为数组的首尾索引，覆盖整个数组范围。

2. 循环条件
   while (left < right) 确保在循环结束时 left 和 right 指向同一位置，即最小值所在。

3. 中间值计算
   使用 mid = left + (right - left) / 2 防止整数溢出。

4. 比较逻辑

   • nums[mid] < nums[right]
     右半部分有序，最小值可能在左侧或 mid 处，将右边界移到 mid。
   • nums[mid] > nums[right]
     最小值位于右半部分，调整左边界到 mid + 1。
   • nums[mid] == nums[right]
     无法确定有序区间，但可排除右边界，逐步缩小范围。

5. 返回结果
   循环结束时，left 指向最小值的位置，返回 nums[left]。

示例分析

• 示例1：nums = [2,2,2,0,1]
  右边界逐步左移，最终定位到最小值 0。

• 示例2：nums = [3,1,3,3,3]
  中间值与右边界相等时缩小右边界，最终找到最小值 1。

复杂度分析

• 时间复杂度：平均 O(log n)，最坏情况下（全重复元素）退化为 O(n)。
• 空间复杂度：O(1)，仅使用常数空间。

该方法通过灵活调整二分查找策略，高效处理了旋转排序数组中的重复元素问题，确保找到最小值的同时减少不必要的比较。

思考：比较nums[mid]与nums[left]的大小关系是否可行？若nums[mid]<nums[left]不是显然可以说明nums[mid]处于右边的升序区间？

来看以下代码：

int findMin(vector<int>& nums) {
    int left = 0, right = nums.size() - 1;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < nums[left]) {    // mid可能位于右半部分
            right = mid;                 // 最小值在左半部分或mid处
            left++;                      // 处理左边界重复
        } else if (nums[mid] > nums[left]) { // 左半部分有序
            left = mid + 1;              // 最小值在右半部分
        } else {                         // 无法确定，缩小左边界
            left++;
        }
    }
    return nums[left];
}

要解决旋转排序数组中寻找最小值的问题，尤其是在存在重复元素的情况下，直接比较中间值 nums[mid] 与左边界 nums[left] 的方法存在逻辑缺陷。以下是对问题的详细分析和优化后的解决方案：

---

关键问题分析

1. 左边界比较的缺陷
   当使用 nums[mid] < nums[left] 判断时，假设 mid 处于右半部分升序中，这种假设在以下场景中会失败：

   • 完全升序数组：例如 [0,1,2,3,4]，mid 会始终大于左边界，导致错误地向右搜索。代入上述代码试试就知道了
   • 旋转点后的最小值位置：若最小值位于右半部分，但左边界值较小（如 [2,0,1,2,2]），比较逻辑会失效。

2. 右边界比较的优势
   右边界 nums[right] 在旋转数组中天然处于更接近最小值的位置。比较 nums[mid] 和 nums[right] 能更可靠地判断有序区间：

   • 右半部分有序：若 nums[mid] < nums[right]，最小值一定在左半部分或 mid 处。
   • 左半部分有序：若 nums[mid] > nums[right]，最小值一定在右半部分。

---

总结

通过比较中间值与右边界，算法能高效定位旋转数组的最小值，同时处理重复元素。直接比较左边界会导致逻辑漏洞，尤其在完全升序或复杂旋转场景下失效。右边界比较策略凭借其天然的区间划分优势，成为解决此类问题的可靠方法。