C++二分详解

二分查找的基本概念

二分查找（Binary Search）是一种高效的搜索算法，其核心思想是将搜索范围每次缩小一半，直到找到目标元素或确定目标元素不存在。这种算法要求被搜索的数据必须是有序的（例如升序排列）。与线性查找（逐个检查元素）相比，二分查找的时间复杂度为 O (log n)，这使得它在处理大量数据时效率极高。

底层逻辑与工作原理

二分查找的工作流程如下：

1. 确定搜索范围：初始时，搜索范围是整个有序数组。
2. 选择中间元素：计算当前搜索范围的中间位置，并获取该位置的元素。
3. 比较中间元素与目标值：
   • 如果中间元素等于目标值，则搜索成功，返回中间元素的位置。
   • 如果中间元素大于目标值，由于数组有序，目标值只能存在于左半部分，因此将搜索范围缩小到左半部分。
   • 如果中间元素小于目标值，目标值只能存在于右半部分，因此将搜索范围缩小到右半部分。
4. 重复步骤 2-3：直到找到目标值或搜索范围为空（即左边界大于右边界）。

图例：

C++ 实现示例

下面是使用普通静态数组实现的二分查找代码：

#include <iostream>
// 二分查找函数 - 迭代实现
int binarySearch(const int arr[], int size, int target) {
    int left = 0;                   // 左边界
    int right = size - 1;           // 右边界
    while (left <= right) {
        int mid = left + (right - left) / 2;  // 计算中间位置，避免整数溢出
        if (arr[mid] == target) {
            return mid;             // 找到目标值，返回索引
        } else if (arr[mid] > target) {
            right = mid - 1;        // 目标在左半部分
        } else {
            left = mid + 1;         // 目标在右半部分
        }
    }
    return -1;                      // 未找到目标值
}
int main() {
    // 有序静态数组示例
    int arr[] = {2, 4, 6, 8, 10, 12, 14, 16};
    int size = sizeof(arr) / sizeof(arr[0]);  // 计算数组大小
    int target = 10;
    int result = binarySearch(arr, size, target);
    if (result != -1) {
        std::cout << "元素 " << target << " 在数组中的索引是: " << result << std::endl;
    } else {
        std::cout << "元素 " << target << " 不在数组中" << std::endl;
    }
    return 0;
}

关键点解析

1. 避免整数溢出：计算中间位置时使用mid = left + (right - left) / 2而非mid = (left + right) / 2，可以防止当left和right都很大时发生整数溢出。

2. 循环条件：使用left <= right作为循环条件，确保当搜索范围缩小到只剩一个元素时仍能正确检查。

3. 边界更新：每次迭代后，通过调整left或right将搜索范围缩小一半。

4. 静态数组处理：

   • 静态数组需要显式传递数组大小
   • 使用sizeof(arr) / sizeof(arr[0])计算数组元素个数
   • 不支持动态扩展，需要预先确定数组大小

递归实现

// 二分查找函数 - 递归实现
int binarySearchRecursive(const int arr[], int left, int right, int target) {
    if (left > right) {
        return -1;  // 搜索范围为空，未找到
    }
    int mid = left + (right - left) / 2;
    if (arr[mid] == target) {
        return mid;  // 找到目标值
    } else if (arr[mid] > target) {
        return binarySearchRecursive(arr, left, mid - 1, target);  // 搜索左半部分
    } else {
        return binarySearchRecursive(arr, mid + 1, right, target);  // 搜索右半部分
    }
}

适用场景

二分查找适用于以下情况：

1. 数据有序：必须是有序数组或类似结构。
2. 静态数据：数据不经常变动，因为插入和删除操作可能破坏有序性，需要额外维护成本。
3. 大量数据：当数据量很大时，二分查找的效率优势明显。

常见应用

• 在数据库索引中快速查找记录
• 在配置文件中查找特定参数
• 数值计算中的根查找问题
• 游戏开发中的碰撞检测优化

局限性

• 要求数据有序，维护有序性可能有额外开销
• 只适用于随机访问的数据结构（如数组），不适用于链表等顺序访问结构
• 对于小规模数据，线性查找可能更简单直接

