标准库的算法小结

Posted 2023-03-01 雷乌斯

以下内容里：

beg和end表示元素范围的迭代器。

beg2表示第二个输入序列开始位置的迭代器，end2表示第二个序列末尾位置。如果没有end2，则假定beg2表示的序列与beg表示的一样大
dest表示目的序列的迭代器。算法生成多少元素，目的序列必须保证能够储存这么多元素
unaryPred和binaryPred是一元和二元谓词，返回可用作条件的类型
comp是一个二元谓词，满足关联容器对关键字序的要求
unaryOp和binaryOp是可调用对象。

查找对象的算法（要求输入迭代器）

find(beg, end, val) //返回迭代器指向第一个等于vval的元素
find_if(beg, end, unaryPred) //返回迭代器指向第一个满足unaryPred的元素
find_if_not(beg, end, unaryPerd) //返回迭代器指向第一个令unaryPred为false的元素
count(beg, end, val) //返回val出现了多少次
count_if(beg, end, unaryPred) //返回有多少个元素满足unaryPred
all_of(beg, end, unaryPred) //返回bool表示unaryPred是否对所有元素都成功
any_of(beg, end, unaryPred) //对任意一个成功
none_of(beg, end, unaryPred) //对所有元素都不成功

查找重复值的算法（要求前向迭代器）

adjacent_find(beg, end)
adjacent_find(beg, end, binaryPred) //返回指向第一对相邻重复元素的迭代器，如果无，返回end

search_n(beg, end, count, val)
search_n(beg, end, count, val, binaryPred) //返回一个迭代器，从此位置开始有count个相等元素。无则返回end

查找子序列的算法（除了find_first_of之外，都要求2个前向迭代器）

search(beg1, end1, beg2, end2)
search(beg1, end1, beg2, end2, binaryPred) //返回第二个输入范围（子序列）在第一个输入范围中第一次出现的位置。

find_first_of(beg1, end2, beg2, end2)
find_first_of(beg1, end1, beg2, end2, binaryPred) //返回一个迭代器，指向第二个输入范围中任意元素在第一个范围中首次出现的位置

find_end(beg1, end1, beg2, end2)
find_end(beg1, end1, beg2, end2, binaryPred) //类似search，但是返回的是最后一次出现的位置。如果第二个范围为空或未在第一个中找到它，返回end

其他只读算法（要求输入迭代器）

for_each(beg, end, unaryOp) //对输入序列的每个元素应用可调用对象unaryOp。如果迭代器允许通过解引用运算符向序列中的元素写入值，则unaryOp可能修改元素

mismatch(beg1, end1, beg2)
mismatch(beg1, end1, beg2, binaryPred) //返回一个迭代器的pair，表示2个序列中第一个不匹配的元素。如果都匹配，返回的pair中第一个为end1.第二个为对应长度的2的位置

equal(beg1, end1, beg2)
equal(beg1, end1, beg2, binaryPred) //确定2个序列是否相等。如果每个元素都对应一一相等则返回true

二分搜索算法（要求前向迭代器）
如果提供随机访问迭代器的话将提高性能
要求序列中的元素已经是有序的。
都有两个版本，一个使用小于号来判断，一个使用给定的比较操作来判断

lower_bound(beg, end, val)
lower_bound(beg, end, val, comp) //返回一个迭代器表示第一个小鱼等于val的元素

upper_bound(beg, end, val)
upper_bound(beg, end, val, comp) //返回一个迭代器表示第一个大鱼val的元素

equal_range(beg, end, val)
equal_range(beg, end, val, comp) //返回一个pair，其first为lower_bound返回的迭代器，second是upper_bound返回的迭代器

binary_search(beg, end, val)
binary_search(beg, ned, val, comp) //返回一个bool，指出序列中是否包含等于val的元素。（当A不小于B且B也不小于A时，认为他们相等）

