命名空间
变体
操作

算法库

来自 cppreference.cn
 
C++
 
算法库
有约束算法与针对范围的算法 (C++20)
有约束的算法，例如 ranges::copy、 ranges::sort 等……
执行策略 (C++17)
排序及相关操作
划分操作
排序操作
二分搜索操作
（于已划分范围上）
集合操作（于已排序范围上）
归并操作（于已排序范围上）
堆操作
最小/最大值操作
(C++11)
(C++17)
字典序比较操作
(C++20)
排列操作
C 库
数值操作
未初始化内存上的操作
 

算法库定义了用于各种目的（例如搜索、排序、计数、操作）的函数，这些函数作用于元素范围。请注意，范围定义为 [first, last)，其中 last 指的是要检查或修改的最后一个元素“之后”的元素。

目录

[编辑] 约束算法 (C++20 起)

C++20 在命名空间 std::ranges 中提供了大多数算法的约束版本。在这些算法中，范围可以指定为迭代器-哨兵对，也可以指定为单个 range 参数，并且支持投影和指向成员的函数对象。此外，大多数算法的返回类型已更改为返回在算法执行期间计算的所有潜在有用信息。

std::vector<int> v{7, 1, 4, 0, -1};
std::ranges::sort(v); // constrained algorithm

[编辑] 执行策略 (C++17 起)

大多数算法都有接受执行策略的重载。标准库算法支持多种执行策略，库提供了相应的执行策略类型和对象。用户可以通过调用具有相应类型的执行策略对象的并行算法来静态选择执行策略。

标准库实现（但非用户）可以定义额外的执行策略作为扩展。使用实现定义类型的执行策略对象调用的并行算法的语义是实现定义的。

并行版本的算法（std::for_each 和 std::for_each_n 除外）允许任意复制范围中的元素，只要 std::is_trivially_copy_constructible_v<T> 和 std::is_trivially_destructible_v<T> 均为 true，其中 T 是元素的类型。

定义于头文件 <execution>
定义于命名空间 std::execution
(C++17)(C++17)(C++17)(C++20)
 执行策略类型
(类) [编辑]
(C++17)(C++17)(C++17)(C++20)
 全局执行策略对象
(常量) [编辑]
定义于命名空间 std
(C++17)
 测试一个类是否表示执行策略
(类模板) [编辑]
特性测试宏 值 标准 特性
__cpp_lib_parallel_algorithm 201603L (C++17) 并行算法
__cpp_lib_execution 201603L (C++17) 执行策略
201902L (C++20) std::execution::unsequenced_policy

[编辑] 非修改序列操作

[编辑] 批处理操作

定义于头文件 <algorithm>
 对范围中的元素应用一元函数对象
(函数模板) [编辑]
(C++20)
 对范围中的元素应用一元函数对象
(算法函数对象)[编辑]
(C++17)
 对序列中的前 N 个元素应用函数对象
(函数模板) [编辑]
(C++20)
 对序列中的前 N 个元素应用函数对象
(算法函数对象)[编辑]

[编辑] 搜索操作

定义于头文件 <algorithm>
(C++11)(C++11)(C++11)
 检查范围中的所有、任意一个或没有元素使谓词为 true
(函数模板) [编辑]
(C++20)(C++20)(C++20)
 检查范围中的所有、任意一个或没有元素使谓词为 true
(算法函数对象)[编辑]
(C++23)(C++23)
 检查范围是否包含给定的元素或子范围
(算法函数对象)[编辑]
(C++11)
 寻找第一个满足特定条件的元素
(函数模板) [编辑]
(C++20)(C++20)(C++20)
 寻找第一个满足特定条件的元素
(算法函数对象)[编辑]
(C++23)(C++23)(C++23)
 寻找最后一个满足特定条件的元素
(算法函数对象)[编辑]
 在特定范围中寻找最后一次出现的元素序列
(函数模板) [编辑]
(C++20)
 在特定范围中寻找最后一次出现的元素序列
(算法函数对象)[编辑]
 搜索一组元素中的任何一个
(函数模板) [编辑]
(C++20)
 搜索一组元素中的任何一个
(算法函数对象)[编辑]
 寻找第一对相等的（或满足给定谓词的）相邻项
(函数模板) [编辑]
(C++20)
 寻找第一对相等的（或满足给定谓词的）相邻项
(算法函数对象)[编辑]
 返回满足特定条件的元素数量
(函数模板) [编辑]
(C++20)(C++20)
 返回满足特定条件的元素数量