通过理解二分查找的底层逻辑并掌握其实现，你可以在处理有序数据时高效地定位目标元素，大幅提升程序性能。

C++ 标准库中的二分查找函数

C++ 标准库提供了几个与二分查找相关的函数，这些函数位于<algorithm>头文件中，使用这些函数可以更方便地实现二分查找相关操作。

1. std::binary_search

该函数用于判断一个元素是否存在于有序序列中，返回一个布尔值。

​#include <iostream>
#include <algorithm>
int main() {
    int arr[] = {2, 4, 6, 8, 10, 12, 14, 16};
    int size = sizeof(arr) / sizeof(arr[0]);
    int target = 10;
    // 使用std::binary_search查找元素
    bool found = std::binary_search(arr, arr + size, target);
    if (found) {
        std::cout << "元素 " << target << " 存在于数组中" << std::endl;
    } else {
        std::cout << "元素 " << target << " 不存在于数组中" << std::endl;
    }
    return 0;
}

2. std::lower_bound

该函数用于查找有序序列中第一个不小于（即大于或等于）给定值的元素的迭代器。如果所有元素都小于给定值，则返回尾后迭代器。

#include <iostream>
#include <algorithm>
int main() {
    int arr[] = {2, 4, 6, 8, 10, 12, 14, 16};
    int size = sizeof(arr) / sizeof(arr[0]);
    int target = 9;
    // 使用std::lower_bound查找第一个不小于target的元素
    int* it = std::lower_bound(arr, arr + size, target);
    if (it != arr + size) {
        std::cout << "第一个不小于 " << target << " 的元素是: " << *it << std::endl;
        std::cout << "其索引是: " << (it - arr) << std::endl;
    } else {
        std::cout << "所有元素都小于 " << target << std::endl;
    }
    return 0;
}

3. std::upper_bound

该函数用于查找有序序列中第一个大于给定值的元素的迭代器。如果所有元素都不大于给定值，则返回尾后迭代器。

#include <iostream>
#include <algorithm>
int main() {
    int arr[] = {2, 4, 6, 8, 10, 12, 14, 16};
    int size = sizeof(arr) / sizeof(arr[0]);
    int target = 10;
    // 使用std::upper_bound查找第一个大于target的元素
    int* it = std::upper_bound(arr, arr + size, target);
    if (it != arr + size) {
        std::cout << "第一个大于 " << target << " 的元素是: " << *it << std::endl;
        std::cout << "其索引是: " << (it - arr) << std::endl;
    } else {
        std::cout << "没有元素大于 " << target << std::endl;
    }
    return 0;
}

4. std::equal_range

该函数返回一个std::pair，其中first是std::lower_bound的结果，second是std::upper_bound的结果，用于确定有序序列中所有等于给定值的元素范围。

#include <iostream>
#include <algorithm>
int main() {
    int arr[] = {2, 4, 6, 8, 10, 10, 12, 14, 16};
    int size = sizeof(arr) / sizeof(arr[0]);
    int target = 10;
    // 使用std::equal_range查找所有等于target的元素范围
    auto range = std::equal_range(arr, arr + size, target);
    if (range.first != range.second) {
        std::cout << "找到 " << (range.second - range.first) 
                  << " 个等于 " << target << " 的元素" << std::endl;
        std::cout << "范围是从索引 " << (range.first - arr)
                  << " 到 " << (range.second - arr - 1) << std::endl;
    } else {
        std::cout << "没有找到等于 " << target << " 的元素" << std::endl;
    }
    return 0;
}

二分查找例题与解题思路

例题 1：搜索插入位置

题目描述：给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

解题思路：这道题本质上就是二分查找，只是在未找到目标值时，返回的插入位置是第一个大于目标值的位置（即std::lower_bound的结果）。

代码实现：

#include <iostream>
int searchInsert(int nums[], int size, int target) {
    int left = 0;
    int right = size - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            return mid;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    // 未找到目标值时，left即为插入位置
    return left;
}
int main() {
    int nums[] = {1, 3, 5, 6};
    int size = sizeof(nums) / sizeof(nums[0]);
    int target = 5;
    std::cout << "目标值 " << target << " 的插入位置是: " << searchInsert(nums, size, target) << std::endl;
    target = 2;
    std::cout << "目标值 " << target << " 的插入位置是: " << searchInsert(nums, size, target) << std::endl;
    return 0;
}

