二分查找,lower_bound,upper_bound

本文探讨了LeetCode 15.3Sum问题的解决方案,提出了通过排序及二分查找的方法来降低时间复杂度,并实现了lower_bound与upper_bound函数以辅助搜索范围的确定。

LeetCode 15. 3Sum

想到的算法是排序之后二重循环a和b,然后二分查找第三个c,时间复杂度 O(n2log(n)) 。于是想手写一下二分查找。搜到了LeetCode: Search for a Range这一题。于是就写了lower_bound和upper_bound。

lower_bound & upper_bound

参考定义
* ForwardIter lower_bound(ForwardIter first, ForwardIter last,const _Tp& val)算法返回一个非递减序列[first, last)中的第一个大于等于值val的位置。
* ForwardIter upper_bound(ForwardIter first, ForwardIter last, const _Tp& val)算法返回一个非递减序列[first, last)中第一个大于val的位置。

Code

针对Search for a Range 这一题的实现如下。但是最后返回的结果还需要再经过判断range是否存在来决定。

int lower_bound(vector<int>& nums, int target) {
    // [lo, hi)
    int lo = 0;
    int hi = nums.size();
    int pos = -1;
    while (lo < hi) {
        int mi = lo + (hi - lo) / 2;
        target > nums[mi] ?  lo = mi + 1, pos = lo : hi = mi, pos = hi ;
    }
    return pos;
}

int upper_bound(vector<int>& nums, int target) {
    // [lo, hi)
    int lo = 0; 
    int hi = nums.size();
    int pos = -1;
    while (lo < hi) {
        int mi = lo + (hi - lo) / 2;
        target < nums[mi] ? hi = mi, pos = hi : lo = mi + 1, pos = lo ;
    }
    return pos;
}
### 关于 `lower_bound` 和 `upper_bound` 的使用方法及其区别 #### 定义与基本功能 在 C++ 标准库中,`lower_bound` 和 `upper_bound` 是两种基于二分查找算法,用于在有序容器(如数组或向量)中快速定位特定值的位置。两者均定义在头文件 `<algorithm>` 中[^2]。 - **`lower_bound`**: 查找第一个不小于指定值的元素位置。 - **`upper_bound`**: 查找第一个大于指定值的元素位置。 两者的返回值是一个指向目标位置的迭代器。如果需要获取具体索引,则可以通过减去容器起始地址来计算得出[^4]。 --- #### 使用示例 ##### 示例 1: 使用 `std::vector` 和 `std::array` 下面展示了一个完整的例子,演示如何分别调用 `lower_bound` 和 `upper_bound` 来完成不同类型的查询任务。 ```cpp #include <iostream> #include <vector> #include <array> #include <algorithm> int main() { std::vector<int> vec = {1, 3, 5, 7, 9}; int target = 5; // 使用 lower_bound 找到第一个 >= target 的元素 auto lb_it = std::lower_bound(vec.begin(), vec.end(), target); if (lb_it != vec.end()) { std::cout << "Lower bound of " << target << ": Position " << std::distance(vec.begin(), lb_it) << ", Value " << *lb_it << "\n"; } // 使用 upper_bound 找到第一个 > target 的元素 auto ub_it = std::upper_bound(vec.begin(), vec.end(), target); if (ub_it != vec.end()) { std::cout << "Upper bound of " << target << ": Position " << std::distance(vec.begin(), ub_it) << ", Value " << *ub_it << "\n"; } return 0; } ``` 此程序会输出如下结果: ``` Lower bound of 5: Position 2, Value 5 Upper bound of 5: Position 3, Value 7 ``` 这里可以看出,对于相同的输入值 `5`,`lower_bound` 返回的是该数值本身所在的位置;而 `upper_bound` 则跳过了这个数,指向下一个小于它的下一个可能取值处[^2]。 --- ##### 示例 2: 应用于普通数组 当面对静态分配的数组而非动态结构时,也可以同样应用这些函数。只需注意调整边界范围即可。 ```cpp #include <iostream> #include <algorithm> int main() { int arr[] = {1, 3, 5, 7, 9}; size_t size = sizeof(arr)/sizeof(*arr); int target = 6; // 对普通数组使用 lower_bound/upper_bound int* lb_ptr = std::lower_bound(arr, arr + size, target); if (lb_ptr != (arr + size)) { std::cout << "Lower bound pointer points to index " << (lb_ptr - arr) << ", with value " << *lb_ptr << "\n"; } int* ub_ptr = std::upper_bound(arr, arr + size, target); if (ub_ptr != (arr + size)) { std::cout << "Upper bound pointer points to index " << (ub_ptr - arr) << ", with value " << *ub_ptr << "\n"; } return 0; } ``` 运行上述代码片段可得类似结论——即针对任意形式存储单元上的连续内存块均可有效施行此类操作[^4]。 --- #### 主要差异对比表 | 属性 | `lower_bound` | `upper_bound` | |---------------------|---------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------| | **目的** | 寻找第一个 不小于 给定值的元素 | 寻找第一个 大于 给定值的元素 | | **返回条件** | 当前元素 ≥ 目标值 | 当前元素 > 目标值 | | **相等情况下的行为** | 若存在等于目标值的元素,返回其首次出现的位置 | 即使有匹配项也不会停留于此,继续前进直到遇到更大的数字 | 通过这样的表格总结可以帮助开发者更直观地区分二者之间的关系[^3]。 --- #### 注意事项 1. 输入序列必须已经按照升序排列好,否则可能导致不可预测的行为。 2. 如果找不到符合条件的项目,则返回超出末端的有效指示符 (`end()` 或者对应偏移后的地址)。 3. 结果是以迭代器的形式给出,转换成实际下标需额外运算步骤。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值