(算法函数对象)[编辑]
 寻找两个范围开始不同的第一个位置
(函数模板) [编辑]
(C++20)
 寻找两个范围开始不同的第一个位置
(算法函数对象)[编辑]
 判断两组元素是否相同
(函数模板) [编辑]
(C++20)
 判断两组元素是否相同
(算法函数对象)[编辑]
 搜索一个范围的元素首次出现的位置
(函数模板) [编辑]
(C++20)
 搜索一个范围的元素首次出现的位置
(算法函数对象)[编辑]
 在一个范围内搜索一个元素的连续 N 次副本首次出现的位置
(函数模板) [编辑]
(C++20)
 在一个范围内搜索一个元素的连续 N 次副本首次出现的位置
(算法函数对象)[编辑]
(C++23)
 检查一个范围是否以另一个范围开始
(算法函数对象)[编辑]
(C++23)
 检查一个范围是否以另一个范围结束
(算法函数对象)[编辑]

[编辑] 折叠操作 (C++23 起)

定义于头文件 <algorithm>
(C++23)
 对一个范围的元素进行左折叠
(算法函数对象)[编辑]
(C++23)
 使用第一个元素作为初始值对一个范围的元素进行左折叠
(算法函数对象)[编辑]
(C++23)
 对一个范围的元素进行右折叠
(算法函数对象)[编辑]
(C++23)
 使用最后一个元素作为初始值对一个范围的元素进行右折叠
(算法函数对象)[编辑]
(C++23)
 对一个范围的元素进行左折叠，并返回一个 pair (迭代器, 值)
(算法函数对象)[编辑]
(C++23)
 使用第一个元素作为初始值对元素范围进行左折叠，并返回 pair (迭代器, optional)
(算法函数对象)[编辑]

[编辑] 修改序列操作

[编辑] 复制操作

定义于头文件 <algorithm>
(C++11)
 将一个范围的元素复制到一个新位置
(函数模板) [编辑]
(C++20)(C++20)
 将一个范围的元素复制到一个新位置
(算法函数对象)[编辑]
(C++11)
 将一定数量的元素复制到一个新位置
(函数模板) [编辑]
(C++20)
 将一定数量的元素复制到一个新位置
(算法函数对象)[编辑]
 以逆序复制一个范围的元素
(函数模板) [编辑]
(C++20)
 以逆序复制一个范围的元素
(算法函数对象)[编辑]
(C++11)
 将一个范围的元素移动到一个新位置
(函数模板) [编辑]
(C++20)
 将一个范围的元素移动到一个新位置
(算法函数对象)[编辑]
(C++11)
 以逆序将一个范围的元素移动到一个新位置
(函数模板) [编辑]
(C++20)
 以逆序将一个范围的元素移动到一个新位置
(算法函数对象)[编辑]

[编辑] 交换操作

定义于头文件 <algorithm>   (C++11 前)
定义于头文件 <utility>     (C++11 起)
定义于头文件 <string_view>
 交换两个对象的值
(函数模板) [编辑]
定义于头文件 <algorithm>
 交换两个范围的元素
(函数模板) [编辑]
(C++20)
 交换两个范围的元素
(算法函数对象)[编辑]
 交换两个迭代器所指向的元素
(函数模板) [编辑]

[编辑] 转换操作

定义于头文件 <algorithm>
 对一个范围的元素应用函数，并将结果存储在目标范围中
(函数模板) [编辑]
(C++20)
 对一个范围的元素应用函数
(算法函数对象)[编辑]
 用另一个值替换所有满足特定条件的值
(函数模板) [编辑]
(C++20)(C++20)
 用另一个值替换所有满足特定条件的值
(算法函数对象)[编辑]
 复制一个范围，同时用另一个值替换满足特定条件的元素
(函数模板) [编辑]
(C++20)(C++20)
 复制一个范围，同时用另一个值替换满足特定条件的元素
(算法函数对象)[编辑]

[编辑] 生成操作

定义于头文件 <algorithm>
 将给定值复制赋给一个范围中的每个元素
(函数模板) [编辑]
(C++20)
 给一个范围的元素赋某个值
(算法函数对象)[编辑]
 将给定值复制赋给一个范围中的 N 个元素
(函数模板) [编辑]
(C++20)
 给一定数量的元素赋一个值
(算法函数对象)[编辑]
 将连续函数调用的结果赋给一个范围中的每个元素
(函数模板) [编辑]
(C++20)
 将一个函数的结果保存在一个范围中
