STL源码剖析笔记-6算法(6.7 其他算法1）

6.7 其他算法

6.7.1 单纯的数据处理

• adjacent_find:
  
  • 找出第一组满足条件的相邻元素。

template <class ForwardIterator>
ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last)

• count:
  
  • 查找某个元素出现的数目。

template <class InputIterator, class T>
typename iterator_traits<InputIterator>::difference_type count(InputIterator first, InputIterator last, const T& value)

• count_if:
  
  • 返回仿函数计算结果为true的元素的个数

template <class InputIterator, class Predicate>
typename iterator_traits<InputIterator>::difference_type count_if(InputIterator first, InputIterator last, Predicate pred)

• find:
  
  • 查找第一个匹配的元素

template <class InputIterator, class T>
InputIterator find(InputIterator first, InputIterator last, const T& value)

• find_if:
  
  • 查找第一个使仿函数为true的元素。

template <class InputIterator, class Predicate>
InputIterator find_if(InputIterator first, InputIterator last, Predicate pred)

• find_end:
  
  • 在序列一的区间内查找序列二的最后一次出现点。
  • 要求完全匹配的序列，即连续出现的序列2.
  • 可以利用正向查找，每次向后查找，记录上次找的的位置，最后没有找到了，那么上次找到的位置就是最后一次。
  • 也可以利用逆向迭代器从后向前找到第一次出现的位置。

template <class ForwardIterator1, class ForwardIterator2>
inline ForwardIterator1 find_end(ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 first2, ForwardIterator2 last2) 

• find_first of:
  
  • 找到序列2中的任何一个元素在序列一中出现的位置。
  • 不需要完全配匹配序列2，任何一个元素出现都可以。

template <class InputIterator, class ForwardIterator>
InputIterator find_first_of(InputIterator first1, InputIterator last1, ForwardIterator first2, ForwardIterator last2)

• for_each:
  
  • 将仿函数施加于区间内的每个元素之上。
  • 不能够改变元素内容
  • 返回值被忽略。
  • 可以用于打印元素的值等。。。

template <class InputIterator, class Function>
Function for_each(InputIterator first, InputIterator last, Function f)

• generate:
  
  • 将仿函数的运算结果赋值给区间内的每一个元素

template <class ForwardIterator, class Generator>
void generate(ForwardIterator first, ForwardIterator last, Generator gen)

• generate_n:
  
  • 将仿函数的运算结果赋值给迭代器first开始的n个元素上

template <class OutputIterator, class Size, class Generator>
void generate(OutputIterator first, Size n, Generator gen)

• includes:
  
  • 判断序列2是否包含于序列1
  • 不要求序列1中连续，只要都出现了序列2的元素就行。
  • 两个区间都是有序的
  • 相等：s1元素不小于s2且s2元素不小于s1, 或者s1元素不大于s2且s2元素不大于s1，即为相等。

template <class InputIterator1, class InputIterator2>
bool includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator last2)

• max_element:
  
  • 返回区间内最大的元素。

template <class ForwardIterator>
ForwardIterator max_element(ForwardIterator first, ForwardIterator last)

• merge:
  
  • 将两个序列融合成一个序列
  • 三个序列都是有序的
  • 返回指向结果序列的尾后元素

template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator merge(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)

• min_element:
  
  • 返回序列中数值最小的元素

template <class ForwardIterator>
ForwardIterator min_element(ForwardIterator first, ForwardIterator last)

• partition:
  
  • 对区间进行重新排列，所有被仿函数判定为true的元素被放倒区间的前端，被判定为false的元素被放到区间的后端。
  • 这个算法并不保留元素的原始相对位置。需要保留原始相对位置，应使用stable_partition.
  • 算法实现类似于快排，先从前向后找到一个false,再从后向前找到一个true，然后交换。

template <class BidirectionIterator, class Predicate>
BidirectionIterator partition(BidirectionIterator first, BidirectionIterator last, Predicate pred)

• remove:
  
  • 移除区间内与value相等的元素
  • 并不是真正移除，容器大小并未改变。只是将不相等的元素重新赋值到原区间上，所以会在原来去就爱你解围有多余的元素
  • 返回在重新整理后的元素的下一位置
  • erase()可以用来删除多余的元素

