二分查找算法精讲：原理、实现与LeetCode实战

梁培定

1. 二分查找算法精讲：从原理到实战

二分查找（Binary Search）是计算机科学中最基础也最高效的查找算法之一，它能在O(log n)的时间复杂度内完成有序数据的查找操作。作为一名有多年算法教学经验的工程师，我发现很多初学者虽然能写出二分查找的代码，但对其中精妙之处和实际应用场景理解不深。今天我就通过LeetCode上的6道经典题目，带大家彻底掌握这个算法的核心思想。

1.1 算法原理与核心思想

二分查找的基本思想非常简单：每次都将搜索范围缩小一半。对于一个有序数组，我们首先比较中间元素与目标值：

如果中间元素等于目标值，查找成功
如果目标值小于中间元素，则在左半部分继续查找
如果目标值大于中间元素，则在右半部分继续查找

这种分治策略使得算法的时间复杂度从线性查找的O(n)降低到O(log n)，对于大规模数据查找效率提升显著。

注意：二分查找的前提是数据必须是有序的，如果是无序数组需要先排序才能使用二分查找

1.2 算法实现的关键细节

在实现二分查找时，有几个关键细节需要特别注意：

循环终止条件：是left <= right还是left < right？
中间值计算：mid = (left + right)/2可能存在整数溢出风险
边界更新：left = mid还是left = mid + 1？
返回值处理：找不到时返回-1还是应该插入的位置？

这些细节处理不当会导致死循环或者错误结果。在下面的具体题目解析中，我会逐一讲解这些问题的解决方案。

2. 基础二分查找实现（LeetCode 704）

2.1 题目分析与标准解法

LeetCode 704是最基础的二分查找题目，要求在一个有序数组中查找目标值，存在则返回索引，不存在则返回-1。

cpp复制class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2; // 防止溢出
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1;
    }
};

2.2 实现细节解析

循环条件：使用left <= right确保能处理只有一个元素的情况
中间值计算：使用left + (right - left)/2而非(left + right)/2防止整数溢出
边界更新：每次排除掉确定不包含目标值的半区，所以是mid±1
返回值：找到时直接返回mid，循环结束未找到则返回-1

2.3 常见错误与调试技巧

初学者常犯的错误包括：

忘记更新left/right导致死循环
边界条件处理不当（如空数组、单个元素数组）
整数溢出问题

调试技巧：

打印每次循环的left、right、mid值
用简单测试用例验证（如空数组、单元素数组）
特别注意循环终止条件和边界更新

3. 搜索插入位置（LeetCode 35）

3.1 问题变形与解法

这道题要求在有序数组中查找目标值，如果存在返回索引，不存在则返回应该插入的位置。这是二分查找的一个典型变种。

cpp复制class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return left; // 关键变化在这里
    }
};

3.2 与基础版本的区别

唯一区别在于返回值处理：

基础版本找不到时返回-1
本题找不到时返回left，即第一个大于目标值的元素位置

这是因为当循环结束时，left指向的就是目标值应该插入的位置。这个性质在解决其他二分查找变种问题时非常有用。

3.3 实际应用场景

这种变种在实际开发中很常见，比如：

数据库索引查找
内存中维护有序数据结构
需要频繁查找和插入的场景

4. 查找元素边界（LeetCode 34）

4.1 问题分析与解决思路

这道题要求在有序数组中查找目标值的起始和结束位置。如果目标值不存在，返回[-1, -1]。这是二分查找的一个高级变种，需要找到目标值的左边界和右边界。

cpp复制class Solution {
    int searchLeft(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] >= target) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return left;
    }
    
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int leftIdx = searchLeft(nums, target);
        if (leftIdx == nums.size() || nums[leftIdx] != target) {
            return {-1, -1};
        }
        int rightIdx = searchLeft(nums, target + 1) - 1;
        return {leftIdx, rightIdx};
    }
};

4.2 边界查找技巧

左边界查找：修改条件为nums[mid] >= target，这样循环结束时left指向第一个等于target的位置
右边界查找：巧妙利用左边界查找函数，查找target+1的左边界然后减1
存在性检查：检查左边界是否有效且对应元素确实等于target

4.3 算法优化与性能分析

这种实现方式：

时间复杂度：O(log n)，因为进行了两次二分查找
空间复杂度：O(1)，只使用了常数额外空间

相比线性扫描的O(n)时间复杂度，二分查找版本在大数据量时优势明显。

5. 数值计算类应用（LeetCode 69 & 367）

5.1 平方根计算（LeetCode 69）

这道题要求计算非负整数x的平方根，结果只保留整数部分。我们可以将这个问题转化为在[0, x]范围内查找最大的整数n使得n² ≤ x。

cpp复制class Solution {
public:
    int mySqrt(int x) {
        if (x <= 1) return x;
        int left = 0, right = x;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (x / mid >= mid) { // 等价于mid*mid <= x，但防止溢出
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        return left - 1;
    }
};

5.2 完全平方数判断（LeetCode 367）

这道题判断一个数是否是完全平方数，可以看作是平方根问题的变种。

cpp复制class Solution {
public:
    bool isPerfectSquare(int num) {
        if (num <= 1) return true;
        long left = 0, right = num;
        while (left <= right) {
            long mid = left + (right - left) / 2;
            long square = mid * mid;
            if (square == num) {
                return true;
            } else if (square < num) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return false;
    }
};

5.3 数值计算技巧

防止整数溢出：使用除法比较而非乘法
边界处理：特别注意0和1的特殊情况
精度控制：虽然本题只要求整数结果，但可以扩展为浮点数计算

6. 二维矩阵中的二分查找（LeetCode 1351）

6.1 问题描述与暴力解法

这道题给定一个m×n的矩阵，行列都是非递增顺序排列，要求统计其中负数的个数。最直观的解法是双重循环遍历整个矩阵。

cpp复制class Solution {
public:
    int countNegatives(vector<vector<int>>& grid) {
        int count = 0;
        for (const auto& row : grid) {
            for (int num : row) {
                if (num < 0) count++;
            }
        }
        return count;
    }
};

6.2 二分查找优化

由于每行都是有序的，我们可以对每行使用二分查找找到第一个负数的位置，然后计算该行的负数个数。

cpp复制class Solution {
public:
    int countNegatives(vector<vector<int>>& grid) {
        int count = 0;
        for (const auto& row : grid) {
            // 使用二分查找找到第一个负数的位置
            int left = 0, right = row.size();
            while (left < right) {
                int mid = left + (right - left) / 2;
                if (row[mid] >= 0) {
                    left = mid + 1;
                } else {
                    right = mid;
                }
            }
            count += row.size() - left;
        }
        return count;
    }
};