二分查找变种：旋转排序数组最小值求解-代码聚汇网

二分查找变种：旋转排序数组最小值求解

王少冬

1. 问题背景与核心挑战

今天我们要啃的是一道经典的二分查找变种题——LeetCode 153题"寻找旋转排序数组中的最小值"。这道题看似简单，实则暗藏玄机，很多同学在面试中都在这里栽过跟头。旋转排序数组是指将一个原本严格递增的数组在某个未知点进行了旋转操作，例如[4,5,6,7,0,1,2]就是[0,1,2,4,5,6,7]在索引3处旋转后的结果。

这类问题的难点在于：

旋转点（即最小值点）的位置完全未知
数组可能完全没有旋转（即旋转点在0处）
需要保持O(log n)的时间复杂度，这意味着必须使用二分查找的变种

2. 暴力解法与二分查找对比

2.1 暴力解法分析

最直观的解法是遍历整个数组寻找最小值：

javascript复制function findMin(nums) {
    let min = Infinity;
    for (let num of nums) {
        if (num < min) min = num;
    }
    return min;
}

虽然这种解法简单直接，但时间复杂度是O(n)，没有利用到数组"部分有序"的特性，显然不是最优解。

2.2 二分查找适用性分析

二分查找通常用于有序数组，但旋转排序数组的特点是：

以旋转点为界，左右两部分仍然保持有序
最小值左侧的所有元素都大于右侧的所有元素

这种局部有序性正是我们可以利用的关键。我们需要改造传统的二分查找：

比较中间元素与右边界元素
根据比较结果决定搜索左半部分还是右半部分
直到找到旋转点（即最小值）

3. 二分查找实现详解

3.1 基本算法框架

javascript复制function findMin(nums) {
    let left = 0;
    let right = nums.length - 1;
    
    while (left < right) {
        const mid = Math.floor((left + right) / 2);
        
        if (nums[mid] > nums[right]) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    
    return nums[left];
}

3.2 关键逻辑解析

比较nums[mid]与nums[right]：
- 如果nums[mid] > nums[right]，说明最小值在右半部分
- 否则最小值在左半部分或就是mid本身
边界移动规则：
- 当确定最小值在右半部分时，left = mid + 1
- 否则right = mid（不能是mid-1，因为mid可能就是最小值）
循环终止条件：
- 当left == right时，就找到了最小值点

3.3 示例推演

以nums = [4,5,6,7,0,1,2]为例：

初始：left=0, right=6 → mid=3 (7)
- 7 > 2 → left=4
left=4, right=6 → mid=5 (1)
- 1 < 2 → right=5
left=4, right=5 → mid=4 (0)
- 0 < 1 → right=4
left == right → 返回nums[4]=0

4. 边界情况处理

4.1 完全升序数组

如nums = [1,2,3,4,5]：

每次比较nums[mid] < nums[right]，right不断左移
最终停在left=0，正确返回1

4.2 单元素数组

如nums = [5]：

直接返回唯一元素

4.3 包含重复元素

虽然题目保证元素唯一，但实际面试中可能会被问到有重复的情况：

javascript复制function findMinWithDup(nums) {
    let left = 0;
    let right = nums.length - 1;
    
    while (left < right) {
        const mid = Math.floor((left + right) / 2);
        
        if (nums[mid] > nums[right]) {
            left = mid + 1;
        } else if (nums[mid] < nums[right]) {
            right = mid;
        } else {
            right--;
        }
    }
    
    return nums[left];
}

当nums[mid] == nums[right]时，无法判断最小值在哪边，只能逐步缩小右边界。

5. 算法复杂度分析

5.1 时间复杂度

每次迭代都将搜索范围减半
最坏情况下需要O(log n)次比较
优于暴力解法的O(n)

5.2 空间复杂度

只使用了常数个额外空间
O(1)的空间复杂度

6. 常见错误与调试技巧

6.1 死循环问题

错误实现：

javascript复制// 错误示例
while (left <= right) {  // 应该用 < 而不是 <=
    // ...
    right = mid;  // 当left==right时会死循环
}

正确做法是使用left < right作为循环条件。

6.2 比较对象选择

有些同学喜欢比较nums[mid]与nums[left]，这在某些情况下也能工作，但不如比较nums[right]可靠：

比较left需要额外处理完全升序的情况
比较right的逻辑更加统一

6.3 调试技巧

打印每次迭代的left, mid, right值
特别关注循环终止条件
用简单的测试用例手动验证（如2-3个元素的数组）

7. 实际应用场景

这种旋转排序数组的问题在实际开发中并不少见，比如：

循环队列的实现
时间序列数据的周期性分析
游戏开发中的关卡循环系统
音乐播放器的播放列表循环

理解这类问题的解法有助于我们在遇到类似模式时快速识别并解决。

8. 扩展练习建议

为了巩固这个算法模式，建议尝试以下LeetCode题目：

1. 搜索旋转排序数组
1. 搜索旋转排序数组 II（含重复元素）
1. 寻找旋转排序数组中的最小值 II
1. 山脉数组的峰顶索引

这些题目都使用了类似的二分查找变种技巧，只是判断条件有所不同。