Algorithm算法库

骑猪看日落 2023-02-21 14:05 26阅读 0赞

algorithm 是C++标准程式库中的一个头文件，定义了C++ STL标准中的基础性的算法（均为函数模板）。在C++98中，共计有70个算法模板函数；在C++11中，增加了20个算法模板函数。其中有5个算法模板函数定义在头文件numeric中。

**下文所称的“序列”（sequence），是指可以用迭代器顺序访问的容器。**

有返回值的函数,返回值都是迭代器,因此判断是否为空,需要判断超尾元素。

#include <algorithm>

# 一、对序列的每个元素执行函数调用 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>for_each(inIterBegin, inIterEnd,ufunc)</td> 
   <td>用函数对象ufunc调用容器中每一项元素。</td> 
  </tr> 
  <tr> 
   <td>transform (InputIterator first1, InputIterator last1, OutputIterator result, UnaryOperation op)</td> 
   <td>对容器中每一个元素，执行一元操作op，结果写入另一容器中。</td> 
  </tr> 
  <tr> 
   <td>transform (InputIterator1 first1, InputIterator1 last1,InputIterator2 first2, OutputIterator result,BinaryOperation binary_op)</td> 
   <td>对两个容器中对应的每一对元素，执行二元操作binary_op，结果写入另一容器中。</td> 
  </tr> 
 </tbody> 
</table>

# 二、测试序列的性质 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>all_of (InputIterator first, InputIterator last, UnaryPredicate pred)</td> 
   <td>C11算法。如果序列所有元素均满足谓词pred，则返回true</td> 
  </tr> 
  <tr> 
   <td>any_of (InputIterator first, InputIterator last, UnaryPredicate pred)</td> 
   <td>C11算法。如果序列存在元素满足谓词pred，则返回true</td> 
  </tr> 
  <tr> 
   <td>none_of (InputIterator first, InputIterator last, UnaryPredicate pred)</td> 
   <td>C11版。如果容器中所有元素不满足为此pred，则返回true</td> 
  </tr> 
 </tbody> 
</table>

# 三、有序容器中的边界查找 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>equal_range(forIterBegin, forIterEnd, targetVal)</td> 
   <td>在已排序的容器中查找目标值的位置范围；返回范围的下界与上界。对于随机迭代器，用二分查找；否则线性查找。返回pair&lt;ForwardIterator,ForwardIterator&gt;</td> 
  </tr> 
  <tr> 
   <td>equal_range(forIterBegin, forIterEnd, targetVal, binPred)</td> 
   <td>重载版本，其中binPred是给定的序关系函数。</td> 
  </tr> 
  <tr> 
   <td>lower_bound(forIterBegin, forIterEnd, targetVal)</td> 
   <td>在升序的容器中查找第一个不小于targetVal的元素。实际上是二分查找。</td> 
  </tr> 
  <tr> 
   <td>lower_bound(forIterBegin, forIterEnd, targetVal, binPred)</td> 
   <td>重载版本，其中binPred是给定的序关系函数。</td> 
  </tr> 
  <tr> 
   <td>upper_bound(forIterBegin, forIterEnd, val)</td> 
   <td>在已排序的容器中查找目标值val出现的上界（即第一个大于目标值val的元素的位置）。</td> 
  </tr> 
  <tr> 
   <td>upper_bound(forIterBegin, forIterEnd, val, binPred)</td> 
   <td>重载版本，其中binPred是给定的序关系函数。</td> 
  </tr> 
 </tbody> 
</table>

