不修改序列的操作 ---------- 

定义于头文件 <algorithm>

all_of  检查谓词pred是否对范围中所有元素为 true

template <class InputIterator, class UnaryPredicate> 

  bool all_of (InputIterator first, InputIterator last, UnaryPredicate pred);
(函数模板)
pred 既可以是一个函数指针，也可以是一个函数对象。
(C++11)

any_of 检查谓词pred是否对范围中存在一个元素为 true

template <class InputIterator, class UnaryPredicate> 

  bool any_of (InputIterator first, InputIterator last, UnaryPredicate pred);
(函数模板)
(C++11)

none_of 检查谓词pred是否对范围中没有元素为 true

 template <class InputIterator, class UnaryPredicate> 

  bool none_of (InputIterator first, InputIterator last, UnaryPredicate pred);
(函数模板)
(C++11)

for_each 应用函数到范围中的元素

template <class InputIterator, class Function> 

   Function for_each (InputIterator first, InputIterator last, Function fn);
(函数模板)

find  寻找val首次出现位置( 如果没有，那就返回过尾元迭代器)。

template <class InputIterator, class T> 

   InputIterator find (InputIterator first, InputIterator last, const T& val);
(C++11)
寻找首个满足 特定判别标准 的元素
(函数模板)

find_if   找到第一个pred返回true的元素

template <class InputIterator, class UnaryPredicate> 

   InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred);
(C++11)

find_if_not    找到第一个pred返回false的元素

template <class InputIterator, class UnaryPredicate> 

   InputIterator find_if_not (InputIterator first, InputIterator last, UnaryPredicate pred);
(C++11)

find_first_of  现有的数据集合，从某个集合里，找匹配的第一个元素。

equality (1) 
template <class InputIterator, class ForwardIterator>
   InputIterator find_first_of (InputIterator first1, InputIterator last1,
                                   ForwardIterator first2, ForwardIterator last2);
predicate (2) 
template <class InputIterator, class ForwardIterator, class BinaryPredicate>
   InputIterator find_first_of (InputIterator first1, InputIterator last1,
                                   ForwardIterator first2, ForwardIterator last2,
                                   BinaryPredicate pred);
---------这里使用谓词函数 的版本，谓词需要双参数。

adjacent_find  找到 首对相邻的相同（或满足给定谓词pred的）元素

equality (1) 
template <class ForwardIterator>
   ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last);
predicate (2) 
template <class ForwardIterator, class BinaryPredicate>
   ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last,
                                  BinaryPredicate pred);
(函数模板)

count  返回val出现的次数

template <class InputIterator, class T> 

  typename iterator_traits<InputIterator>::difference_type
    count (InputIterator first, InputIterator last, const T& val);
(函数模板)

count_if   返回满足谓词pred为真的元素数

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

mismatch  寻找两个集合的值出现不同的首个位置 ，返回一个 pair，含有两者的迭代器。

equality (1) 
template <class InputIterator1, class InputIterator2>
  pair<InputIterator1, InputIterator2>
    mismatch (InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2);
predicate (2) 
template <class InputIterator1, class InputIterator2, class BinaryPredicate>
  pair<InputIterator1, InputIterator2>
    mismatch (InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, BinaryPredicate pred);
(函数模板)

equal  确定两个元素集合是否相同的

equality (1) 
template <class InputIterator1, class InputIterator2>
  bool equal (InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2);
predicate (2) 
template <class InputIterator1, class InputIterator2, class BinaryPredicate>
  bool equal (InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, BinaryPredicate pred);
(函数模板)

is_permutation   判断一个序列是否为另一个序列的排列

(C++11)
(函数模板)
equality (1) 
template <class ForwardIterator1, class ForwardIterator2>
   bool is_permutation (ForwardIterator1 first1, ForwardIterator1 last1,
                        ForwardIterator2 first2);
predicate (2) 
template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
   bool is_permutation (ForwardIterator1 first1, ForwardIterator1 last1,
                        ForwardIterator2 first2, BinaryPredicate pred);

search  在[fisrt1,last1)搜索一个[fisrt2,last2) 元素整个出现的位置, 没整个出现 就返回 last1

equality (1) 
template <class ForwardIterator1, class ForwardIterator2>
   ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1,
                            ForwardIterator2 first2, ForwardIterator2 last2);
predicate (2) 
template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
   ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1,
                            ForwardIterator2 first2, ForwardIterator2 last2,
                            BinaryPredicate pred);
(函数模板)

search_n  在范围中搜索一定量的连续某个元素的副本

equality (1) 
template <class ForwardIterator, class Size, class T>
   ForwardIterator search_n (ForwardIterator first, ForwardIterator last,
                             Size count, const T& val);
predicate (2) 
template <class ForwardIterator, class Size, class T, class BinaryPredicate>
   ForwardIterator search_n ( ForwardIterator first, ForwardIterator last,
                              Size count, const T& val, BinaryPredicate pred );
(函数模板)