只写容器不读的算法（要求输入迭代器）

fill(beg, end, val) //用val赋予每个元素，返回void
fill_n(dest, count, val) //返回迭代器指向“写入到输入序列的最后一个元素之后”的位置
generate(beg, end, Gen) //执行Gen()生成新值，返回void
generate(dest, count, Gen) //返回迭代器指向“写入到输入序列的最后一个元素之后”的位置

读+写算法（要求输入迭代器）

copy(beg, end, dest)
copy_if(beg, end, dest, unaryPred) //满足unaryPred才会被拷贝
copy_n(beg, n, dest)

move(beg, end, dest) //对输入序列的每个元素调用std::move，将其移动到迭代器dest开始的序列中

transform(beg, end, dest, unaryOp) //调用给定操作，并将结果写入dest
transform(beg, end, beg2, dest, binaryOp) //对beg和beg2序列调用二元操作，再写入dest序列

replace_copy(beg, end, dest, old_val, new_val) //将每个元素拷贝到dest，将等于old_val的元素替换为new_val
replace_copy_if(beg, end, dest, unaryPred, new_val) //拷贝到dest，并将满足unaryPred的元素替换为new_val

merge(beg1, end1, beg2, end2, dest)
merge(beg1, end1, beg2, end2, dest, comp) //2个序列都必须是有序的，合并后写入dest中。第一个版本用<第二个版本用给定的比较操作

前向迭代器写算法

iter_swap(iter1, iter2) //交互元素，返回void
swap_ranges(beg1, end1, beg2) //交换范围元素，范围不能有重叠，反回递增后的beg2，指向最后一个交换元素之后的位置

replace(beg, end, old_val, new_val)
replace_if(beg, end, unaryPred, new_val) //替换每个元素，满足==oldval或unaryPred

双向迭代器写算法（算法需要有在序列中反向移动的能力）

copy_backward(beg, end, dest)
move_backward(beg, end, dest) //拷贝或移动范围的元素到dest序列，但是dest表示的是目标序列中拷贝完成后的末尾迭代器

inplace_merge(beg, mid, end)
inplace_merge(beg, mid, end, comp) //将同一个序列中的两个有序子序列合并为单一的有序序列。[1,3,5,)[2,4,6) -> inplace_merge(0,3,5) -> 1,2,3,4,5,6

划分算法

is_partitioned(beg, end, unaryPred) //如果所有满足unaryPred的元素都在不满足unaryPred的元素之前，则返回true
partition_copy(beg. end, dest1, dest2, unaryPred) //满足unaryPred的元素拷贝到dest1，否则dest2。返回pair，first为拷贝到dest1的元素末尾，second为2的
partition_point(beg, end, unaryPred) //要求输入序列是已经用unaryPred划分过的，返回指向前半部分的尾后迭代器，或者end
stable_partition(beg, end, unaryPed)
partition(beg, end, unaryPed) //按照unaryPred划分输入序列。返回迭代器指向最后一个满足unaryPred元素之后的位置

排序算法

sort(beg, end)
stable_sort(beg, end)
sort(beg, end, comp)
stable_sort(beg, end, comp)

is_sorted(beg, end)
is_sorted(beg, end, comp) //返回bool指出输入序列是否有序
is_sorted_until(beg, end)
is_sorted_until(beg, end, comp) //查找最长初始有序子序列，返回子序列的尾后迭代器

partial_sort(beg, mid, end)
partial_sort(beg, mid, end, comp) //将beg到end内最小的若干(mid减beg)个元素放到beg到mid的位置

partial_sort_copy(beg, end, destBeg, destEnd)
partial_sort_copy(beg, end, destBeg, destEnd, comp) //排序输入元素，将足够多的已排序元素拷贝到dest序列

nth_element(beg, nth, end)
nth_element(beg, nth, end, comp) //nth是一个迭代器，指向输入序列中的一个元素。排序后，nth前的元素都小于他，后的元素都大鱼等于他。返回void