# 四、比较 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>equal(inIter1Begin, inIter1End, inIter2Begin)</td> 
   <td>比较两个序列的对应元素是否相等</td> 
  </tr> 
  <tr> 
   <td>equal(inIter1Begin, inIter1End, inIter2Begin, binPred)</td> 
   <td>重载版本，其中binPred是给定的相等比较函数。</td> 
  </tr> 
  <tr> 
   <td>lexicographical_compare(inIter1Begin, inIter1End, inIter2Begin, inIter2End)</td> 
   <td>对两个序列做词典比较。两个序列的对应元素用 &lt; 运算符比较。如果第一个序列在词典序下小于第二个序列，返回true</td> 
  </tr> 
  <tr> 
   <td>lexicographical_compare(inIter1Begin, inIter1End, inIter2Begin, inIter2End, binPred)</td> 
   <td>重载版本，其中binPred是给定的“小于”比较函数。</td> 
  </tr> 
  <tr> 
   <td>mismatch (InputIterator1 first1, InputIterator1 last1,InputIterator2 first2)</td> 
   <td>比较两个序列的对应元素，返回用std::pair表示的第一处不匹配在两个序列的位置，比较时使用==运算符。</td> 
  </tr> 
  <tr> 
   <td>mismatch (InputIterator1 first1, InputIterator1 last1,InputIterator2 first2, BinaryPredicate pred)</td> 
   <td>重载版本，其中binPred是给定的“相等”比较函数。</td> 
  </tr> 
 </tbody> 
</table>

# 五、复制 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>copy (InputIterator first, InputIterator last, OutputIterator result)</td> 
   <td>复制一个序列到另一个序列</td> 
  </tr> 
  <tr> 
   <td>copy_backward (BidirectionalIterator1 first,BidirectionalIterator1 last,BidirectionalIterator2 result)</td> 
   <td>把一个序列复制到另一个序列，按照由尾到头顺序依次复制元素。</td> 
  </tr> 
  <tr> 
   <td>copy_if (InputIterator first, InputIterator last,OutputIterator result, UnaryPredicate pred)</td> 
   <td>C11算法。复制容器中所有满足谓词pred的元素</td> 
  </tr> 
  <tr> 
   <td>copy_n (InputIterator first, Size n, OutputIterator result)</td> 
   <td>C11算法。复制容器中前n个元素</td> 
  </tr> 
 </tbody> 
</table>

# 六、计数 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>count (InputIterator first, InputIterator last, const T&amp; val)</td> 
   <td>容器中等于给定值的元素的计数</td> 
  </tr> 
  <tr> 
   <td>count_if (InputIterator first, InputIterator last, UnaryPredicate pred)</td> 
   <td>容器中满足给定谓词的元素的计数</td> 
  </tr> 
 </tbody> 
</table>

# 七、填充 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>fill (ForwardIterator first, ForwardIterator last, const T&amp; val)</td> 
   <td>用给定值填充容器中每个元素</td> 
  </tr> 
  <tr> 
   <td>fill_n (OutputIterator first, Size n, const T&amp; val)</td> 
   <td>用给定值填充序列的n个元素</td> 
  </tr> 
 </tbody> 
</table>

# 八、单值过滤 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>unique (ForwardIterator first, ForwardIterator last)</td> 
   <td>对容器中一群连续的相等的元素，仅保留第一个元素，该群其他元素被这群元素之后的其他值的元素替换。该函数不改变这些值的相互顺序，不改变容器的size。函数返回值为最后一个保留元素的下一个位置（past-the-end element）。建议函数返回后resize容器对象。</td> 
  </tr> 
  <tr> 
   <td>unique (ForwardIterator first, ForwardIterator last,BinaryPredicate pred)</td> 
   <td>重载版本，用二元谓词pred替换operator==算符。</td> 
  </tr> 
  <tr> 
   <td>unique_copy (InputIterator first, InputIterator last,OutputIterator result)</td> 
   <td>把一个容器中的元素拷贝到另一个序列；对于一群连续的相等的元素，仅拷贝第一个元素。</td> 
  </tr> 
  <tr> 
   <td>unique_copy (InputIterator first, InputIterator last,OutputIterator result, BinaryPredicate pred)</td> 
   <td>重载版本，用二元谓词pred替换operator==算符。</td> 
  </tr> 
 </tbody> 
</table>

# 九、生成 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>generate (ForwardIterator first, ForwardIterator last, Generator gen)</td> 
   <td>对容器中每个元素，依次调用函数gen的返回值赋值。</td> 
  </tr> 
  <tr> 
   <td>generate_n (OutputIterator first, Size n, Generator gen)</td> 
   <td>对容器中的n个元素，依次调用指定函数的返回值赋值。</td> 
  </tr> 
 </tbody> 
