二分查找变体：有序数组中定位目标值边界

1. 问题背景与核心挑战

在算法面试和日常编程中，处理有序数据集是最基础也最频繁遇到的任务之一。给定一个按照升序排列的整数数组和一个目标值，要求找出该目标值在数组中的开始位置和结束位置，这个问题看似简单，却蕴含着多个考察点。

这个问题最早出现在LeetCode第34题，被归类为中等难度。它在2023年依然保持在LeetCode热题100榜单中，说明其作为面试题的经典地位。根据我的面试经验，亚马逊、微软等公司在近半年的技术面中仍有超过30%的概率会考察这个题目或它的变种。

这个问题的核心难点在于：

• 必须设计时间复杂度为O(log n)的算法
• 需要处理目标值不存在于数组中的情况（返回[-1, -1]）
• 边界条件的处理（如数组为空、所有元素相同等）
• 在二分查找的基础上进行两次变体操作

提示：很多面试者会直接套用标准二分查找模板，但这样只能找到任意一个匹配位置，无法确定起始和结束边界。这是面试中最常见的失分点。

2. 算法设计思路解析

2.1 暴力解法与优化方向

最直观的解法是线性扫描：

1. 从左到右遍历，记录第一个等于target的位置
2. 继续遍历直到找到第一个大于target的位置
3. 时间复杂度O(n)，空间复杂度O(1)

这种解法虽然简单，但无法满足O(log n)的要求。我们需要利用数组已排序的特性，通过二分查找进行优化。

2.2 二分查找的变体应用

标准的二分查找在找到目标值后会立即返回，但我们需要的是边界位置。这需要修改二分查找的终止条件和搜索逻辑：

1. 查找左边界：

   • 当nums[mid] == target时，不立即返回
   • 继续在左半部分搜索(end = mid)
   • 直到搜索空间耗尽(start == end)

2. 查找右边界：

   • 当nums[mid] == target时，不立即返回
   • 继续在右半部分搜索(start = mid + 1)
   • 直到搜索空间耗尽(start == end)

这种变体保证了即使找到目标值也会继续搜索边界，最终得到的start/end就是边界位置。

3. 完整代码实现与逐行解析

以下是Python的完整实现，包含详细注释：

python复制def searchRange(nums, target):
    def findLeft(nums, target):
        left, right = 0, len(nums)
        while left < right:
            mid = (left + right) // 2
            if nums[mid] >= target:
                right = mid
            else:
                left = mid + 1
        return left
    
    def findRight(nums, target):
        left, right = 0, len(nums)
        while left < right:
            mid = (left + right) // 2
            if nums[mid] > target:
                right = mid
            else:
                left = mid + 1
        return left
    
    left_idx = findLeft(nums, target)
    right_idx = findRight(nums, target) - 1
    
    # 检查是否找到有效范围
    if left_idx <= right_idx and right_idx < len(nums) and nums[left_idx] == target and nums[right_idx] == target:
        return [left_idx, right_idx]
    return [-1, -1]

关键点解析：

1. findLeft函数中的nums[mid] >= target条件确保即使找到target也继续向左搜索
2. findRight函数中的nums[mid] > target条件会在找到target时继续向右搜索
3. 最终需要检查找到的索引是否有效（防止target不存在的情况）
4. 右边界返回的是第一个大于target的位置，所以需要减1

4. 边界条件与测试用例设计

4.1 必须考虑的边界情况

根据我的调试经验，这些边界情况最容易出错：

• 空数组输入 []
• 数组中所有元素相同 [1,1,1,1]
• target比所有元素都小或都大
• 数组中只有一个元素且匹配/不匹配
• target出现在数组开头或结尾

4.2 推荐的测试用例集

python复制test_cases = [
    ([5,7,7,8,8,10], 8, [3,4]),   # 标准情况
    ([5,7,7,8,8,10], 6, [-1,-1]), # 不存在
    ([], 0, [-1,-1]),             # 空数组
    ([1,1,1,1], 1, [0,3]),        # 全相同
    ([2,2], 3, [-1,-1]),          # 超出最大值
    ([1,3], 1, [0,0]),            # 单个匹配
    ([1,4,4,4,5], 4, [1,3]),      # 多个连续
    ([1], 1, [0,0]),              # 单元素匹配
]

注意：在实际面试中，建议先口头描述这些测试用例再开始编码，展示全面的思考过程。

5. 算法复杂度与优化空间

5.1 时间复杂度分析

• 两次二分查找：2 * O(log n) = O(log n)
• 最后的边界检查：O(1)
• 总体时间复杂度：O(log n)

5.2 空间复杂度分析

• 只使用了常数级别的额外空间
• 空间复杂度：O(1)

5.3 可能的优化方向

1. 提前终止：在第一次二分查找后，如果没找到target可以直接返回[-1,-1]
2. 合并搜索：有些实现尝试在一次二分查找中同时记录左右边界，但代码会变得复杂
3. 模板化：将二分查找抽象为通用模板，适用于各种变体问题

6. 相关题目与扩展思考

6.1 LeetCode相似题目推荐

1. 35. 搜索插入位置（更简单的二分查找）
2. 702. 搜索长度未知的有序数组（处理未知边界）
3. 153. 寻找旋转排序数组中的最小值（变体二分）
4. 162. 寻找峰值（另一种变体）

6.2 实际应用场景

这种边界查找算法在以下场景有实际应用：

• 数据库索引的范围查询优化
• 日志系统中时间戳范围的快速定位
• 大数据分析中的值分布统计

6.3 面试进阶问题

面试官可能会追问：

1. 如果数组中有大量重复元素，如何进一步优化？
2. 如何将这个算法扩展到多维数据？
3. 如果数组是流式数据（无法完全加载到内存）如何处理？

我在实际项目中曾遇到过需要处理数十亿级别有序数据的场景，最终采用的正是这种二分查找边界定位的变体，配合分块加载技术，将查询时间从小时级降低到秒级。