重排操作（要求前向迭代器）

remove(beg, end, val)
remove_if(beg, end, binaryPred)
remove_copy(beg, end, dest, val)
remove_copy_if(beg, end, dest, unaryPred) //从序列中删除元素（满足==val或unaryPred），并移动到dest序列

unique(beg, end);
unique(beg, end, binaryPred)
unique_copy(beg, end, dest)
unique_copy_if(beg, end, dest, binaryPred) //重排序列，对相邻的重复元素（满足==或binaryPred）进行删除，并移动到dest

rotate(beg, mid, end)
rotate_copy(beg, mid, end, dest) //围绕MID指向的元素进行转动，mid成为首元素，随后是mid+1到end，再是beg到mid。返回迭代器指向原来beg位置的元素

使用双向迭代器的重排算法

reverse(beg, end) //翻转元素,返回void
reverse_copy(beg, end, dest) //翻转元素拷贝到dest，返回一个迭代器指向拷贝到目的序列的元素的尾后

使用随机访问迭代器的重排算法

random_shuffle(beg, end)
random_shuffle(beg, end, rand) //rand为可调用对象，接受正整数，并生成0到此值的包含区间内的一个服从均匀分布的随机整数。
shuffle(beg, end, Uniform_rand) //Uniform_rand必须满足于均匀分布随机数生成器的要求

排列算法

is_permutation(beg1, end1, beg2)
is_permutation(beg1, end1, beg2, binaryPred) //如果第二个序列的某个排列和第一个序列具有相同数目的元素，且元素都相等，则回复true

next_permutation(beg, end)
next_permutation(beg, end, comp)
prev_permutation(beg, end)
prev_permutation(beg, end, comp) //将序列转为上一个/下一个排列，如果已经是最小/最大的排列，将变成最大/最小的排列

有序序列的集合算法

includes(beg, end, beg2, end2, [comp]) //如果第二个序列中每个都包含在输入序列中，则返回true=
set_union(beg, end, beg2, end2, dest, [comp]) //将2个序列的所有元素合并到一个有序序列中并去掉重复元素
set_intersection(beg, end, beg2, end2, dest, [comp]) //对2个序列都包含的元素创建一个有序序列
set_difference(beg, end, beg2, end2, dest, [comp]) //对出现在第一个序列但不在第二个序列的元素创建一个有序序列
set_symmetric_difference(beg, end, beg2, end2, dest, [comp]) //对只出现在一个序列中的元素创建一个有序序列

最小/最大值

min(val1, val2 [comp])
min(init_list, [comp])
max(val1, val2 [comp])
max(init_list, [comp]) //参数和返回类型都是const的引用

minmax(val1, val2, [comp])
minmax(init_list, [comp]) //返回pair

min_element(beg, end, [comp])
max_element(beg, end, [comp])
minmax_element(beg, end, [comp]) //返回迭代器和迭代器pair

字典序比较

lexicographical_compare(beg1, end1, beg2, end2,[comp])

数值算法

accumulate(beg, end, init, [binaryOp]) //返回init值与序列所有值的和。返回类型与init相同。 使用+或者指定二元操作
inner_product(beg1, end1, beg2, init, binOp1. binOp2) //返回两个序列的内积，即对应序列的积的和。使用*与+，或指定的op1与op2
partial_sum(beg, end, dest, [binaryOp]) //将新序列写入dest，每个新元素的值都等于输入范围中当前位置和之前位置上所有元素之和。返回迭代器指向尾后
adjacent_difference(beg, end, dest, [binaryOp]) //将新序列写入dest，每个新元素（除首元素）的值都等于输入范围中当前位置和前一个位置元素之差
iota(beg, end, val) //将val赋给首元素并递增val。将递增后的值赋予下一个元素，继续递增val，将递增后的值赋予序列中下一个元素。继续....