(算法函数对象)[编辑]
 将连续函数调用的结果赋给一个范围中的 N 个元素
(函数模板) [编辑]
(C++20)
 保存 N 次应用一个函数的结果
(算法函数对象)[编辑]

[编辑] 移除操作

定义于头文件 <algorithm>
 移除满足特定标准的元素
(函数模板) [编辑]
(C++20)(C++20)
 移除满足特定标准的元素
(算法函数对象)[编辑]
 复制一个范围的元素，忽略那些满足特定条件的元素
(函数模板) [编辑]
(C++20)(C++20)
 复制一个范围的元素，忽略那些满足特定条件的元素
(算法函数对象)[编辑]
 移除一个范围中的连续重复元素
(函数模板) [编辑]
(C++20)
 移除一个范围中的连续重复元素
(算法函数对象)[编辑]
 创建一个不含连续重复元素的某个元素范围的副本
(函数模板) [编辑]
(C++20)
 创建一个不含连续重复元素的某个元素范围的副本
(算法函数对象)[编辑]

[编辑] 改变顺序操作

定义于头文件 <algorithm>
 反转一个范围中元素的顺序
(函数模板) [编辑]
(C++20)
 反转一个范围中元素的顺序
(算法函数对象)[编辑]
 创建一个反转后的范围副本
(函数模板) [编辑]
(C++20)
 创建一个反转后的范围副本
(算法函数对象)[编辑]
 旋转一个范围中元素的顺序
(函数模板) [编辑]
(C++20)
 旋转一个范围中元素的顺序
(算法函数对象)[编辑]
 复制并旋转一个范围的元素
(函数模板) [编辑]
(C++20)
 复制并旋转一个范围的元素
(算法函数对象)[编辑]
(C++20)
 移动一个范围中的元素
(函数模板) [编辑]
(C++23)
 移动一个范围中的元素
(算法函数对象)[编辑]
(C++17 前)(C++11)
 随机地重排一个范围中的元素
(函数模板) [编辑]
(C++20)
 随机地重排一个范围中的元素
(算法函数对象)[编辑]

[编辑] 采样操作

定义于头文件 <algorithm>
(C++17)
 从一个序列中选择 N 个随机元素
(函数模板) [编辑]
(C++20)
 从一个序列中选择 N 个随机元素
(算法函数对象)[编辑]

[编辑] 排序及相关操作

[编辑] 要求

某些算法要求由参数表示的序列是“已排序”或“已分区”的。如果未满足要求，则行为未定义。

如果对于序列的每个迭代器 iter 和每个非负整数 n（使得 iter + n[1] 是指向序列元素的有效迭代器），comp(*(iter + n), *iter) == false[1]，则序列相对于比较器 comp 已排序。

 (C++20 前)

如果对于比较器 comp 和投影 proj，序列相对于 comp 和 proj 已排序，则对于序列的每个迭代器 iter 和每个非负整数 n（使得 iter + n[1] 是指向序列元素的有效迭代器），bool(std::invoke(comp, std::invoke(proj, *(iter + n)),
                       std::invoke(proj, *iter)))[1] 为 false。

如果序列相对于 comp 和 std::identity{}（恒等投影）已排序，则序列相对于比较器 comp 已排序。

 (C++20 起)

如果存在整数 n，使得对于 [​0​, std::distance(start, finish)) 中的所有 i，f(*(start + i))[1] 为 true 当且仅当 i < n，则序列 [start, finish) 相对于表达式 f(e) 已分区。

  1. ↑ 1.0 1.1 1.2 1.3 1.4 iter + n 简单地表示“iter 递增 n 次的结果”，而不管 iter 是否为随机访问迭代器。

[编辑] 分区操作

定义于头文件 <algorithm>
(C++11)
 判断一个范围是否按给定谓词划分
(函数模板) [编辑]
(C++20)
 判断一个范围是否按给定谓词划分
(算法函数对象)[编辑]
 将一个范围的元素分成两组
(函数模板) [编辑]
(C++20)
 将一个范围的元素分成两组
(算法函数对象)[编辑]
(C++11)
 复制一个范围，并将元素分成两组
(函数模板) [编辑]
(C++20)
 复制一个范围，并将元素分成两组
(算法函数对象)[编辑]
 将元素分成两组，同时保留它们的相对顺序
(函数模板) [编辑]
(C++20)
 将元素分成两组，同时保留它们的相对顺序
(算法函数对象)[编辑]
(C++11)
 定位一个已划分范围的划分点