例题 2：第一个错误的版本

题目描述：你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。假设你有n个版本[1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。你可以通过调用bool isBadVersion(version)接口来判断版本号version是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

解题思路：这是一个典型的二分查找应用，目标是找到第一个满足条件的元素（即第一个错误的版本）。我们可以使用二分查找来缩小搜索范围，直到找到该元素。

代码实现：

// 假设这是题目提供的API
bool isBadVersion(int version);
int firstBadVersion(int n) {
    int left = 1;
    int right = n;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (isBadVersion(mid)) {
            // mid是错误版本，第一个错误版本可能是mid或更早
            right = mid;
        } else {
            // mid不是错误版本，第一个错误版本在mid之后
            left = mid + 1;
        }
    }
    // 循环结束时，left和right指向同一个位置，即为第一个错误版本
    return left;
}

例题 3：寻找峰值

题目描述：峰值元素是指其值大于左右相邻值的元素。给定一个输入数组nums，其中nums[i] ≠ nums[i+1]，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回任何一个峰值所在位置即可。你可以假设nums[-1] = nums[n] = -∞。

解题思路：虽然数组不是完全有序的，但我们可以利用二分查找的思想。如果中间元素大于其右侧元素，那么峰值一定在左侧（包括中间元素）；否则峰值一定在右侧。这样每次可以将搜索范围缩小一半。

代码实现：

#include <iostream>
int findPeakElement(int nums[], int size) {
    int left = 0;
    int right = size - 1;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] > nums[mid + 1]) {
            // 峰值在左侧（包括mid）
            right = mid;
        } else {
            // 峰值在右侧
            left = mid + 1;
        }
    }
    // 循环结束时，left和right指向同一个位置，即为峰值
    return left;
}
int main() {
    int nums[] = {1, 2, 3, 1};
    int size = sizeof(nums) / sizeof(nums[0]);
    std::cout << "峰值元素的索引是: " << findPeakElement(nums, size) << std::endl;
    int nums2[] = {1, 2, 1, 3, 5, 6, 4};
    int size2 = sizeof(nums2) / sizeof(nums2[0]);
    std::cout << "峰值元素的索引是: " << findPeakElement(nums2, size2) << std::endl;
    return 0;
}

例题 4：搜索旋转排序数组

题目描述：整数数组nums按升序排列，数组中的值互不相同。在传递给函数之前，nums在预先未知的某个点上进行了旋转（例如，[0,1,2,4,5,6,7]经旋转后可能变为[4,5,6,7,0,1,2]）。给你旋转后的数组nums和一个整数target，如果nums中存在这个目标值target，则返回它的索引，否则返回-1。

解题思路：虽然数组被旋转了，但我们可以观察到，数组的一部分仍然是有序的。因此，在每次二分查找时，我们可以先判断哪一部分是有序的，然后检查目标值是否在这个有序部分内。如果是，则在有序部分继续查找；否则在另一部分查找。

代码实现：

#include <iostream>
int search(int nums[], int size, int target) {
    int left = 0;
    int right = size - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;

        if (nums[mid] == target) {
            return mid;
        }
        // 判断左半部分是否有序
        if (nums[left] <= nums[mid]) {
            // 目标值在左半部分的有序区间内
            if (nums[left] <= target && target < nums[mid]) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        } 
        // 右半部分有序
        else {
            // 目标值在右半部分的有序区间内
            if (nums[mid] < target && target <= nums[right]) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
    }
    return -1;
}
int main() {
    int nums[] = {4, 5, 6, 7, 0, 1, 2};
    int size = sizeof(nums) / sizeof(nums[0]);
    int target = 0;
    std::cout << "目标值 " << target << " 的索引是: " << search(nums, size, target) << std::endl;
    target = 3;
    std::cout << "目标值 " << target << " 的索引是: " << search(nums, size, target) << std::endl;
    return 0;
}

​

二分查找的变体与扩展

1. 查找左边界和右边界

在某些情况下，我们需要找到目标值在有序数组中的第一个出现位置（左边界）或最后一个出现位置（右边界）。

查找左边界：