template <class ForwardIterator, class T>
ForwardIterator remove(ForwardIterator first, ForwardIterator last, const T& value)

• remove_copy:
  
  • 与remove类似，只不过复制到其他容器上
  • 新容器可以与原容器重叠

template <class ForwardIterator, class OutputIterator, class T>
ForwardIterator remove_copy(ForwardIterator first, ForwardIterator last, OutputIterator result, const T& value)

• remove_if:
  
  • 移除区间内被仿函数判定为true的元素
  • 原理与remove类似

template <class ForwardIterator, class Predicate>
ForwardIterator remove_if(ForwardIterator first, ForwardIterator last, Predicate pred)

• remove_copy_if:
  
  • remove_copy与remove_if的结合

template <class ForwardIterator, class OutputIterator, class Predicate>
ForwardIterator remove_copy_if(ForwardIterator first, ForwardIterator last, OutputIterator result, Predicate pred)

• replace:
  
  • 将区间内的所有元素用新元素取代

template <class ForwardIterator, class T>
void replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value)

• replace_copy:
  
  • 与replace类似，只不过复制到其他容器上
  • 新容器可以与原容器重叠

template <class ForwardIterator, class OutputIterator, class T>
void replace_cpoy(ForwardIterator first, ForwardIterator last, OutputIterator result, const T& old_value, const T& new_value)

• replace_if:
  
  • 移除区间内被仿函数判定为true的元素
  • 原理与replace类似

template <class ForwardIterator, class Predicate, class T>
void replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value)

• replace_copy_if:
  
  • replace_if和replace_copy的结合

template <class Iterator, class OutputIterator, class T>
void replace_cpoy(Iterator first, Iterator last, OutputIterator result, Predicate pred, const T& new_value)

• reverse:
  
  • 将序列的元素在原容器中颠倒重排。

template <class BidirectionIterator>
inline void reverse(BidirectionIterator first, BidirectionIterator last)

• reverse_copy:
  
  • 将序列颠倒重排，将结果置于另一序列

template <class BidirectionIterator, class OutputIterator>
inline void reverse(BidirectionIterator first, BidirectionIterator last, OutputIterator result)

• rotate:
  
  • 以middle为中心将序列旋转，middle所指的元素将会变成第一个元素。
  • rotate()可以交换两个长度不同的区间，swap_range()只能交换长度相同的。

template <class ForwardIterator>
inline void rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last)

• rotate_copy:
  
  • 和rotate类似
  • 将结果置于另一序列

template <class ForwardIterator， class OutputIterator>
inline void rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result)

• search:
  
  • 在序列1中查找序列2的首次出现点
  • 序列1中要求序列2完全匹配，不能间隔。
  • 不存在就返回last1

template <class ForwardIterator1, class ForwardIterator2>
inline ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)

• search_n:
  
  • 和search类似
  • 查找连续n个符合条件的元素形成的子序列。

template <class ForwardIterator, class Integer, class T>
ForwardIterator search_n(ForwardIterator first, ForwardIterator last, Integer count, const T& value)

• swap_range:
  
  • 将两个长度相同的序列交换
  • 两个序列可以在同一容器，也可在不同容器
  • 如果第一个序列长度小于第二个或者两个序列有重叠，结果不可预期。
  • 返回第二个序列最后一个交换元素的下一位置

template <class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 swap_range(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2)

• transform:
  
  • 将仿函数作用于每一个元素身上，并以其结果产生出一个新序列

template <class InputIterator, class OutputIterator, class UnaryOperation>
OutputIterator transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op)

• unique:
  
  • 移除相邻的重复元素
  • 类似于remove，并不是真正移除，而是将不重复的元素重新赋值于区间上。
  • 因为区间大小并未改变，所以尾部会有残余数据
  • 算法是稳定的，所有你保留下来的元素其相对位置不变

template <class ForwardIterator>
ForwardIterator unique(ForwardIterator first, ForwardIterator last)

• unique_copy:
  
  • 与unique类似
  • 将结果复制到另一区间

template <class ForwardIterator， class OutputIterator>
inline OutputIterator unique(ForwardIterator first, ForwardIterator last, OutputIterator result)