</table>

# 十、堆操作 #

这里的堆是指b:二叉堆，默认为b:最大堆。用数组或std::vector等顺序结构按照广度优先顺序存储堆的元素。数组的第一个元素是堆的根节点元素。元素的比较使用operator< 或者comp函数（对于重载版本）。

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>is_heap (RandomAccessIterator first, RandomAccessIterator last)</td> 
   <td>C11版，判断序列是否为二叉堆</td> 
  </tr> 
  <tr> 
   <td>is_heap_until (RandomAccessIterator first, RandomAccessIterator last,Compare comp)</td> 
   <td>C11版，重载版本</td> 
  </tr> 
  <tr> 
   <td>is_heap_until (RandomAccessIterator first, RandomAccessIterator last)</td> 
   <td>C11版，返回有效二叉堆的最末范围</td> 
  </tr> 
  <tr> 
   <td>is_heap (RandomAccessIterator first, RandomAccessIterator last,Compare comp)</td> 
   <td>C11版，重载版本</td> 
  </tr> 
  <tr> 
   <td>make_heap (RandomAccessIterator first, RandomAccessIterator last)</td> 
   <td>对于一个序列，其元素任意放置，原地(in-place)构造一颗最大树。</td> 
  </tr> 
  <tr> 
   <td>make_heap (RandomAccessIterator first, RandomAccessIterator last,Compare comp )</td> 
   <td>重载版本</td> 
  </tr> 
  <tr> 
   <td>pop_heap (RandomAccessIterator first, RandomAccessIterator last)</td> 
   <td>堆的根节点被移除到last-1位置，堆的元素数目减1并保持堆性质。</td> 
  </tr> 
  <tr> 
   <td>pop_heap (RandomAccessIterator first, RandomAccessIterator last,Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
  <tr> 
   <td>push_heap (RandomAccessIterator first, RandomAccessIterator last)</td> 
   <td>对一个范围为[first,last-1)的堆，增加一个新元素。新元素最初保存在last-1位置。</td> 
  </tr> 
  <tr> 
   <td>push_heap(r,r,bpred)</td> 
   <td>重载版本</td> 
  </tr> 
  <tr> 
   <td>sort_heap (RandomAccessIterator first, RandomAccessIterator last)</td> 
   <td>对一个堆，执行原地堆排序，得到一个升序结果。</td> 
  </tr> 
  <tr> 
   <td>sort_heap (RandomAccessIterator first, RandomAccessIterator last,Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
 </tbody> 
</table>

# 十一、合并 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>inplace_merge (BidirectionalIterator first, BidirectionalIterator middle,BidirectionalIterator last)</td> 
   <td>对两个升序的序列[first,middle) 与[middle,last)，执行原地合并，合并后的序列仍保持升序。空间复杂度O(1)，时间复杂度O(N)</td> 
  </tr> 
  <tr> 
   <td>inplace_merge (BidirectionalIterator first, BidirectionalIterator middle,BidirectionalIterator last, Compare comp)</td> 
   <td>重载版本,operator&lt; 被函数对象comp代替。</td> 
  </tr> 
  <tr> 
   <td>merge (InputIterator1 first1, InputIterator1 last1,InputIterator2 first2, InputIterator2 last2,OutputIterator result)</td> 
   <td>两个升序的序列合并，结果序列保持升序。</td> 
  </tr> 
  <tr> 
   <td>merge (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)</td> 
   <td>重载版本。operator&lt; 被函数对象comp代替。</td> 
  </tr> 
 </tbody> 
</table>

# 十二、最小最大 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>min (const T&amp; a, const T&amp; b)</td> 
   <td>两个值中的最小值。</td> 
  </tr> 
  <tr> 
   <td>min (const T&amp; a, const T&amp; b, Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
  <tr> 
   <td>max (const T&amp; a, const T&amp; b)</td> 
   <td>两个值中的最大值。</td> 
  </tr> 
  <tr> 
   <td>max (const T&amp; a, const T&amp; b, Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
  <tr> 
   <td>min_element (ForwardIterator first, ForwardIterator last)</td> 
   <td>返回容器中最小值的迭代器</td> 
  </tr> 
  <tr> 
   <td>min_element (ForwardIterator first, ForwardIterator last,Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
  <tr> 
   <td>max_element (ForwardIterator first, ForwardIterator last)</td> 
   <td>返回容器中最大值的迭代器</td> 
  </tr> 
  <tr> 
   <td>max_element (ForwardIterator first, ForwardIterator last,Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
  <tr> 
   <td>max (initializer_list il, Compare comp) </td> 
   <td>C11版本</td> 
  </tr> 
  <tr> 
   <td>minmax (const T&amp; a, const T&amp; b)</td> 
   <td>C11版，返回由最小值与最大值构成的std:pair</td> 
  </tr> 
  <tr> 
   <td>minmax (const T&amp; a, const T&amp; b, Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
  <tr> 
   <td>minmax (initializer_list il) </td> 
   <td>C11版，返回由初始化列表中最小元素与最大元素构成的std:pair</td> 
  </tr> 
  <tr> 
   <td>minmax (initializer_list il, Compare comp) </td> 
   <td>重载版本</td> 
  </tr> 
  <tr> 
   <td>minmax_element (ForwardIterator first, ForwardIterator last)</td> 
   <td>C11版，返回由容器中最小元素与最大元素构成的std:pair</td> 
  </tr> 
  <tr> 
   <td>minmax_element (ForwardIterator first, ForwardIterator last, Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
 </tbody> 
</table>

# 十三、移动语义 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>move (InputIterator first, InputIterator last, OutputIterator result)</td> 
   <td>C11版，把输入容器中的逐个元素移动到结果序列。需要注意的是，把一个对象移动给另一个对象的std::move定义在头文件<code>&lt;utility&gt;</code>中。</td> 
  </tr> 
  <tr> 
   <td>move_backward (BidirectionalIterator1 first,BidirectionalIterator1 last,BidirectionalIterator2 result)</td> 
   <td>C11版，把输入容器中的逐个元素自尾到头移动到结果序列</td> 
  </tr> 
 </tbody> 
</table>

# 十四、划分 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>nth_element (RandomAccessIterator first, RandomAccessIterator nth,RandomAccessIterator last)</td> 
   <td>对序列重排，使得指定的位置出现的元素就是有序情况下应该在该位置出现的那个元素，且在指定位置之前的元素都小于指定位置元素，在指定位置之后的元素都大于指定位置元素。</td> 
  </tr> 
  <tr> 
   <td>nth_element (RandomAccessIterator first, RandomAccessIterator nth,RandomAccessIterator last, Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
  <tr> 
   <td>is_partitioned (InputIterator first, InputIterator last, UnaryPredicate pred)</td> 
   <td>C11版，判断容器中满足为此pred的元素是否都在头部</td> 
  </tr> 
  <tr> 
   <td>partition (ForwardIterator first,ForwardIterator last, UnaryPredicate pred)</td> 
   <td>对序列重排，使得满足谓词pred的元素位于最前，返回值为指向不满足谓词pred的第一个元素的迭代器。</td> 
  </tr> 
  <tr> 
   <td>stable_partition (BidirectionalIterator first,BidirectionalIterator last,UnaryPredicate pred)</td> 
   <td>对序列重排，使得满足谓词pred的元素在前，不满足谓词pred的元素在后，且两组元素内部的相对顺序不变。一般是用临时缓冲区实现本函数。</td> 
  </tr> 
  <tr> 
   <td>partition_copy (InputIterator first, InputIterator last, OutputIterator1 result_true, OutputIterator2 result_false, UnaryPredicate pred)</td> 
   <td>C11版，输入容器中满足谓词pred的元素复制到result_true，其他元素复制到result_false</td> 
  </tr> 
  <tr> 
   <td>partition_point (ForwardIterator first, ForwardIterator last, UnaryPredicate pred)</td> 
   <td>C11版，输入队列已经是partition，折半查找到分界点。</td> 
  </tr> 
 </tbody> 
</table>

# 十五、排列 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>is_permutation (ForwardIterator1 first1, ForwardIterator1 last1,ForwardIterator2 first2)</td> 
   <td>C11版本，判断两个序列是否为同一元素集的两个排列</td> 
  </tr> 
  <tr> 
   <td>is_permutation (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, BinaryPredicate pred)</td> 
   <td>C11版本，重载版本</td> 
  </tr> 
  <tr> 
   <td>next_permutation (BidirectionalIterator first, BidirectionalIterator last)</td> 
   <td>n个元素有n!种排列。这些排列中，规定升序序列为最小排列，降序序列为最大的排列，任意两个排列按照字典序分出大小。该函数返回当前序列作为一个排列按字典序的下一个排列。</td> 
  </tr> 
  <tr> 
   <td>next_permutation (BidirectionalIterator first, BidirectionalIterator last, Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
  <tr> 
   <td>prev_permutation (BidirectionalIterator first, BidirectionalIterator last )</td> 
   <td>返回当前序列作为一个排列按字典序的上一个排列</td> 
  </tr> 
  <tr> 
   <td>prev_permutation (BidirectionalIterator first, BidirectionalIterator last, Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
 </tbody> 
</table>

# 十六、随机洗牌 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>random_shuffle (RandomAccessIterator first, RandomAccessIterator last)</td> 
   <td>n个元素有n!个排列。该函数给出随机选择的一个排列。</td> 
  </tr> 
  <tr> 
   <td>random_shuffle (RandomAccessIterator first, RandomAccessIterator last, RandomNumberGenerator&amp; gen)</td> 
   <td>使用给定的随机数发生器来产生随机选择的一个排列。</td> 
  </tr> 
  <tr> 
   <td>shuffle (RandomAccessIterator first, RandomAccessIterator last, URNG&amp;&amp; g)</td> 
   <td>C11版，其中参数g为随机数发生器（uniform random number generator），如在 中定义的标准随机数发生器。 </td> 
  </tr> 
 </tbody> 
</table>

# 十七、删除 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>remove (ForwardIterator first, ForwardIterator last, const T&amp; val)</td> 
   <td>删除容器中等于给定值的所有元素，保留的元素存放在容器的前部且相对次序不变。容器的size不变。</td> 
  </tr> 
  <tr> 
   <td>remove_if (ForwardIterator first, ForwardIterator last,UnaryPredicate pred)</td> 
   <td>删除容器中满足给定谓词pred的元素，保留的元素存放在容器的前部且相对次序不变。容器的size不变。</td> 
  </tr> 
  <tr> 
   <td>remove_copy (InputIterator first, InputIterator last, OutputIterator result, const T&amp; val)</td> 
   <td>把一个容器中不等于给定值的元素复制到另一个容器中。</td> 
  </tr> 
  <tr> 
   <td>remove_copy_if (InputIterator first, InputIterator last, OutputIterator result, UnaryPredicate pred)</td> 
   <td>把一个容器中不满足给定谓词pred的元素复制到另一个容器中。</td> 
  </tr> 
 </tbody> 
</table>

# 十八、替换 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>replace (ForwardIterator first, ForwardIterator last, const T&amp; old_value, const T&amp; new_value)</td> 
   <td>把容器中为给定值的元素替换为新值</td> 
  </tr> 
  <tr> 
   <td>replace_if (ForwardIterator first, ForwardIterator last, UnaryPredicate pred, const T&amp; new_value )</td> 
   <td>把容器中满足给定谓词pred的元素替换为新值</td> 
  </tr> 
  <tr> 
   <td>replace_copy (InputIterator first, InputIterator last, OutputIterator result, const T&amp; old_value, const T&amp; new_value)</td> 
   <td>复制序列，对于等于老值的元素复制时使用新值</td> 
  </tr> 
  <tr> 
   <td>replace_copy_if (InputIterator first, InputIterator last, OutputIterator result, UnaryPredicate pred, const T&amp; new_value)</td> 
   <td>复制序列，对于满足给定谓词pred的元素复制新值。</td> 
  </tr> 
 </tbody> 
</table>

# 十九、逆序 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>reverse (BidirectionalIterator first, BidirectionalIterator last)</td> 
   <td>把容器中的元素逆序</td> 
  </tr> 
  <tr> 
   <td>reverse_copy (BidirectionalIterator first, BidirectionalIterator last, OutputIterator result)</td> 
   <td>复制序列的逆序</td> 
  </tr> 
 </tbody> 
</table>

# 二十、旋转 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>rotate (ForwardIterator first, ForwardIterator middle,ForwardIterator last)</td> 
   <td>等效于循环左移序列，使得迭代器middle所指的元素成为首元素。</td> 
  </tr> 
  <tr> 
   <td>rotate_copy (ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result)</td> 
   <td>等效于循环左移序列并复制到新的存储空间，使得迭代器middle所指的元素成为首元素。</td> 
  </tr> 
 </tbody> 
</table>

# 二十一、搜索 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last)</td> 
   <td>在容器中发现第一对相邻且值相等的元素</td> 
  </tr> 
  <tr> 
   <td>ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last, BinaryPredicate pred)</td> 
   <td>重载版本。用给定谓词pred代替了operator ==</td> 
  </tr> 
  <tr> 
   <td>binary_search (ForwardIterator first, ForwardIterator last,const T&amp; val)</td> 
   <td>对一个升序序列做b:二分搜索，判定容器中是否有给定值val。</td> 
  </tr> 
  <tr> 
   <td>binary_search (ForwardIterator first, ForwardIterator last,const T&amp; val, Compare comp)</td> 
   <td>重载版本。用给定谓词pred代替了operator ==</td> 
  </tr> 
  <tr> 
   <td>find (InputIterator first, InputIterator last, const T&amp; val)</td> 
   <td>对一个输入序列，找到第一个等于给定值的元素</td> 
  </tr> 
  <tr> 
   <td>ForwardIterator1 find_end (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)</td> 
   <td>在序列[first1,last1)中，找到序列[first2,last2)最后出现的位置</td> 
  </tr> 
  <tr> 
   <td>ForwardIterator1 find_end (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred)</td> 
   <td>重载版本，用给定谓词pred代替operator==</td> 
  </tr> 
  <tr> 
   <td>find_first_of (InputIterator first1, InputIterator last1, ForwardIterator first2, ForwardIterator last2)</td> 
   <td>返回字符第一次出现的位置</td> 
  </tr> 
  <tr> 
   <td>find_first_of (InputIterator first1, InputIterator last1, ForwardIterator first2, ForwardIterator last2, BinaryPredicate pred)</td> 
   <td>重载版本，用给定谓词pred代替operator==</td> 
  </tr> 
  <tr> 
   <td>find_if (InputIterator first, InputIterator last, UnaryPredicate pred)</td> 
   <td>在容器中返回满足谓词pred的第一个元素</td> 
  </tr> 
  <tr> 
   <td>find_if_not (InputIterator first, InputIterator last, UnaryPredicate pred)</td> 
   <td>C11算法，在容器中返回不满足谓词pred的第一个元素</td> 
  </tr> 
  <tr> 
   <td>search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)</td> 
   <td>在序列[first1,last1)中，找到序列[first2,last2)首次出现的位置</td> 
  </tr> 
  <tr> 
   <td>search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred)</td> 
   <td>重载版本，用给定谓词pred代替operator==</td> 
  </tr> 
  <tr> 
   <td>search_n (ForwardIterator first, ForwardIterator last, Size count, const T&amp; val)</td> 
   <td>给定容器中，搜索给定值val连续出现n次的位置</td> 
  </tr> 
  <tr> 
   <td>search_n ( ForwardIterator first, ForwardIterator last, Size count, const T&amp; val, BinaryPredicate pred )</td> 
   <td>重载版本，用给定谓词pred代替operator==</td> 
  </tr> 
 </tbody> 
</table>

# 二十二、集合操作 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>includes ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2 )</td> 
   <td>判断第2个已为升序的序列的元素是否都出现在第1个升序容器中</td> 
  </tr> 
  <tr> 
   <td>includes ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp )</td> 
   <td>重载版本，用给定谓词pred代替operator&lt;</td> 
  </tr> 
  <tr> 
   <td>set_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)</td> 
   <td>两个升序序列之差</td> 
  </tr> 
  <tr> 
   <td>set_difference (InputIterator1 first1, InputIterator1 last1,InputIterator2 first2, InputIterator2 last2,OutputIterator result, Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
  <tr> 
   <td>set_intersection (InputIterator1 first1, InputIterator1 last1,InputIterator2 first2, InputIterator2 last2,OutputIterator result)</td> 
   <td>两个升序序列（集合）的交</td> 
  </tr> 
  <tr> 
   <td>set_intersection (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
  <tr> 
   <td>set_symmetric_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)</td> 
   <td>两个升序序列的b:对称差</td> 
  </tr> 
  <tr> 
   <td>set_symmetric_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
  <tr> 
   <td>set_union (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)</td> 
   <td>两个升序序列的并</td> 
  </tr> 
  <tr> 
   <td>set_union (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
 </tbody> 
</table>

# 二十三、排序 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>partial_sort (RandomAccessIterator first, RandomAccessIterator middle,RandomAccessIterator last)</td> 
   <td>使得[first, middle)为整个容器中最小的那些元素并为升序。[middle,last)的元素任意安排。</td> 
  </tr> 
  <tr> 
   <td>partial_sort (RandomAccessIterator first, RandomAccessIterator middle,RandomAccessIterator last, Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
  <tr> 
   <td>partial_sort_copy (InputIterator first,InputIterator last, RandomAccessIterator result_first, RandomAccessIterator result_last)</td> 
   <td>从输入序列复制最小的一批元素到结果容器中，并按升序排列</td> 
  </tr> 
  <tr> 
   <td>partial_sort_copy (InputIterator first,InputIterator last, RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
  <tr> 
   <td>is_sorted (ForwardIterator first, ForwardIterator last)</td> 
   <td>C11版本，判断序列是否为升序</td> 
  </tr> 
  <tr> 
   <td>is_sorted (ForwardIterator first, ForwardIterator last, Compare comp)</td> 
   <td>C11版本，重载版本</td> 
  </tr> 
  <tr> 
   <td>is_sorted_until (ForwardIterator first, ForwardIterator last)</td> 
   <td>C11版本，返回序列从头部开始为升序的子序列的结束处</td> 
  </tr> 
  <tr> 
   <td>is_sorted_until (ForwardIterator first, ForwardIterator last, Compare comp)</td> 
   <td>C11版本，重载版本</td> 
  </tr> 
  <tr> 
   <td>sort (RandomAccessIterator first, RandomAccessIterator last)</td> 
   <td>排序</td> 
  </tr> 
  <tr> 
   <td>sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp)</td> 
   <td>重载版本</td> 
  </tr> 
  <tr> 
   <td>stable_sort ( RandomAccessIterator first, RandomAccessIterator last )</td> 
   <td>稳定排序</td> 
  </tr> 
  <tr> 
   <td>stable_sort ( RandomAccessIterator first, RandomAccessIterator last,Compare comp )</td> 
   <td>重载版本</td> 
  </tr> 
 </tbody> 
</table>

# 二十四、交换 #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>iter_swap (ForwardIterator1 a, ForwardIterator2 b)</td> 
   <td>交换两个迭代器所指的元素对象</td> 
  </tr> 
  <tr> 
   <td>swap (T&amp; a, T&amp; b)</td> 
   <td>交换两个对象。优先使用移动语义</td> 
  </tr> 
  <tr> 
   <td>swap(T (&amp;a)[N], T (&amp;b)[N])</td> 
   <td>交换两个对象数组</td> 
  </tr> 
  <tr> 
   <td>swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1,ForwardIterator2 first2)</td> 
   <td>交换两个容器中对应元素</td> 
  </tr> 
 </tbody> 
</table>

参考链接：  
[https://zh.wikibooks.org/wiki/C%2B%2B/STL/Algorithm][https_zh.wikibooks.org_wiki_C_2B_2B_STL_Algorithm]

[https_zh.wikibooks.org_wiki_C_2B_2B_STL_Algorithm]: https://zh.wikibooks.org/wiki/C%2B%2B/STL/Algorithm