<think>我们正在讨论C++标准库中的`
lower_
bound`和`
upper_
bound`
函数。这两个
函数通常用于已排序的序列（如数组、向量等），以进行高效的
二分查找。它们定义在`<algorithm>`头文件中。
### 1.
lower_
bound
- **功能**：在已排序的序列中查
找第一个**大于或等于**给定值的元素的位置。
- **
返回值**：
返回一个迭代器，指向第一个不小于（即大于或等于）给定值的元素。如果
找不到这样的元素，则
返回指向序列末尾的迭代器。
- **示例**：在数组`[1, 2, 3, 3, 5]`中查
找值`3`，`
lower_
bound`将
返回指向第一个`3`的迭代器（即索引2）。
### 2.
upper_
bound
- **功能**：在已排序的序列中查
找第一个**大于**给定值的元素的位置。
- **
返回值**：
返回一个迭代器，指向第一个大于给定值的元素。如果
找不到这样的元素，则
返回指向序列末尾的迭代器。
- **示例**：在同一个数组`[1, 2, 3, 3, 5]`中查
找值`3`，`
upper_
bound`将
返回指向`5`的迭代器（即索引4）。
### 3. 区别
- `
lower_
bound`
返回的是第一个**不小于**给定值的位置，而`
upper_
bound`
返回的是第一个**大于**给定值的位置。
- 对于同一个值，`
upper_
bound`
返回的位置一定不会小于`
lower_
bound`
返回的位置。
- 特别地，如果序列中没有给定值，那么`
lower_
bound`和`
upper_
bound`会
返回相同的位置，即第一个大于给定值的位置（也就是该值应该插入的位置，以保持有序）。
### 4. 使用示例
以下是一个C++代码示例：
```cpp
#include <iostream>
#include <algorithm>
#include <vector>
int main() {
std::vector<int> vec = {1, 2, 3, 3, 5};
int value = 3;
// 使用
lower_
bound和
upper_
bound
auto
lower = std::
lower_
bound(vec.begin(), vec.end(), value);
auto
upper = std::
upper_
bound(vec.begin(), vec.end(), value);
// 输出位置（索引）
std::cout << "
lower_
bound at position: " << (
lower - vec.begin()) << std::endl; // 输出2
std::cout << "
upper_
bound at position: " << (
upper - vec.begin()) << std::endl; // 输出4
// 遍历[
lower_
bound,
upper_
bound)之间的元素（即所有等于value的元素）
for (auto it =
lower; it !=
upper; ++it) {
std::cout << *it << " "; // 输出3 3
}
return 0;
}
```
### 5. 注意事项
- 序列必须是已排序的，否则结果未定义。
- 这两个
函数的时间复杂度为$O(\log n)$，因为内部使用
二分查找实现。
- 它们也可以用于自定义比较
函数，以支持不同的排序方式或自定义类型。
§§相关问题§§
1. `
lower_
bound`和`
upper_
bound`在自定义比较
函数时如何使用？
2. 如何利用`
lower_
bound`和`
upper_
bound`计算有序序列中某个值的出现次数？
3. 在非降序序列中，`
lower_
bound`和`
upper_
bound`
与在非升序序列中的使用有何不同？
4. 除了数组和向量，`
lower_
bound`和`
upper_
bound`还可以用于哪些容器？</think>### C++中`
lower_
bound`和`
upper_
bound`的
用法与区别
#### 1. 基本功能
- **`
lower_
bound`**：在**有序序列**中查
找第一个**大于或等于**目标值的元素位置
公式：$\text{
lower\_
bound}(v) = \min\\{i \mid a_i \geq v\\}$
- **`
upper_
bound`**：在**有序序列**中查
找第一个**大于**目标值的元素位置
公式：$\text{
upper\_
bound}(v) = \min\\{i \mid a_i > v\\}$
#### 2. 使用前提
- **必须对有序序列操作**（升序或自定义排序）
- 包含头文件：`#include <algorithm>`
- 时间复杂度：$O(\log n)$（
二分查找实现）
#### 3.
函数原型
```cpp
// 默认比较版本
template <class ForwardIt, class T>
ForwardIt
lower_
bound(ForwardIt first, ForwardIt last, const T& value);
template <class ForwardIt, class T>
ForwardIt
upper_
bound(ForwardIt first, ForwardIt last, const T& value);
// 自定义比较版本
template <class ForwardIt, class T, class Compare>
ForwardIt
lower_
bound(ForwardIt first, ForwardIt last, const T& value, Compare comp);
```
#### 4. 关键区别
|
函数 |
返回值含义 | 目标值存在时 | 目标值不存在时 |
|---------------|------------------------------|--------------------------|--------------------------|
| `
lower_
bound` | **首个 ≥ 目标值**的元素位置 | 指向第一个目标值 | 指向第一个 > 目标值的位置 |
| `
upper_
bound` | **首个 > 目标值**的元素位置 | 指向目标值**之后**的位置 | 同左 |
#### 5. 使用示例
```cpp
#include <iostream>
#include <algorithm>
#include <vector>
int main() {
std::vector<int> v = {10, 20, 30, 30, 40, 50};
int target = 30;
// 查
找范围 [begin, end)
auto low = std::
lower_
bound(v.begin(), v.end(), target);
auto up = std::
upper_
bound(v.begin(), v.end(), target);
std::cout << "
lower_
bound at index: " << (low - v.begin()) // 输出2
<< "\n
upper_
bound at index: " << (up - v.begin()); // 输出4
// 获取所有等于target的元素范围 [low, up)
for (auto it = low; it != up; ++it) {
std::cout << *it << " "; // 输出30 30
}
}
```
#### 6. 实际应用场景
1. **有序数据查
找**
```cpp
// 检查元素是否存在
bool exists = std::binary_search(v.begin(), v.end(), value);
```
2. **插入位置确定**
```cpp
v.insert(std::
lower_
bound(v.begin(), v.end(), new_value), new_value);
```
3. **统计元素出现次数**
```cpp
int count = std::
upper_
bound(v.begin(), v.end(), value)
- std::
lower_
bound(v.begin(), v.end(), value);
```
4. **范围查询**（如数据库查询）
```cpp
auto low = std::
lower_
bound(data.begin(), data.end(), min_val);
auto up = std::
upper_
bound(data.begin(), data.end(), max_val);
```
#### 7. 自定义比较
函数
```cpp
struct Person {
int id;
std::string name;
};
// 按id升序排序
auto comp = [](const Person& a, int b) { return a.id < b; };
std::vector<Person> people = {{3, "Alice"}, {5, "Bob"}, {7, "Charlie"}};
auto pos = std::
lower_
bound(people.begin(), people.end(), 5, comp); //
找到Bob
```
> **关键点总结**：
> - `
lower_
bound`
返回**首个 ≥ 目标**的位置，`
upper_
bound`
返回**首个 > 目标**的位置
> - 两者配合可精确锁定值域范围 $[\text{
lower\_
bound}, \text{
upper\_
bound})$
> - 操作前**必须确保序列有序**，否则行为未定义
> - 自定义类型需提供比较
函数（
与排序规则一致）
本文介绍了STL中用于二分查找的lower_bound与upper_bound函数。详细解释了这两个函数的使用方法及其返回值的意义，并通过实例展示了如何利用它们来确定特定元素在有序表中的存在及数量。
扫一扫
9604
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
