算法

常用版本

描述

返回Type

std::find()

find(_InIt _Fisrt,_InIt _Last,_Ty& _Val);

從兩個迭代器指定的范圍中查找指定值

引用被查找的值的iterator或end()

std::find_if()

find_if(_InIt _Fisrt,_InIt _Last, _CallBack);

從兩個迭代器指定的范圍中查找與回調謂詞匹配的實例

與謂詞匹配的實例的iterator或end()

std::find_if_not()

find_if_not(_InIt _Fisrt,_InIt _Last,_Func _CallBack);

從迭代器范圍中返回第一個不符合謂詞的元素

第一個不符合謂詞的元素的iterator或end()

std::count()

count(_InIt _First,_InIt _Last,_Ty& _Val);

求得一個元素序列中與第三個參數相符的元素的個數

與第三個參數匹配的元素的int個數

std::count_if()

count_if(_InIt _First,_InIt _Last, _CallBack);

求得一個序列中與謂詞匹配的元素的個數

符合條件元素的int個數

std::generate()

generate(_FwdIt _First,_FwdIt _Last, _CallBack);

通過特定值填充一個迭代器范圍

void

std::max()

max(_Left,_Right /*,PRedicate*/);

通過Operator<或用戶提供的二元謂詞比較任意類型的兩個元素

返回較大的一個元素的const引用

std::min()

min(_Left,_Right /*,Predicate*/);

通過operator<或用戶提供的二元謂詞比較任意類型的兩個元素

較小的一個元素的const引用

std::max_element()

max_element(_FwdIt _First,_FwdIt _Last /*,_Pred*/);

從一組任意類型的元素元素序列中查找"最大"的一個

引用"最大”的元素的iterator

std::min_element()

min_element(_FwdIt _First,_FwdIt _Last /*,_Pred*/);

從一組任意類型的元素元素序列中查找"最小"的一個

引用"最小"的元素的iterator

adjacent_find()

adjacent_find(_FwdIt _First, _FwdIt _Last/*,_Pred*/);

從一組任意類型的元素序列中查找有重復的元素

引用重復的第一個元素的iterator或者end()

std::all_of()

all_of(_InIt _First,_InIt _Last,Pr _Pred);

當一組元素序列全部與謂詞匹配時返回true否則返回false

bool

std::any_of()

any_of(_InIt _First,_InIt _Last,_Pr _Pred);

當一組元素序列中任意一個元素與謂詞匹配時返回true否則返回false

bool

std::none_of()

none_of(_InIt _First,_InIt _Last,_Pr _Pred);

當一組元素序列全部都不與謂詞匹配時返回true否則返回false

bool

std::for_each()

for_each(_InIt _First,_InIt _Last,_CallBack);

對指定范圍內的所有元素執行一次_CallBack

_CallBackl類型

std::transform()

transform(_InIt_SrcFirst,_InIt _SrcLast,_OutIt_DestBegin,_CallBack);

對指定范圍的元素執行回調后生成新的元素,然后將這些新元素保存在第三個參數指定的目標范圍中

引用Dest范圍的past-the-end的_OutputIterator

-

transform(_InIt _First1,_InIt _Last,_InIt _First2,_OutIt _DestBegin,_CallBack); 

對兩個指定序列的元素調用二元謂詞,并將結果存入到第四個參數指定的容器中

引用Dest范圍的past-the-end的_OutputIterator

std::equal()

equal(_InIt _First1,_InIt _Last1,_InIt _First2 /*,_Pred*/);

對兩個不同類型的容器比較對應位置的值,當全部相等或者全部符合謂詞時返回true否則返回false

bool

std::copy()

copy(_InIt _SrcBegin,_InIt _SrcEnd,_OutIt _DestBegin);

將一個序列的元素復制到另一個序列中,Src范圍與Dest范圍不能相同,但可以重疊,std::copy不會向目標序列中插入元素,而會直接修改元素,使用前必須配合_Dest序列的resize()函數給Dest序列重分配足夠的空間

引用Dest范圍past_the_end的_OutputIterator

std::copy_backward()

copy_backward(_InIt _SrcBegin,_InIt _SrcEnd,_OutIt _DestEnd);

將Src范圍的元素反向復制到Dest范圍中,也就是從Src范圍最后一個元素開始復制,將這個元素放在Dest范圍的最后一個位置,然后再每一次復制后反向移動.第三個參數應該是_DestEnd而不是_DestBegin

引用Dest范圍的_Begin()的_OutputIterator

std::copy_if

copy_if(_InIt _SrcBegin,_InIt _SrcEnd,_OutIt _DestBegin,_Pr _Pred);