(函数模板) [编辑]
(C++20)
 定位一个已划分范围的划分点
(算法函数对象)[编辑]

[编辑] 排序操作

定义于头文件 <algorithm>
 将一个范围按升序排序
(函数模板) [编辑]
(C++20)
 将一个范围按升序排序
(算法函数对象)[编辑]
 对一个范围的元素进行排序，同时保留相等元素之间的顺序
(函数模板) [编辑]
(C++20)
 对一个范围的元素进行排序，同时保留相等元素之间的顺序
(算法函数对象)[编辑]
 对一个范围的前 N 个元素进行排序
(函数模板) [编辑]
(C++20)
 对一个范围的前 N 个元素进行排序
(算法函数对象)[编辑]
 复制并部分排序一个范围的元素
(函数模板) [编辑]
(C++20)
 复制并部分排序一个范围的元素
(算法函数对象)[编辑]
(C++11)
 检查一个范围是否按升序排序
(函数模板) [编辑]
(C++20)
 检查一个范围是否按升序排序
(算法函数对象)[编辑]
(C++11)
 寻找最大的已排序子范围
(函数模板) [编辑]
(C++20)
 寻找最大的已排序子范围
(算法函数对象)[编辑]
 部分排序给定的范围，确保它被给定的元素划分
(函数模板) [编辑]
(C++20)
 部分排序给定的范围，确保它被给定的元素划分
(算法函数对象)[编辑]

[编辑] 二分搜索操作（在分区范围内）

定义于头文件 <algorithm>
 返回一个指向第一个不小于给定值的元素的迭代器
(函数模板) [编辑]
(C++20)
 返回一个指向第一个不小于给定值的元素的迭代器
(算法函数对象)[编辑]
 返回一个指向第一个大于某个值的元素的迭代器
(函数模板) [编辑]
(C++20)
 返回一个指向第一个大于某个值的元素的迭代器
(算法函数对象)[编辑]
 返回与特定键匹配的元素范围
(函数模板) [编辑]
(C++20)
 返回与特定键匹配的元素范围
(算法函数对象)[编辑]
 判断一个元素是否存在于部分有序的范围中
(函数模板) [编辑]
(C++20)
 判断一个元素是否存在于部分有序的范围中
(算法函数对象)[编辑]

[编辑] 集合操作（在排序范围内）

定义于头文件 <algorithm>
 如果一个序列是另一个序列的子序列，则返回 true
(函数模板) [编辑]
(C++20)
 如果一个序列是另一个序列的子序列，则返回 true
(算法函数对象)[编辑]
 计算两个集合的并集
(函数模板) [编辑]
(C++20)
 计算两个集合的并集
(算法函数对象)[编辑]
 计算两个集合的交集
(函数模板) [编辑]
(C++20)
 计算两个集合的交集
(算法函数对象)[编辑]
 计算两个集合的差集
(函数模板) [编辑]
(C++20)
 计算两个集合的差集
(算法函数对象)[编辑]
 计算两个集合的对称差
(函数模板) [编辑]
(C++20)
 计算两个集合的对称差
(算法函数对象)[编辑]

[编辑] 合并操作（在排序范围内）

定义于头文件 <algorithm>
 归并两个已排序的范围
(函数模板) [编辑]
(C++20)
 归并两个已排序的范围
(算法函数对象)[编辑]
 就地归并两个有序范围
(函数模板) [编辑]
(C++20)
 就地归并两个有序范围
(算法函数对象)[编辑]

[编辑] 堆操作

如果对于 (​0​, last - first) 中的所有整数 i，bool(comp(first[(i - 1) / 2], first[i])) 为 false，则随机访问范围 [first, last) 相对于比较器 comp 是堆。

 (C++20 前)

