<think>首先，用户的问题是：“我想查找
lower_
bound和
upper_
bound的实现方法或
使用示例 请问
C++ lower_
bound 和
upper_
bound 的用法和实现”。系统指令要求我
使用中文回答，结构清晰，逐步解决问题，并保证回答真实可靠。
系统指令还指定了格式：
- 行内数学表达式
使用$...$，例如 $x^2$。
- 独立公式
使用$$...$$并单独成段。
- LaTeX语法正确。
- 生成相关问题。
- 在引用的段落末尾添加引用标识，如[^1]。
参考的站内引用：
- 引用[1]：提到set和
map有自己的
lower_
bound和
upper_
bound，效率高于
STL中的通用版本。
- 引用[2]：给出了
lower_
bound的实现代码。
- 引用[3]：展示了std
::lower_
bound和std
::upper_
bound在
map中的
使用示例。
- 引用[4]：解释了
lower_
bound和
upper_
bound的常见用法，包括参数和返回值。
我需要基于这些引用构建回答。用户要求的是
lower_
bound和
upper_
bound的用法和实现方法。
结构化回答：
1. **引言**：简要介绍
lower_
bound和
upper_
bound是什么。
2. **用法**：解释如何在
C++中
使用它们，包括在vector和
map中的示例。
3. **实现方法**：提供或描述算法的实现。
4. **示例**：给出代码示例。
5. **相关问题**：生成相关问题。
确保回答真实可靠：基于标准
C++库的知识，引用提供的资料。
关键点：
-
lower_
bound：返回第一个大于或等于给定值的元素的迭代器。
-
upper_
bound：返回第一个大于给定值的元素的迭代器。
- 在有序容器中
使用，如vector、set、
map。
从引用[2]，有
lower_
bound的实现代码：
```c
int
lower_
bound(int *array, int size, int val) {
int first = 0;
int len = size;
while (len > 0) {
int half = len >> 1;
int middle = first + half;
if (array[middle] < val) {
first = middle + 1;
len = len - half - 1;
} else {
len = half;
}
}
return first;
}
```
这是一个二分查找的实现。
从引用[3]，有
map中的
使用示例：
```
c++
#include <iostream>
#include <
map>
int main() {
std
::map<char, int> my
map;
std
::map<char, int>
::iterator itlow, itup;
my
map['a'] = 20;
my
map['b'] = 40;
my
map['c'] = 60;
my
map['d'] = 80;
my
map['e'] = 100;
itlow = my
map.
lower_
bound('b'); // points to 'b'
itup = my
map.
upper_
bound('d'); // points to 'e'
my
map.erase(itlow, itup); // erases from 'b' to 'd'
for (auto it = my
map.begin(); it != my
map.end(); ++it)
std
::cout << it->first << " => " << it->second << '\n';
return 0;
}
```
输出应为a和e。
从引用[4]，
lower_
bound的用法描述：在数组中找到第一个大于或等于num的元素，返回地址或下标。
生成相关问题：
1.
lower_
bound和
upper_
bound在无序容器中能用吗？
2. 如何用
lower_
bound实现二分查找？
3. 在自定义比较函数时如何
使用它们？
回答结构：
- 先解释概念。
- 提供用法。
- 展示实现。
- 给出示例。
- 添加相关问题。
确保
使用中文。</think>###
C++ `
lower_
bound` 和 `
upper_
bound` 的用法与实现
在
C++ 标准库中，`
lower_
bound` 和 `
upper_
bound` 是用于有序序列（如数组、`vector`、`set`、`
map`）的高效二分查找算法。它们基于二分查找原理，时间复杂度为 $O(\log n)$。下面我将从用法、实现方法和示例三个方面详细解释，确保内容真实可靠（基于
C++ 标准和常见实践）。
---
#### 1. **核心概念和用法**
- **`
lower_
bound`**：返回序列中第一个**大于或等于**给定值的元素的迭代器（或下标）。如果值不存在，返回指向序列末尾的迭代器。
数学描述：在有序序列 $[begin, end)$ 中，找到最小索引 $i$ 满足 $a_i \geq val$。
- **`
upper_
bound`**：返回序列中第一个**大于**给定值的元素的迭代器（或下标）。如果值不存在，返回序列末尾。
数学描述：在有序序列 $[begin, end)$ 中，找到最小索引 $i$ 满足 $a_i > val$。
- **适用容器**：需有序序列，如 `std
::vector`, `std
::set`, `std
::map`。对于关联容器（如 `set` 和 `
map`），优先
使用其成员函数版本（`set.
lower_
bound(val)`），效率更高，因为直接利用内部树结构[^1]。
- **参数格式**：
```cpp
// 通用版本（适用于 vector 等）
iterator
lower_
bound(iterator begin, iterator end, const T& val);
iterator
upper_
bound(iterator begin, iterator end, const T& val);
// 成员函数版本（适用于 set/
map）
set.
lower_
bound(val); // 返回 set 的迭代器
map.
lower_
bound(key); // 返回
map 的迭代器
```
- **返回值**：迭代器或下标。通过 `std
::distance(begin, iter)` 可获取下标。
---
#### 2. **实现方法（基于二分查找）**
这两个函数的底层实现是二分查找。以下是 `
lower_
bound` 的经典实现（基于引用[2]的代码，优化为
C++ 风格）：
```cpp
//
lower_
bound 实现：在有序数组 array 中查找 val
template <typename T>
int
lower_
bound(T* array, int size, T val) {
int first = 0;
int len = size;
while (len > 0) {
int half = len >> 1; // 等价于 len / 2
int middle = first + half;
if (array[middle] < val) {
first = middle + 1;
len = len - half - 1; // 调整剩余长度
} else {
len = half; // 调整剩余长度
}
}
return first; // 返回下标
}
```
- **算法原理**：
- 初始化 `first=0` 和 `len=size`，表示搜索区间 $[first, first+len)$。
- 循环中，计算中点 `middle`。如果中点值小于 `val`，则搜索右半区间；否则搜索左半区间。
- 最终返回 `first`，即第一个 $\geq val$ 的元素下标。
- **`
upper_
bound` 实现**：类似 `
lower_
bound`，但条件改为 `if (array[middle] <= val)`，确保找到第一个 $> val$ 的元素。
- **数学保证**：二分查找确保时间复杂度为 $O(\log n)$，空间复杂度 $O(1)$。
---
#### 3. **
使用示例**
下面通过 `vector` 和 `
map` 的示例展示具体用法（基于引用[3]和引用[4]）。
**示例 1：在 vector 中查找下标**
```cpp
#include <iostream>
#include <vector>
#include <algorithm> // 需要包含此头文件
int main() {
std
::vector<int> vec = {10, 20, 30, 30, 40, 50};
int val = 30;
//
lower_
bound：返回第一个 >=30 的元素迭代器
auto low = std
::lower_
bound(vec.begin(), vec.end(), val);
int low_idx = std
::distance(vec.begin(), low); // 下标计算
std
::cout << "
lower_
bound 下标
: " << low_idx << " (值
: " << *low << ")\n"; // 输出
: 下标
: 2 (值
: 30)
//
upper_
bound：返回第一个 >30 的元素迭代器
auto up = std
::upper_
bound(vec.begin(), vec.end(), val);
int up_idx = std
::distance(vec.begin(), up);
std
::cout << "
upper_
bound 下标
: " << up_idx << " (值
: " << *up << ")\n"; // 输出
: 下标
: 4 (值
: 40)
// 应用：删除所有值为 30 的元素
vec.erase(std
::lower_
bound(vec.begin(), vec.end(), 30), std
::upper_
bound(vec.begin(), vec.end(), 30));
for (int x
: vec) std
::cout << x << " "; // 输出
: 10 20 40 50
return 0;
}
```
**示例 2：在
map 中
使用成员函数（高效版）**
```cpp
#include <iostream>
#include <
map>
int main() {
std
::map<char, int> my
map;
my
map['a'] = 20;
my
map['b'] = 40;
my
map['c'] = 60;
my
map['d'] = 80;
my
map['e'] = 100;
//
使用 map 的成员函数
lower_
bound/
upper_
bound
auto itlow = my
map.
lower_
bound('b'); // 指向 'b' (键值 >= 'b')
auto itup = my
map.
upper_
bound('d'); // 指向 'e' (键值 > 'd')
// 删除区间 [itlow, itup)（即 'b' 到 'd'）
my
map.erase(itlow, itup);
// 输出剩余元素
for (auto it = my
map.begin(); it != my
map.end(); ++it)
std
::cout << it->first << " => " << it->second << '\n';
// 输出
: a => 20, e => 100
return 0;
}
```
- **关键点**：
- 在 `
map` 中，`
lower_
bound('b')` 返回指向键 `'b'` 的迭代器，`
upper_
bound('d')` 返回指向 `'e'` 的迭代器（因为 `'e'` 是第一个大于 `'d'` 的键）[^3]。
- 成员函数版本比通用 `std
::lower_
bound` 更快，因为它直接利用红黑树结构[^1]。
---
#### 注意事项
- **序列必须有序**：
使用前确保容器已排序，否则行为未定义。
- **自定义比较**：支持传入比较函数，如 `std
::lower_
bound(vec.begin(), vec.end(), val, custom_comp)`。
- **性能**：二分查找确保高效，但频繁插入/删除时，优先选择 `set/
map`。
---
本文介绍C++ STL中map::lower_bound与map::upper_bound的使用方法，通过示例程序展示了如何寻找指定键值及其之后的第一个元素，并演示了如何利用这两个函数删除指定范围内的元素。
扫一扫
277
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