對一個序列中每個準備復制的元素執行一次_Callback,如果返回值為true,那么執行copy操作,否則不執行;返回了Dest范圍中最后一個復制的元素的后一個位置,這是為了配合past_the_end來刪除多余的元素:復制完成后使用_Dest.erase(_CopyEndIt,past_the_end);來刪除Dest范圍多余的元素位置

返回引用Dest范圍的最后一個復制的元素的后一個位置的_OutputIterator

std::copy_n()

copy_n(_InIt _SrcBegin,_Ty _Cnt,_OutIt _DestBegin);

從Src范圍復制_Cnt個元素到Dest范圍,第二個參數是一個指定要復制的元素個數的整數

返回引用Dest范圍的past_the_end

std::partition_copy()

partition_copy(_InIt _SrcBegin,_InIt _SrcEnd,_OutIt _Dest1,_OutIt _Dest2,_Pr _Pred);

對一個序列的元素進行依據謂詞返回的結果進行劃分復制,首先對Src序列中的每一個元素執行一次謂詞,如果返回true,那么將這個元素復制到_Dest1,如果返回false,復制到_Dest2,復制之前需要使用resize()重置Dest的空間;算法返回一個打包_Dest1和_Dest2的one_past_the_last_copied的std::pair,利用這個pair可以刪除多分配的空間

打包引用_Dest1和_Dest2的one_past_the_last_copied的_OutputIterator的std::pair

std::move()

move(_InIt _SrcBegin,_InIt _SrcEnd,_OutIt _DestBegin);

需要給元素提供移動賦值運算符,將Src序列的元素通過移動賦值運算符移動到Dest序列,在移動操作中,SrcObject被重置了,因為DstObject接管了SrcObject資源的所有權,這意味著在move操作過后Src序列中的對象不能再使用

返回Dest范圍的引用past_the_end的_OutputIterator

Std::move_backward()

move_backward(_InIt _SrcBegin,_InIt _SrcEnd,_OutIt _DstEnd)

使用了和std::move()相同的移動機制,但是按照從最后一個元素向第一個元素的順序進行移動

返回Dest范圍的引用_Begin()的_OutputIterator

std::replace()

replace(_FwdIt _First,_FwdIt _Last,const _Ty& _OldVal,const _Ty& _NewVal);

這個算法將一個范圍中的匹配某個值的元素替換為第三個參數指定的新值

void

std::replace_if()

replace_if(_FwdIt _First,_FwdIt _Last,_Pr _Pred,const _Ty& _NewVal);

這個算法將一個范圍中的匹配某個謂詞的元素替換為第三個參數指定的新值

void

std::remove()

remove(_FwdIt _First,_FwdIt _Last,const _Ty& _Val); 

這個算法并不是將序列中與_Val匹配的元素直接刪除,而是將它們移動到容器的末端,然后返回引用第一個被移除的元素的iterator,可以利用這個iterator和end()將被移除的元素徹底擦除

返回引用第一個被移除的元素的_FwdIterator

std::remove_if()

remove_if(_FwdIt _First,_FwdIt _Last,_Pr _Pred);

這個算法并不是將序列中與謂詞匹配的元素直接刪除,而是將它們移動到容器的末端,然后返回引用第一個被移除的元素的iterator,可以利用這個iterator和end()將被移除的元素徹底擦除

返回引用第一個被移除的元素的_FwdIterator

std::unique()