如果对于比较器 comp 和投影 proj，随机访问范围 [first, last) 相对于 comp 和 proj 是堆，则对于 (​0​, last - first) 中的所有整数 i，bool(std::invoke(comp, std::invoke(proj, first[(i - 1) / 2]),
                       std::invoke(proj, first[i])) 为 false。

如果范围相对于 comp 和 std::identity{}（恒等投影）是堆，则随机访问范围 [first, last) 相对于比较器 comp 是堆。

 (C++20 起)

堆可以通过 std::make_heap 和 ranges::make_heap(C++20 起) 创建。

有关堆的更多属性，请参见 最大堆。


定义于头文件 <algorithm>
 向一个最大堆添加一个元素
(函数模板) [编辑]
(C++20)
 向一个最大堆添加一个元素
(算法函数对象)[编辑]
 从一个最大堆中移除最大的元素
(函数模板) [编辑]
(C++20)
 从一个最大堆中移除最大的元素
(算法函数对象)[编辑]
 从一个元素范围创建一个最大堆
(函数模板) [编辑]
(C++20)
 从一个元素范围创建一个最大堆
(算法函数对象)[编辑]
 将一个最大堆转换成一个按升序排序的元素范围
(函数模板) [编辑]
(C++20)
 将一个最大堆转换成一个按升序排序的元素范围
(算法函数对象)[编辑]
(C++11)
 检查给定的范围是否是一个最大堆
(函数模板) [编辑]
(C++20)
 检查给定的范围是否是一个最大堆
(算法函数对象)[编辑]
(C++11)
 寻找是一个最大堆的最大子范围
(函数模板) [编辑]
(C++20)
 寻找是一个最大堆的最大子范围
(算法函数对象)[编辑]

[编辑] 最小/最大操作

定义于头文件 <algorithm>
 返回给定值中较大的那个
(函数模板) [编辑]
(C++20)
 返回给定值中较大的那个
(算法函数对象)[编辑]
 返回一个范围中最大的元素
(函数模板) [编辑]
(C++20)
 返回一个范围中最大的元素
(算法函数对象)[编辑]
 返回给定值中较小的那个
(函数模板) [编辑]
(C++20)
 返回给定值中较小的那个
(算法函数对象)[编辑]
 返回一个范围中最小的元素
(函数模板) [编辑]
(C++20)
 返回一个范围中最小的元素
(算法函数对象)[编辑]
(C++11)
 返回两个元素中较小和较大的一个
(函数模板) [编辑]
(C++20)
 返回两个元素中较小和较大的一个
(算法函数对象)[编辑]
(C++11)
 返回范围中最小和最大的元素
(函数模板) [编辑]
(C++20)
 返回范围中最小和最大的元素
(算法函数对象)[编辑]
(C++17)
 将值限制在边界值对之间
(函数模板) [编辑]
(C++20)
 将值限制在边界值对之间
(算法函数对象)[编辑]

[编辑] 字典序比较操作

定义于头文件 <algorithm>
 如果一个范围在字典上小于另一个范围，则返回 true
(函数模板) [编辑]
(C++20)
 如果一个范围在字典上小于另一个范围，则返回 true
(算法函数对象)[编辑]
(C++20)
 使用三路比较比较两个范围
(函数模板) [编辑]

[编辑] 排列操作

定义于头文件 <algorithm>
 生成元素范围的下一个更大的字典序排列
(函数模板) [编辑]
(C++20)
 生成元素范围的下一个更大的字典序排列
(算法函数对象)[编辑]
 生成元素范围的下一个更小的字典序排列
(函数模板) [编辑]
(C++20)
 生成元素范围的下一个更小的字典序排列
(算法函数对象)[编辑]
(C++11)
 确定一个序列是否是另一个序列的排列
(函数模板) [编辑]
(C++20)
 确定一个序列是否是另一个序列的排列
(算法函数对象)[编辑]

[编辑] 数值操作

定义于头文件 <numeric>
(C++11)
 以起始值的连续增量填充一个范围
(函数模板) [编辑]
(C++23)
 以起始值的连续增量填充一个范围
(算法函数对象)[编辑]
 对一个范围的元素进行求和或折叠
(函数模板) [编辑]
 计算两个元素范围的内积
(函数模板) [编辑]
 计算一个范围内相邻元素之间的差值
(函数模板) [编辑]
 计算一个范围元素的部分和
(函数模板) [编辑]
(C++17)
 类似于 std::accumulate，但顺序是乱序的
(函数模板) [编辑]
(C++17)
 类似于 std::partial_sum，将第 i 个输入元素从第 i 个和中排除
(函数模板) [编辑]
(C++17)
 类似于 std::partial_sum，将第 i 个输入元素包含在第 i 个和中
(函数模板) [编辑]
(C++17)
 应用一个可调用对象，然后进行乱序归约
(函数模板) [编辑]
(C++17)
 应用一个可调用对象，然后计算排除扫描
(函数模板) [编辑]
(C++17)
 应用一个可调用对象，然后计算包含扫描
(函数模板) [编辑]

[编辑] 未初始化内存上的操作

定义于头文件 <memory>
 将对象范围复制到未初始化内存区域
(函数模板) [编辑]
(C++20)
 将对象范围复制到未初始化内存区域
(算法函数对象)[编辑]
(C++11)
 将一定数量的对象复制到未初始化内存区域
(函数模板) [编辑]
(C++20)
 将一定数量的对象复制到未初始化内存区域
(算法函数对象)[编辑]
 将对象复制到由范围定义的未初始化内存区域
(函数模板) [编辑]
(C++20)
 将对象复制到由范围定义的未初始化内存区域
(算法函数对象)[编辑]
 将对象复制到由起始和计数定义的未初始化内存区域
(函数模板) [编辑]
(C++20)
 将对象复制到由起始和计数定义的未初始化内存区域
(算法函数对象)[编辑]
(C++17)
 将一系列对象移动到未初始化内存区域
(函数模板) [编辑]
(C++20)
 将一系列对象移动到未初始化内存区域
(算法函数对象)[编辑]
(C++17)
 将多个对象移动到未初始化内存区域
(函数模板) [编辑]
(C++20)
 将多个对象移动到未初始化内存区域
(算法函数对象)[编辑]
(C++17)
 通过默认初始化在由范围定义的未初始化内存区域中构造对象
(函数模板) [编辑]
(C++20)
 通过默认初始化在由范围定义的未初始化内存区域中构造对象
(算法函数对象)[编辑]
(C++17)
 在由起始和计数定义的未初始化内存区域中，通过默认初始化构造对象
(函数模板) [编辑]
(C++20)
 通过默认初始化在由起始和计数定义的未初始化内存区域中构造对象
(算法函数对象)[编辑]
(C++17)
 在由范围定义的未初始化内存区域中，通过值初始化构造对象
(函数模板) [编辑]
(C++20)
 在由范围定义的未初始化内存区域中，通过值初始化构造对象
(算法函数对象)[编辑]
(C++17)
 在由起始和计数定义的未初始化内存区域中，通过值初始化构造对象
(函数模板) [编辑]
(C++20)
 在由起始和计数定义的未初始化内存区域中，通过值初始化构造对象
(算法函数对象)[编辑]
(C++17)
 销毁对象范围
(函数模板) [编辑]
(C++20)
 销毁对象范围
(算法函数对象)[编辑]
(C++17)
 销毁范围内的多个对象
(函数模板) [编辑]
(C++20)
 销毁范围内的多个对象
(算法函数对象)[编辑]
(C++17)
 销毁给定地址处的对象
(函数模板) [编辑]
(C++20)
 销毁给定地址处的对象
(算法函数对象)[编辑]
(C++20)
 在给定地址创建对象
(函数模板) [编辑]
(C++20)
 在给定地址创建对象
(算法函数对象)[编辑]

[编辑] 随机数生成 (自 C++26 起)

定义于头文件 <random>
(C++26)
 用来自均匀随机位生成器的随机数填充范围
(算法函数对象)[编辑]

[编辑] 注意

特性测试宏 值 标准 特性
__cpp_lib_algorithm_iterator_requirements 202207L (C++23) Ranges 迭代器作为非 Ranges 算法的输入
__cpp_lib_clamp 201603L (C++17) std::clamp
__cpp_lib_constexpr_algorithms 201806L (C++20) 算法的 constexpr
202306L (C++26) constexpr 稳定排序
__cpp_lib_algorithm_default_value_type 202403L (C++26) 算法的列表初始化
__cpp_lib_freestanding_algorithm 202311L (C++26) <algorithm> 中的独立设施
__cpp_lib_robust_nonmodifying_seq_ops 201304L (C++14) 使非修改序列操作更健壮（std::mismatch、std::equal 和 std::is_permutation 的双范围重载）
__cpp_lib_sample 201603L (C++17) std::sample
__cpp_lib_shift 201806L (C++20) std::shift_left 和 std::shift_right

[编辑] C 库

定义于头文件 <cstdlib>
 对未指定类型的元素范围进行排序
(函数) [编辑]
 在数组中搜索未指定类型的元素
(函数) [编辑]

[编辑] 缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告 应用于 发布时的行为 正确的行为
LWG 193 C++98 堆要求 *first 是最大元素 可能存在
等于 *first 的元素
LWG 2150 C++98 排序序列的定义不正确 已更正
LWG 2166 C++98 堆要求与
最大堆的定义不够匹配		 要求已改进

[编辑] 另请参阅

C 文档，关于 算法
取自 "https://cppreference.cn/mwiki/index.php?title=cpp/algorithm&oldid=180667"