int leftBound(const int nums[], int size, int target) {
    int left = 0;
    int right = size;  // 注意这里的右边界
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] >= target) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    // 检查是否越界或目标值不存在
    if (left >= size || nums[left] != target) {
        return -1;
    }
    return left;
}

查找右边界：

int rightBound(const int nums[], int size, int target) {
    int left = 0;
    int right = size;  // 注意这里的右边界
    while (left < right) {
        int mid = left + (right - left) / 2;

        if (nums[mid] <= target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    // 检查是否越界或目标值不存在
    if (left == 0 || nums[left - 1] != target) {
        return -1;
    }
    return left - 1;  // 注意这里返回left-1
}

2. 浮点数二分查找

当需要在浮点数范围内进行二分查找时，通常不需要严格判断相等，而是设置一个足够小的误差范围eps。

#include <cmath>
#include <stdexcept>
double sqrt(double x) {
    if (x < 0) {
        throw std::invalid_argument("Cannot compute square root of a negative number");
    }
    double left = 0.0;
    double right = std::max(x, 1.0);  // 处理x在0到1之间的情况
    double eps = 1e-10;  // 设置精度
    while (right - left > eps) {
        double mid = (left + right) / 2;
        if (mid * mid > x) {
            right = mid;
        } else {
            left = mid;
        }
    }
    return (left + right) / 2;
}

3. 二分答案

二分答案是一种将优化问题转化为判定问题的思想，通常用于求解满足某种条件的最大值或最小值。

例题：给定一个非负整数数组和一个整数m，你需要将这个数组分成m个非空的连续子数组。设计一个算法使得这m个子数组各自和的最大值最小。

解题思路：我们可以二分查找这个最小的最大值。对于一个候选值mid，判断是否可以将数组分成m个连续子数组，使得每个子数组的和不超过mid。如果可以，则尝试更小的候选值；否则尝试更大的候选值。

代码实现：

#include <iostream>
#include <numeric>
bool canSplit(const int nums[], int size, int m, int sumLimit) {
    int count = 1;
    int currentSum = 0;
    for (int i = 0; i < size; ++i) {
        if (currentSum + nums[i] > sumLimit) {
            count++;
            currentSum = nums[i];
            if (count > m) {
                return false;
            }
        } else {
            currentSum += nums[i];
        }
    }
    return true;
}
int splitArray(const int nums[], int size, int m) {
    int left = 0;
    for (int i = 0; i < size; ++i) {
        if (nums[i] > left) {
            left = nums[i];
        }
    }
    int right = std::accumulate(nums, nums + size, 0);
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (canSplit(nums, size, m, mid)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}

二分查找的应用领域

二分查找作为一种高效的算法，广泛应用于各种领域：

1. 数据库系统：在数据库索引（如 B 树、B + 树）中使用二分查找快速定位记录。

2. 搜索引擎：在倒排索引中查找关键词对应的文档列表。

3. 数值计算：求解方程的根、优化问题等。

4. 游戏开发：在碰撞检测、资源加载等场景中优化查找效率。

5. 网络编程：在路由表查找、IP 地址匹配等操作中提高效率。

6. 版本控制系统：如 Git 中的二分查找用于快速定位引入问题的提交。

7. 数据压缩：在霍夫曼编码等算法中查找最优解。

8. 人工智能：在超参数优化中使用二分查找确定最佳参数值。

总结

二分查找是一种高效的搜索算法，其核心思想是通过每次将搜索范围缩小一半来快速定位目标元素。掌握二分查找需要理解以下关键点：

1. 有序性：二分查找要求数据必须是有序的。
2. 边界处理：正确设置左右边界和循环条件，避免死循环和越界。
3. 中间值计算：使用mid = left + (right - left) / 2避免整数溢出。
4. 变体应用：能够处理查找左边界、右边界、旋转数组等变体问题。
5. 二分答案：将优化问题转化为判定问题，利用二分查找求解。

通过大量练习不同类型的二分查找题目，可以熟练掌握这种算法，并在实际应用中灵活运用，提高程序的性能和效率。无论是使用vector还是普通静态数组，二分查找的核心思想和实现逻辑都是一致的，只是在处理数组大小时略有不同。