STL算法总结

STL的四种算法
1 非修改式算法 ：不改变容器元素的次序和元素值 一般通过input迭代器和forward迭代器完成工作，可用于所有的标准容器
2修改式序列算法： 不直接改变元素的值，具有移除和删除算法，移除不改变容器的大小和容器中元素的个数
3排序：通过对容器中元素的赋值和交换，改变元素的顺序，复杂度低于下你选哪个算法，要使用随机存取迭代器，不能用于关联式容器(关联式容器的元素被视为常熟)
4通用数字算法：数学运算

for_each算法
for_each(迭代器1，迭代器2， 进程）在区间（1,2）之间每个元素均调用进程

元素计数算法
count（迭代器1，迭代器2，const T&a）统计在迭代器区间（1,2）之内等于value的元素个数

最小值和最大值算法
Iterator min_element（Iterator a，Iterator b，compfun c（可有可无）））
Iterator max_element（Iterator a，Iterator b，compfun c（可有可无）））
搜索算法
Iterator find（Iterator begin，Iterator end ，const T&value） 返回begin和end区间内第一个值为value的元素的位置
Iterator find_if(Iterator begin,iterator end,func op) 返回begin和end区间内第一个满足条件op的元素的位置

Iterator search_n(Iterator begin，iterator end，size count，const T&a)
返回从begin到end中第一组连续count个元素值全为a的位置
Iterator search_n(Iterator begin，iterator end，size count，const T&a，func op) 返回从begin到end中第一组满足op连续count个元素值全为a的位置

Iterator search（Iterator1 begin，Iterator1 end，Iterator2 sbegin，Iterator send）在【begin，end】区间内返回和【sbegin，send】完全吻合的第一个元素的位置

adjacent_find()搜索序列中两个连续相等元素的功能
adjacent_find(T first,T last) 返回在区间（first，last）中第一对连续相等的两个元素的第一个元素的位置
adjacent_find(T first,T last，P) 返回在区间（first，last）中第一对连续两个元素使二元判断是p为true的第一个元素

区间比较算法
equal（）两个容器对象之间的比较，只能比较同一类型的不同变量
mismatch（）寻找两个容器对象之间两两相异的对应元素，有相异点则返回这些相异点
lexicographical_compare()容器一一比较 发生以下情况：
1 如果两个元素不等 则两个元素的比较结果为两个序列的比较结果
2 如果两个容器的元素数量不等，若第一列元素较少则返回true
3 如果两序列相等则返回false

变动性算法
改变容器中元素值的方法：1 使用迭代器遍历序列时直接改变
2 在元素赋值过程中改变

复制
元素复制是两个容器变量之间进行元素传递

copy（a,b，Iterator c） 将（a,b）指定范围的所有元素复制到另一个容器中指定的位置c后面 正向遍历
copy_backward（）双向迭代器，从指定范围的最后一个元素开始向前复制 反向遍历

注：1 STL不存在copy_if()算法，若要实现有条件的复制容器中的元素则使用算法remove_copy_if()
2 若要实现复制过程中逆转元素的序列，使用reverse_copy（）
3 若实现两个容器的所有元素的复制，则使用assign（）
4 若实现赋值过程中删除某些元素，则使用remove_copy()和remove_copy_if()
5 若实现在复制过程中改变元素的数值，则使用transform（）和replace_copy()
6 若目标容器为空，则使用插入型迭代器

转换（难）
transform（）将源区间的元素复制到目标区间，结果写入目标区间

template<class Init,class Outit,class Unop>
Outit transform(Init first,Init last,Outit x,Unop uop)
针对源文件区间中的每个元素均调用函数uop 并将结果写入目标区间，函数返回值为最后一个被转换的元素的下一个位置 确保有足够的空间存放元素否则使用插入型迭代器 可以变动序列中每一个元素

template<class Init1，class Init2，class Outit，class Binop>
Outit transform（Init1 first1，Init2 first2 Outit x，Binop bop）
针对源区间【first，last】的每个元素和从first2开始的第二个源区间对应的元素，调用函数bop 并将结果写入以x为起始的目标区间，函数返回值为最后一个被转换的元素的下一个位置

互换
void swap(T&a,T&b)
交换两个类型相同的容器对象的所有元素

template <class T1,class T2 >
swap_ranges(T1 a,T1,b,T2 x)
可以将容器中的(a，b)的元素和另一个容器中x为起始位置的元素交换

赋值
fill（T first，T last ，const&x）将容器中范围【first，last】内的所有元素设为x
fill_n(T first， Size n，const &x)将容器中从first开始后的n个元素设为x
generate（T first，T last，Gen x）将容器中范围【first，last】内的所有元素调用函数x
generate_n（T first， Size n， Gen x）将容器中从first开始后的n个元素调用函数x
Gen为子进程或者仿函数

替换
replace（first，last，const T&a，const T&b）将容器中【first，last】范围内和a相同的元素替换为b
replace（first，last ，Pr，const T& val） 将容器中【first，last】范围内满足一元片段式pr为true的元素替换为b

逆转
将容器或序列中元素按逆向顺序翻转
reverse（a，b）将区间【a，b】中的元素全部逆序
reverse_copy(a，b，Iterator c)将区间【a，b】复制到c后 并且逆序

旋转
rotate（Iter a，Iter b，Iter c）
将容器中的元素看成一个环，旋转这些元素直至原来b出的元素到达a处，旋转运算是使序列中的元素按照一个环的方式旋转而不是左移

排列
1 排列元素：改变容器中元素的次序，排列方式为字典式正规排序
升序：bool next_permutation（Iterator a，Iterator b）
降序：bool next_permutation(Iterator a，Iterator b，Compare c）c为仿函数

2 重排元素：对容器中的元素进行随机排序有两种形式：
1符合均匀分布随机的排序：void random_shuffle（RandomIterator first，RandomIter last）
2按制定的规律打乱顺序 void random_shuffle（RandomIterator first，RandomIter last,RandomNumberGenerator&rand）
3向前搬移：按指定的一元判断式 若为true则向前移动符合条件的元素，返回值为false的第一个元素的位置
不排序 partition（Iterator a，Iterator b，T pred）
排序 stable_partiton（Iterator a，Iterator b，T pred）
pred为一元判定式或仿函数

全部元素排序
sort（first，last，（Pred））
stable_sort(first,last,（Pred)）
Pred为判定原则 二元判断式，默认为升序
stable_sort可以保持序列或容器中的元素的相对顺序不变
需要访问随机存取迭代器 只适用于vector和deque

局部排序
partial_sort(first,sor,end,(pred))在区间（first，end）内进行排序，并且使（first，sor）内的元素有序
partial_sort_copy(Iter a，Iter b ，Iter2 c，Iter2 d，（pred）)：将区间（a，b）内的元素替换到目标区间（c，d）中，并且对（a，b）内的元素进行排序，返回值是最后一个被复制的元素的下一个位置

根据某个元素排序
nth_element（Iter a，Iter n，Iter b）、nth_element（Iter a，Iter n，Iter b，compare com）可以对指定区间内的元素排序，使容器中n之前的元素都小于他，n之后的元素都大于他 com为二元判断式
与partial_sort（）的区别：
partial_sort（）实现局部排序时指定位置作为划分整个区间的界限
nth_element（）是指定区间中的某个元素作为划分整个区间的界限

堆（二叉树）
介绍：堆通常指一种组织序列元素的方式，第一个元素通常为最大值元素
算法：
make_heap(Iterator a，Iterator b，（comp）)：将区间【a，b】内的元素转化为堆 comp为排序准则

push_heap(Iter a，Iter b)：在【a，b】中插入一个元素，插在堆栈末尾

pop_heap(Iter a，Iter b)：删除【a，b】内的最大的元素

sort_heap(Iter a ，Iter b)：给【a，b】内的元素排序

合并排序
1 总和：merge（InputIter a，InputIter b，InputIter a2，InputIter b2，OutputIter x，（compar com））将【a，b】和【a2，b2】内的元素合并，且将合并后的所有元素保存在以x为起始的目标区间 comp为二元判断式

2 并集 set_union（InputIter a，InputIter b，InputIter a2，InputIter b2，OutputIter x，（compar com））将【a，b】和【a2，b2】内重复的元素保存 x为新生成目标的起始位置 ，重复的元素只保留一个

3 交集：set_intersection(InputIter a，InputIter b，InputIter a2，InputIter b2，OutputIter x，（compar com）) 将【a，b】和【a2，b2】内的元素合并 只保留重复的元素

4 差集：set_difference(InputIter a，InputIter b，InputIter a2，InputIter b2，OutputIter x，（compar com）)【a，b】内所有和【a2，b2】相同的元素都不存在新区间

5 合并 inplace_merge(InputIter a，InputIter b，InputIter a2，InputIter b2，OutputIter x，（compar com）) 将将【a，b】和【a2，b2】内的元素合并

搜索
1 binary_search(Iter a，Iter b，const x，（Comp cp）)
判断区间【a，b】内是否存在x 区间必须是有序的
2 includes（Iter1 a，Iter1 b， Iter2 a2，Iter2 b2，（Comp cp））
在区间【a，b】内检查【a2，b2】是否存在

删除
1 remove（Iter a，Iter b ，const &c）删除【a，b】内所有元素值为c的值 返回值为删除元素之后容器的末尾位置
2 remove_if（Iter a，Iter b，Pard）删除区间【a，b】内所有使条件pard满足的元素，删除元素后剩余元素前移，只能使用序列式容器。
3 remove_copy_if(Iter a，Iter b，OutIter c，Pred) 将【a，b】内的元素移动到c并且删除满足pred的函数
4 unique_copy（Iter a，Iter b ，OutIter c，Comp）将【a，b】内的元素移动到c的位置并且删除相邻重复的元素且当comp为true时，删除该元素 返回值为最后一个被复制的元素的下一个位置
5 unique（Iter a，Iter b ）将【a，b】内相邻相同的元素移动到尾部，不会删除