unique(_FwdIt _First,_FwdIt _Last /*,_Pr _Pred)*/;

std::unique算法是特殊的std::remove算法,和后者一樣,std::unique并不是直接將重復的元素刪除,而是將它們全部移動到容器的尾端,然后返回引用第一個被移除的元素的iterator,可以利用這個iterator和end()將被移除的元素徹底擦除

返回引用第一個被移除的元素的_FwdIterator

std::unique_copy

unique(_FwdIt _SrcBegin,_FwdIt _SrcEnd,_OutIt _DestBegin  /*,_Pr _Pred*/);

std::unique()的基本形式是就地操作數據,std::unique_copy則是將操作的結果復制到Dest范圍中

返回引用Dest范圍的元素的_OutputIterator

std::reverse()

reverse(_BidIt _First,_BidIt _Last);

將范圍中的第一個元素和最后一個元素交換,第二個元素和倒數第二個元素交換,依此類推

Void

std::reverse_copy()

reverse_copy(_BidIt _SrcBegin,_BidIt _SrcEnd,_OutIt _DestBegin);

std::reverse是就地操作數據,std::reverse_copy將結果復制到Dest范圍中

返回引用Dest范圍的元素的_OutputIterator

std::sort()

sort(_RanIt _First,_RanIt _Last /*,_Pr _Pred*/);

將范圍中的元素按operator<或_CallBack進行排序

Void

std::merge()

merge(_InIt _SrcBegin1,_InIt _SrcEnd1,_InIt _SrcBegin2,_InIt _SrcEnd2,_OutIt _DestBegin, /*,_Pr _Prd*/);

將兩個排好序的Src序列合并成一個元素序列,然后將結果復制到Dest序列中,并且依然保持排序的順序,結果是一個包含兩個Src序列的所有元素的有序序列,注意一定要使用兩個排好序的序列進行merge操作

引用Dest序列的past_the_end的_OutputIterator

std::is_sorted()

sort(_FwdIt _First,_FwdIt _Last /*,_Pr _Pred*/);

驗證一個序列是否是有序序列.如果是,返回true,否則返回false

bool

std:random_shuffle()

random_shuffle(_RanIt _First,_RanIt _Last /*,_Fn& _Func*/

將一個序列的順序打亂,這個算法適用于洗牌之類的任務,對一個版本默認使用標準C庫的rand()函數,第二個版本需要提供一個隨機數生成器, 以適應不同問題領域的隨機性

void

std::includes()

includes(_InIt _First1,_InIt _Last1,_InIt _First2,_InIt _Last2 /*,_Pr _Pred*/);

驗證第二個序列是否是第一個序列的子集,注意不是真子集,而是子集,如果是返回true,否則返回false

bool

std::set_union()

set_union(_InIt _SrcBegin1,_InIt _SrcEnd1,_InIt _SrcBegin2,_InIt _SrcEnd2,_OutIt _DestBegin /*,_Pr _Pred*/);

計算兩個有序序列的并集,然后將并集的結果存入第四個參數指定的Dest序列中,注意在計算前必須給Dest容器分配足夠的空間,因為Dest范圍最大是_Src1和_Src2的size()和,所以在進行合并后有可能會留下一些空間,set_union算法返回一個引用Dest范圍中最后一個被添加進去的元素的后一個位置的iterator,利用它可以將Dest中多余的空間刪除

返回一個引用Dest范圍中最后一個被添加進去的元素的后一個位置的_OutputIterator

std::set_intersection()

set_intersection(

_InIt _SrcBegin1,_InIt _SrcEnd1,_InIt _SrcBegin2,_InIt _SrcEnd2,_OutIt _DestBegin /*,_Pr _Pred*/);

計算兩個有序序列的交集,然后將交集的結果存入第四個參數指定的Dest序列中,注意在計算前必須給Dest容器分配足夠的空間,因為Dest范圍最大是兩個_Src范圍的size的最大值,所以在進行取交集后有可能會留下一些空間,set_union算法返回一個引用Dest范圍中最后一個被添加進去的元素的后一個位置的iterator,利用它可以將Dest中多余的空間刪除

返回一個引用Dest范圍中最后一個被添加進去的元素的后一個位置的_OutputIterator

std ::set_difference()

set_difference(

_InIt _SrcBegin1,_InIt _SrcEnd1,_InIt _SrcBegin2,_InIt _SrcEnd2,_OutIt _DestBegin /*,_Pr _Pred*/);

計算兩個有序序列的集合差,(集合差:所有存在于第一個集合,但是不存在與第二個集合中的所有元素),然后將求集合差的結果存入第四個參數指定的Dest序列中,注意在計算前必須給Dest容器分配足夠的空間,因為Dest范圍最大是兩個_Src范圍的size的最大值,所以在進行取交集后有可能會留下一些空間,set_union算法返回一個引用Dest范圍中最后一個被添加進去的元素的后一個位置的iterator,利用它可以將Dest中多余的空間刪除

返回一個引用Dest范圍中最后一個被添加進去的元素的后一個位置的_OutputIterator

std::set_symmetric_difference()

set_symmetric_difference(

_InIt _SrcBegin1,_InIt _SrcEnd1,_InIt _SrcBegin2,_InIt _SrcEnd2,_OutIt _DestBegin /*,_Pr _Pred*/);

計算兩個有序序列的對稱集合差,(對稱集合差:所有存在于某一個集合,但是不存在與第二個集合中的元素),然后將求對稱集合差的結果存入第四個參數指定的Dest序列中,注意在計算前必須給Dest容器分配足夠的空間,因為Dest范圍最大是_Src1和_Src2的size()和,所以在進行取交集后有可能會留下一些空間,set_union算法返回一個引用Dest范圍中最后一個被添加進去的元素的后一個位置的iterator,利用它可以將Dest中多余的空間刪除

返回一個引用Dest范圍中最后一個被添加進去的元素的后一個位置的_OutputIterator