命名空间
变体
操作

算法库

来自 cppreference.cn
< cpp
 
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)
 搜索元素范围的第一次出现
(算法函数对象)[编辑]
 搜索范围内元素的连续副本的第一次出现
(函数模板) [编辑]
(C++20)
 搜索范围内元素的连续副本的第一次出现
(算法函数对象)[编辑]
(C++23)
 检查一个范围是否以另一个范围开始
(算法函数对象)[编辑]
(C++23)
 检查一个范围是否以另一个范围结束
(算法函数对象)[编辑]

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

定义于头文件 <algorithm>
(C++23)
 左折叠元素范围
(算法函数对象)[编辑]
(C++23)
 使用第一个元素作为初始值左折叠元素范围
(算法函数对象)[编辑]
(C++23)
 右折叠元素范围
(算法函数对象)[编辑]
(C++23)
 使用最后一个元素作为初始值右折叠元素范围
(算法函数对象)[编辑]
(C++23)
 左折叠元素范围，并返回一个对 (迭代器, 值)
(算法函数对象)[编辑]
(C++23)
 使用第一个元素作为初始值左折叠元素范围，并返回一个对 (迭代器, 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)
 移除满足特定条件的元素
(算法函数对象)[编辑]
 复制元素范围，省略满足特定条件的元素
(函数模板) [edit]
(C++20)(C++20)
 复制元素范围，省略满足特定条件的元素
(算法函数对象)[edit]
 移除范围内的连续重复元素
(函数模板) [edit]
(C++20)
 移除范围内的连续重复元素
(算法函数对象)[edit]
 创建一个不包含连续重复元素的范围副本
(函数模板) [edit]
(C++20)
 创建一个不包含连续重复元素的范围副本
(算法函数对象)[edit]

[编辑] 顺序更改操作

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

[编辑] 采样操作

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

[编辑] 排序和相关操作

[编辑] 要求

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

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

 (C++20 前)

如果对于指向序列的每个迭代器 iter 和每个非负整数 n 使得 iter + n[1] 是指向序列元素的有效迭代器，则序列相对于 comp 和 proj （对于比较器 comp 和投影 proj）是已排序的，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] 仅当 i < n 时为 true，则序列 [start, finish) 相对于表达式 f(e) 是已分区的。

  1. ↑ 1.0 1.1 1.2 1.3 1.4 iter + n 仅表示 “iter 递增 n 次的结果”，无论 iter 是否为随机访问迭代器。

[编辑] 分区操作

定义于头文件 <algorithm>
(C++11)
 确定范围是否由给定谓词分区
(函数模板) [edit]
(C++20)
 确定范围是否由给定谓词分区
(算法函数对象)[edit]
 将元素范围划分为两组
(函数模板) [edit]
(C++20)
 将元素范围划分为两组
(算法函数对象)[edit]
(C++11)
 复制范围，将元素划分为两组
(函数模板) [edit]
(C++20)
 复制范围，将元素划分为两组
(算法函数对象)[edit]
 将元素划分为两组，同时保留它们的相对顺序
(函数模板) [edit]
(C++20)
 将元素划分为两组，同时保留它们的相对顺序
(算法函数对象)[edit]
(C++11)
 定位已分区范围的分区点
(函数模板) [edit]
(C++20)
 定位已分区范围的分区点
(算法函数对象)[edit]

[编辑] 排序操作

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

[编辑] 二分查找操作（在已分区范围上）

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

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

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

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

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

[编辑] 堆操作

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

 (C++20 前)

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

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

 (自 C++20 起)

堆可以使用 std::make_heap 和 ranges::make_heap(自 C++20 起) 创建。

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


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

[编辑] 最小值/最大值操作

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

[编辑] 字典序比较操作

定义于头文件 <algorithm>
 如果一个范围在字典序上小于另一个范围，则返回 true
(函数模板) [edit]
(C++20)
 如果一个范围在字典序上小于另一个范围，则返回 true
(算法函数对象)[edit]
(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，从第 ith 个和中排除第 ith 个输入元素
(函数模板) [编辑]
(C++17)
 类似于 std::partial_sum，在第 ith 个和中包含第 ith 个输入元素
(函数模板) [编辑]
(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++ 标准。

DR 应用于 已发布行为 正确行为
LWG 193 C++98 堆要求 *first 是最大元素 可以有元素
等于 *first
LWG 2150 C++98 排序序列的定义不正确 已更正
LWG 2166 C++98 堆要求与
最大堆 的定义不够接近		 要求已改进

[编辑] 参见

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