STL (13) 非变动型算法

• algorithm是“算法”必须的头文件。
• Non-modifying sequence operations (非变动式算法)：算法过后，容器内部数据不发生改变。
  all_of
  Test condition on all elements in range (function template )
  any_of
  Test if any element in range fulfills condition (function template )
  none_of
  Test if no elements fulfill condition (function template )
  for_each
  Apply function to range (function template )
  find
  Find value in range (function template )
  find_if
  Find element in range (function template )
  find_if_not
  Find element in range (negative condition) (function template )
  find_end
  Find last subsequence in range (function template )
  find_first_of
  Find element from set in range (function template )
  adjacent_find
  Find equal adjacent elements in range (function template )
  count
  Count appearances of value in range (function template )
  count_if
  Return number of elements in range satisfying condition (function template )
  mismatch
  Return first position where two ranges differ (function template )
  equal
  Test whether the elements in two ranges are equal (function template )
  is_permutation
  Test whether range is permutation of another (function template )
  search
  Search range for subsequence (function template )
  search_n
  Search range for elements (function template )
• all_of  Test condition on all elements in range (function template )
  测试范围内所有元素的条件（函数模板）???
• 观察本质
• cplusplus页面上的范例
  template<class InputIterator, class UnaryPredicate>
  bool all_of (InputIterator first, InputIterator last, UnaryPredicate pred)
  {
  while (first!=last) {
  if (!pred(*first)) return false;
  ++first;
  }
  return true;
  }
  
  ---------------------------------------------------------
  // all_of example
  #include <iostream> // std::cout
  #include <algorithm> // std::all_of
  #include <array> // std::array
  
  int main () {
  std::array<int,8> foo = {3,5,7,11,13,17,19,23};
  
  if ( std::all_of(foo.begin(), foo.end(), [](int i){return i%2;}) )
  std::cout << "All the elements are odd numbers.\n";
  
  return 0;
  }???
  ------------------------------------------------------
  Output:
  All the elements are odd numbers.?
  
  解释：
  1. [](int i){return i%2;})??? 这里表示一个匿名函数，C++11专属
  2. 些算法效率比较高：因为不是全部判断，只要其中有一个不符合，就返回false了。?
  
  
  
  ??
• vs2015中代码如下：
  // TEMPLATE FUNCTION all_of
  template<class _InIt,class _Pr> inline
  bool _All_of_unchecked(_InIt _First, _InIt _Last, _Pr& _Pred)
  { // test if all elements satisfy _Pred
  for (; _First != _Last; ++_First)
  if (!_Pred(*_First))
  return (false);
  return (true);
  }????
• all_of使用场景是很多的，它能帮我们判断容器内数据，是否符合我们的要求。
• any_of  Test if any element in range fulfills condition (function template )
• 观察本质
• 与all_of成对出现，all_of是判断是否全部符合，any_of则是判断是否有一个符合。
• 示例：
  template<class InputIterator, class UnaryPredicate>
  bool any_of (InputIterator first, InputIterator last, UnaryPredicate pred)
  {
  while (first!=last) {
  if (pred(*first)) return true;
  ++first;
  }
  return false;
  }
  ----------------------------------------------------------
  ??// any_of example
  #include <iostream> // std::cout
  #include <algorithm> // std::any_of
  #include <array> // std::array
  
  int main () {
  std::array<int,7> foo = {0,1,-1,3,-3,5,-5};
  
  if ( std::any_of(foo.begin(), foo.end(), [](int i){return i<0;}) )
  std::cout << "There are negative elements in the range.\n";
  
  return 0;
  }
  
  --------------------------------------------------------------------
  Output:
  There are negative elements in the range.
  
  
  解释：测试如果有一个元素满足条件
  ????
  ????
• none_of  Test if no elements fulfill condition (function template ) 如果没有元素满足条件
• 观察本质
• 示例
  template<class InputIterator, class UnaryPredicate>
  bool none_of (InputIterator first, InputIterator last, UnaryPredicate pred)
  {
  while (first!=last) {
  if (pred(*first)) return false;
  ++first;
  }
  return true;
  }
  ---------------------------------------------------------
  ??
  // none_of example
  #include <iostream> // std::cout
  #include <algorithm> // std::none_of
  #include <array> // std::array
  
  int main () {
  std::array<int,8> foo = {1,2,4,8,16,32,64,128};
  
  if ( std::none_of(foo.begin(), foo.end(), [](int i){return i<0;}) )
  std::cout << "There are no negative elements in the range.\n";
  
  return 0;
  }
  
  -------------------------------------------------------------
  
  Output:
  There are no negative elements in the range.?????
  
  解释：测试如果没有元素满足条件
  ?
  
  ????
• for_each Apply function to range (function template ) 将函数应用到范围
• 观察本质
  template<class InputIterator, class Function>
  Function for_each(InputIterator first, InputIterator last, Function fn)
  {
  while (first!=last) {
  fn (*first);
  ++first;
  }
  return fn; // or, since C++11: return move(fn);
  }
  -------------------------------------------
  
  ??// for_each example
  #include <iostream> // std::cout
  #include <algorithm> // std::for_each
  #include <vector> // std::vector
  
  void myfunction (int i) { // function:
  std::cout << ‘ ‘ << i;
  }
  
  struct myclass { // function object type:
  void operator() (int i) {std::cout << ‘ ‘ << i;}
  } myobject;
  
  int main () {
  std::vector<int> myvector;
  myvector.push_back(10);
  myvector.push_back(20);
  myvector.push_back(30);
  
  std::cout << "myvector contains:";
  for_each (myvector.begin(), myvector.end(), myfunction);
  std::cout << ‘\n‘;
  
  // or:
  std::cout << "myvector contains:";
  for_each (myvector.begin(), myvector.end(), myobject);
  std::cout << ‘\n‘;
  
  return 0;
  }
  
  ----------------------------------------------------------------------
  
  Output:
  myvector contains: 10 20 30
  myvector contains: 10 20 30????
  
  解释：??要注意C++98 与C++11返回值的不同。
  C++11：Returns fn, as if calling std::move(fn).
  C++98：Returns fn.???
  ???
• find Find value in range (function template ) 在范围内查找值
• 观察本质：找到了，直接返回找到的值，没找到，返回last。(有效空间的后面位置)
  template<class InputIterator, class T>
  InputIterator find (InputIterator first, InputIterator last, const T& val)
  {
  while (first!=last) {
  if (*first==val) return first;
  ++first;
  }
  return last; //返回有效区间+1的位置
  }
  -------------------------------------------------------------------------------
  
  // find example
  #include <iostream> // std::cout
  #include <algorithm> // std::find
  #include <vector> // std::vector
  
  int main () {
  // using std::find with array and pointer:
  int myints[] = { 10, 20, 30, 40 };
  int * p;
  
  p = std::find (myints, myints+4, 30);
  if (p != myints+4)
  std::cout << "Element found in myints: " << *p << ‘\n‘;
  else
  std::cout << "Element not found in myints\n";
  
  // using std::find with vector and iterator:
  std::vector<int> myvector (myints,myints+4); //这里要注意，myints+4是有效区间+1的位置。
  std::vector<int>::iterator it;
  
  it = find (myvector.begin(), myvector.end(), 30);
  if (it != myvector.end())
  std::cout << "Element found in myvector: " << *it << ‘\n‘;
  else
  std::cout << "Element not found in myvector\n";
  
  return 0;
  }
  
  ---------------------------------------------------------------------------------
  
  ???????Output:
  Element found in myints: 30
  Element found in myvector: 30
  
  
  解释：???查找值需要“operator==”支持
  if (*first==val) return first; 核心代码：如果*first与val是相等的，返回first.?
  
  ------------------------vs2015代码----------------------------------
  template<class _InIt,
  class _Ty> inline
  _InIt _Find_unchecked1(_InIt _First, _InIt _Last, const _Ty& _Val, false_type)
  { // find first matching _Val
  for (; _First != _Last; ++_First)
  if (*_First == _Val)
  break;
  return (_First);
  }
  ????
• 注意点：
• 1 查找值需要“operator==”支持
• 2 查找值需要遍历容器数据，迭代器需要支持"operator++"
• 3 注意返回的位置，特别要注意数组和容器数据的不同，最后返回的位置last，在数组中是有效数据;而在前闭后开的容器中，last的位置是“有效数据+1”的无效数据。
• 示例
  #include <iostream>
  #include "Algorithm.h"
  #include <array>
  class Demo
  {
  int no_;
  public:
  bool operator==(int num)
  {
  return no_ == num;
  }
  };
  int main ()
  ?{
  Demo demoArray[10];
  std::find(&demoArray[0], &demoArray[9], 20); //这里demoArray[9]是有效数据，demoArray[10]才是无效的数据
  return 0;
  }??
• find_if Find element in range (function template ) 在一个范围里面查找元素
• 观察本质
  template<class InputIterator, class UnaryPredicate>
  InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred)
  {
  while (first!=last) {
  if (pred(*first)) return first; //返回第一个符合条件的元素。
  ++first;
  }
  return last;
  }
  ----------------------------------------------------------------------------------------
  // find_if example
  #include <iostream> // std::cout
  #include <algorithm> // std::find_if
  #include <vector> // std::vector
  bool IsOdd (int i) {
  return ((i%2)==1);
  }
  int main () {
  std::vector<int> myvector;
  myvector.push_back(10);
  myvector.push_back(25);
  myvector.push_back(40);
  myvector.push_back(55);
  std::vector<int>::iterator it = std::find_if (myvector.begin(), myvector.end(), IsOdd);
  std::cout << "The first odd value is " << *it << ‘\n‘;
  return 0;
  }
  
  ----------------------------------------------------------------------------------------------
  
  Output:
  The first odd value is 25
  
  解释：返回第一个符合条件的元素。如果没有找到，则返回有效区间+1的无效数据位置。
  ?
  ???????
  ???
• find_if_not  Find element in range (negative condition 否定条件) (function template )
• 观察本质
  template<class InputIterator, class UnaryPredicate>
  InputIterator find_if_not (InputIterator first, InputIterator last, UnaryPredicate pred)
  {
  while (first!=last) {
  if (!pred(*first)) return first; //返回第一个不符合要求的元素
  ++first;
  }
  return last;
  }
  -----------------------------------------------------------------------------------------------
  // find_if_not example
  #include <iostream> // std::cout
  #include <algorithm> // std::find_if_not
  #include <array> // std::array
  
  int main () {
  std::array<int,5> foo = {1,2,3,4,5};
  
  std::array<int,5>::iterator it =
  std::find_if_not (foo.begin(), foo.end(), [](int i){return i%2;} );
  std::cout << "The first even value is " << *it << ‘\n‘;
  
  return 0;
  }
  
  ---------------------------------------------------------------------------------------------------
  ???Output:
  The first even value is 2
  
  解释：在一个范围内查找不符合要求的元素，返回第一个不符合要求的元素。
  ???
  ???
• find_end Find last subsequence in range (function template )
• 观察本质
  template<class ForwardIterator1, class ForwardIterator2> //只写了带4个参数的实现
  ForwardIterator1 find_end (ForwardIterator1 first1, ForwardIterator1 last1,
  ForwardIterator2 first2, ForwardIterator2 last2)
  {
  if (first2==last2) return last1; // specified in C++11 判断第2区间是否有效
  
  ForwardIterator1 ret = last1;
  
  while (first1!=last1) //遍历第1区间
  {
  ForwardIterator1 it1 = first1;
  ForwardIterator2 it2 = first2;
  while (*it1==*it2) { // or: while (pred(*it1,*it2)) for version (2)
  ++it1; ++it2; //用临时it变量对比，第1区间每个元素，与第2区间的每个元素
  if (it2==last2) { ret=first1; break; } //判断第2区间是否遍历完，完成了则重置要返回的值，跳出此内循环
  if (it1==last1) return ret; //判断第1区间是否遍历完，完成了返回第1区间末尾加一位置
  }
  ++first1;
  }
  return ret;
  }
  ---------------------------------------------------------------------------------------
  // find_end example
  #include <iostream> // std::cout
  #include <algorithm> // std::find_end
  #include <vector> // std::vector
  bool myfunction (int i, int j) {
  return (i==j);
  }
  int main () {
  int myints[] = {1,2,3,4,5,1,2,3,4,5};
  std::vector<int> haystack (myints,myints+10);
  ?
  int needle1[] = {1,2,3};?
  // using default comparison:
  std::vector<int>::iterator it;
  it = std::find_end (haystack.begin(), haystack.end(), needle1, needle1+3);
  if (it!=haystack.end())
  std::cout << "needle1 last found at position " << (it-haystack.begin()) << ‘\n‘;
  ?
  int needle2[] = {4,5,1};?
  // using predicate comparison:
  it = std::find_end (haystack.begin(), haystack.end(), needle2, needle2+3, myfunction);
  if (it!=haystack.end())
  std::cout << "needle2 last found at position " << (it-haystack.begin()) << ‘\n‘;
  ?
  return 0;
  }
  ------------------------------------------------------------------------------------------------
  Output:
  needle1 found at position 5
  needle2 found at position 3
  
  解释：
  1 函数重载，一个4参数，一个5参数，后面多一个BinaryPredicate pred ?????(二元谓词)
  2 算法功能：在第1区间查找，是否与第2区间完全匹配，匹配成功返回第1空间匹配最后的元素。简单来说：就是查找某一段数据。
  3 ??注意点：数据如果不是在前闭后开的容器中（如：数组），都要注意最后的元素的设定。
  ----------------------------------------vs2015代码-----------------------------------------
  // TEMPLATE FUNCTION find_end WITH PRED
  template<class _FwdIt1, class _FwdIt2, class _Pr> inline
  _FwdIt1 _Find_end_unchecked(_FwdIt1 _First1, _FwdIt1 _Last1,
  _FwdIt2 _First2, _FwdIt2 _Last2, _Pr& _Pred)
  { // find last [_First2, _Last2) satisfying _Pred
  _Iter_diff_t<_FwdIt1> _Count1 = _STD distance(_First1, _Last1); //区间距离1
  _Iter_diff_t<_FwdIt2> _Count2 = _STD distance(_First2, _Last2); //区间距离2
  _FwdIt1 _Ans = _Last1;
  
  if (0 < _Count2)
  { // validate _Pred and test
  _DEBUG_POINTER_IF(_Count2 <= _Count1, _Pred);
  for (; _Count2 <= _Count1; ++_First1, (void)--_Count1)
  { // room for match, try it
  _FwdIt1 _Mid1 = _First1;
  for (_FwdIt2 _Mid2 = _First2; ; ++_Mid1)
  if (!_Pred(*_Mid1, *_Mid2))
  break;
  else if (++_Mid2 == _Last2)
  { // potential answer, save it
  _Ans = _First1;
  break;
  }
  }
  }
  
  return (_Ans);
  }??
  ???
• find_first_of Find element from set in range (function template ) 从设定范围内查找元素
• 观察本质
  template<class InputIterator, class ForwardIterator>
  InputIterator find_first_of ( InputIterator first1, InputIterator last1,
  ForwardIterator first2, ForwardIterator last2)
  {
  while (first1!=last1) {
  for (ForwardIterator it=first2; it!=last2; ++it) {
  if (*it==*first1) // or: if (pred(*it,*first)) for version (2)
  return first1;
  }
  ++first1;
  }
  return last1;
  }
  --------------------------------------------------------------------------------------------
  // find_first_of example
  #include <iostream> // std::cout
  #include <algorithm> // std::find_first_of
  #include <vector> // std::vector
  #include <cctype> // std::tolower
  
  bool comp_case_insensitive (char c1, char c2) {
  return (std::tolower(c1)==std::tolower(c2));
  }
  
  int main () {
  int mychars[] = {‘a‘,‘b‘,‘c‘,‘A‘,‘B‘,‘C‘};
  std::vector<char> haystack (mychars,mychars+6);
  std::vector<char>::iterator it;
  
  int needle[] = {‘A‘,‘B‘,‘C‘};
  
  // using default comparison:
  it = find_first_of (haystack.begin(), haystack.end(), needle, needle+3);
  
  if (it!=haystack.end())
  std::cout << "The first match is: " << *it << ‘\n‘;
  
  // using predicate comparison:
  it = find_first_of (haystack.begin(), haystack.end(),
  needle, needle+3, comp_case_insensitive);
  
  if (it!=haystack.end())
  std::cout << "The first match is: " << *it << ‘\n‘;
  
  return 0;
  }
  ----------------------------------------------------------------------------------------
  Output:
  The first match is: A
  The first match is: a
  
  解释：
  循环区间1，里面嵌套循环区间2，用临时it比较所有元素，相等（或其它条件）则直接返回区间1此时元素.
  简单来说：就是查找任意一个相同（或者其它条件）元素，即刻返回。?
  
  ---------------------------------------------vs2015--------------------------------------
  // TEMPLATE FUNCTION find_first_of WITH PRED
  template<class _FwdIt1, class _FwdIt2, class _Pr> inline
  _FwdIt1 _Find_first_of_unchecked(_FwdIt1 _First1, _FwdIt1 _Last1,
  _FwdIt2 _First2, _FwdIt2 _Last2, _Pr& _Pred)
  { // look for one of [_First2, _Last2) satisfying _Pred with element
  for (; _First1 != _Last1; ++_First1)
  for (_FwdIt2 _Mid2 = _First2; _Mid2 != _Last2; ++_Mid2)
  if (_Pred(*_First1, *_Mid2))
  return (_First1);
  return (_First1);
  }??????
  ???
  ???
• adjacent_find Find equal adjacent elements in range (function template ) 在范围内查找相等的相邻元素
• 观察本质
  template <class ForwardIterator>
  ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last)
  {
  if (first != last)
  {
  ForwardIterator next=first; ++next; //跳过第1个元素
  while (next != last) {
  if (*first == *next) // or: if (pred(*first,*next)), for version (2) 比较第1个和第2个元素
  return first; //如符合条件，直接返回first
  ++first; ++next; //不符合条件，则轮番向前
  }
  }
  return last;
  }
  ---------------------------------------------------------------------------------------
  // adjacent_find example
  #include <iostream> // std::cout
  #include <algorithm> // std::adjacent_find
  #include <vector> // std::vector
  
  bool myfunction (int i, int j) {
  return (i==j);
  }
  
  int main () {
  int myints[] = {5,20,5,30,30,20,10,10,20};
  std::vector<int> myvector (myints,myints+8);
  std::vector<int>::iterator it;
  
  // using default comparison:
  it = std::adjacent_find (myvector.begin(), myvector.end());
  
  if (it!=myvector.end())
  std::cout << "the first pair of repeated elements are: " << *it << ‘\n‘;
  
  //using predicate comparison:
  it = std::adjacent_find (++it, myvector.end(), myfunction);
  
  if (it!=myvector.end())
  std::cout << "the second pair of repeated elements are: " << *it << ‘\n‘;
  
  return 0;
  }
  -------------------------------------------------------------------------------------------
  Output:
  the first pair of repeated elements are: 30
  the second pair of repeated elements are: 10
  
  解释：
  
  
  ------------------------------------vs2015-----------------------------------------------
  // TEMPLATE FUNCTION adjacent_find WITH PRED
  template<class _FwdIt,
  class _Pr> inline
  _FwdIt _Adjacent_find_unchecked(_FwdIt _First, _FwdIt _Last, _Pr& _Pred)
  { // find first satisfying _Pred with successor
  if (_First != _Last)
  for (_FwdIt _Firstb; (void)(_Firstb = _First), ++_First != _Last; )
  if (_Pred(*_Firstb, *_First))
  return (_Firstb);
  return (_Last);
  }????????
  
  ????
• count Count appearances of value in range (function template ) 计数
• 观察本质
  template <class InputIterator, class UnaryPredicate>
  typename iterator_traits<InputIterator>::difference_type
  count_if (InputIterator first, InputIterator last, UnaryPredicate pred)
  {
  typename iterator_traits<InputIterator>::difference_type ret = 0;
  while (first!=last) {
  if (pred(*first)) ++ret;
  ++first;
  }
  return ret;
  }
  -------------------------------------------------------------------------------------
  // count_if example
  #include <iostream> // std::cout
  #include <algorithm> // std::count_if
  #include <vector> // std::vector
  
  bool IsOdd (int i) { return ((i%2)==1); }
  
  int main () {
  std::vector<int> myvector;
  for (int i=1; i<10; i++) myvector.push_back(i); // myvector: 1 2 3 4 5 6 7 8 9
  
  int mycount = count_if (myvector.begin(), myvector.end(), IsOdd);
  std::cout << "myvector contains " << mycount << " odd values.\n";
  
  return 0;
  }
  ---------------------------------------------------------------------------------------------
  Output:
  myvector contains 5 odd values.
  
  解释：计数算法
  
  -------------------------------------------vs2015--------------------------------------------
  // TEMPLATE FUNCTION count
  template<class _InIt,
  class _Ty> inline
  _Iter_diff_t<_InIt>
  _Count_unchecked(_InIt _First, _InIt _Last, const _Ty& _Val)
  { // count elements that match _Val
  _Iter_diff_t<_InIt> _Count = 0;
  
  for (; _First != _Last; ++_First)
  if (*_First == _Val)
  ++_Count;
  return (_Count);
  }
  ??????????
• count_if Return number of elements in range satisfying condition (function template ) 按条件计数
• 观察本质
  template <class InputIterator, class UnaryPredicate>
  typename iterator_traits<InputIterator>::difference_type
  count_if (InputIterator first, InputIterator last, UnaryPredicate pred)
  {
  typename iterator_traits<InputIterator>::difference_type ret = 0;
  while (first!=last) {
  if (pred(*first)) ++ret;
  ++first;
  }
  return ret;
  }
  ------------------------------------------------------------------------------------
  // count_if example
  #include <iostream> // std::cout
  #include <algorithm> // std::count_if
  #include <vector> // std::vector
  
  bool IsOdd (int i) { return ((i%2)==1); }
  
  int main () {
  std::vector<int> myvector;
  for (int i=1; i<10; i++) myvector.push_back(i); // myvector: 1 2 3 4 5 6 7 8 9
  
  int mycount = count_if (myvector.begin(), myvector.end(), IsOdd);
  std::cout << "myvector contains " << mycount << " odd values.\n";
  
  return 0;
  }
  -----------------------------------------------------------------------------------
  
  Output:
  myvector contains 5 odd values.
  
  解释：按条件计数
  
  
  -------------------------------------------------vs2015--------------------------
  
  ????????????
• mismatch Return first position where two ranges differ (function template ) 返回两个范围不同的第一位置
• 观察本质
  template <class InputIterator1, class InputIterator2>
  pair<InputIterator1, InputIterator2>
  mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 )
  {
  while ( (first1!=last1) && (*first1==*first2) ) // or: pred(*first1,*first2), for version 2
  { ++first1; ++first2; }
  return std::make_pair(first1,first2);
  }
  ----------------------------------------------------------------------------------------------
  // mismatch algorithm example
  #include <iostream> // std::cout
  #include <algorithm> // std::mismatch
  #include <vector> // std::vector
  #include <utility> // std::pair
  
  bool mypredicate (int i, int j) {
  return (i==j);
  }
  
  int main () {
  std::vector<int> myvector;
  for (int i=1; i<6; i++) myvector.push_back (i*10); // myvector: 10 20 30 40 50
  
  int myints[] = {10,20,80,320,1024}; // myints: 10 20 80 320 1024
  
  std::pair<std::vector<int>::iterator,int*> mypair;
  
  // using default comparison:
  mypair = std::mismatch (myvector.begin(), myvector.end(), myints);
  std::cout << "First mismatching elements: " << *mypair.first;
  std::cout << " and " << *mypair.second << ‘\n‘;
  
  ++mypair.first; ++mypair.second;
  
  // using predicate comparison:
  mypair = std::mismatch (mypair.first, myvector.end(), mypair.second, mypredicate);
  std::cout << "Second mismatching elements: " << *mypair.first;
  std::cout << " and " << *mypair.second << ‘\n‘;
  
  return 0;
  }
  -------------------------------------------------------------------------------------------------------------
  Output:
  First mismatching elements: 30 and 80
  Second mismatching elements: 40 and 320
  
  解释：
  
  
  ---------------------------------------vs2015--------------------------------------------------\
  // TEMPLATE FUNCTION mismatch
  template<class _InIt1,class _InIt2> inline
  pair<_InIt1, _InIt2>
  mismatch(_InIt1 _First1, _InIt1 _Last1,
  _InIt2 _First2)
  { // return [_First1, _Last1)/[_First2, ...) mismatch
  return (_STD mismatch(_First1, _Last1, _First2,
  equal_to<>()));
  }?????
  -------------------------------------------------------------------------------------------------------、
  // TEMPLATE FUNCTION mismatch WITH PRED
  template<class _InIt1,class _InIt2, class _Pr> inline
  pair<_InIt1, _InIt2>
  _Mismatch_unchecked(_InIt1 _First1, _InIt1 _Last1,
  _InIt2 _First2, _Pr& _Pred)
  { // return [_First1, _Last1)/[_First2, ...) mismatch using _Pred
  for (; _First1 != _Last1 && _Pred(*_First1, *_First2); )
  { // point past match
  ++_First1;
  ++_First2;
  }
  
  return (pair<_InIt1, _InIt2>(_First1, _First2));
  }????
  ??????
• equal Test whether the elements in two ranges are equal (function template )
• 观察本质
  template <class InputIterator1, class InputIterator2>
  bool equal ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 )
  {
  while (first1!=last1) {
  if (!(*first1 == *first2)) // or: if (!pred(*first1,*first2)), for version 2
  return false;
  ++first1; ++first2; //第2区间没有判断条件
  }
  return true;
  }
  --------------------------------------------------------------------------------------------
  // equal algorithm example
  #include <iostream> // std::cout
  #include <algorithm> // std::equal
  #include <vector> // std::vector
  
  bool mypredicate (int i, int j) {
  return (i==j);
  }
  
  int main () {
  int myints[] = {20,40,60,80,100}; // myints: 20 40 60 80 100
  std::vector<int>myvector (myints,myints+5); // myvector: 20 40 60 80 100
  
  // using default comparison:
  if ( std::equal (myvector.begin(), myvector.end(), myints) )
  std::cout << "The contents of both sequences are equal.\n";
  else
  std::cout << "The contents of both sequences differ.\n";
  
  myvector[3]=81; // myvector: 20 40 60 81 100
  
  // using predicate comparison:
  if ( std::equal (myvector.begin(), myvector.end(), myints, mypredicate) )
  std::cout << "The contents of both sequences are equal.\n";
  else
  std::cout << "The contents of both sequences differ.\n";
  
  return 0;
  }
  ----------------------------------------------------------------------------------------
  Output:
  The contents of both sequences are equal.
  The contents of both sequence differ.
  
  解释：第2区间要保证比第1区间要长，不然会出问题。
  
  -------------------------------------------------vs2015---------------------------------
  
  // TEMPLATE FUNCTION equal WITH TWO RANGES, PRED
  template<class _InIt1,class _InIt2,class _Pr> inline
  bool _Equal_unchecked(_InIt1 _First1, _InIt1 _Last1,
  _InIt2 _First2, _InIt2 _Last2, _Pr& _Pred,
  input_iterator_tag, input_iterator_tag)
  { // compare [_First1, _Last1) to [_First2, _Last2)
  // using _Pred, arbitrary iterators
  _DEBUG_POINTER_IF(_First1 != _Last1 && _First2 != _Last2, _Pred);
  for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, (void)++_First2)
  if (!_Pred(*_First1, *_First2))
  return (false);
  return (_First1 == _Last1 && _First2 == _Last2);
  }??????
  ?????
• is_permutation  Test whether range is permutation of another (function template ) 测试范围是否是另一个排列
• 观察本质
  template <class InputIterator1, class InputIterator2>
  bool is_permutation (InputIterator1 first1, InputIterator1 last1,
  InputIterator2 first2)
  {
  std::tie (first1,first2) = std::mismatch (first1,last1,first2);
  if (first1==last1) return true;
  InputIterator2 last2 = first2; std::advance (last2,std::distance(first1,last1));
  for (InputIterator1 it1=first1; it1!=last1; ++it1) {
  if (std::find(first1,it1,*it1)==it1) {
  auto n = std::count (first2,last2,*it1);
  if (n==0 || std::count (it1,last1,*it1)!=n) return false;
  }
  }
  return true;
  }
  -----------------------------------------------------------------------------------------
  // is_permutation example
  #include <iostream> // std::cout
  #include <algorithm> // std::is_permutation
  #include <array> // std::array
  
  int main () {
  std::array<int,5> foo = {1,2,3,4,5};
  std::array<int,5> bar = {3,1,4,5,2};
  
  if ( std::is_permutation (foo.begin(), foo.end(), bar.begin()) )
  std::cout << "foo and bar contain the same elements.\n";
  
  return 0;
  }
  ------------------------------------------------------------------------------------------------
  Output:
  foo and bar contain the same elements.
  
  解释：是否是一组有序的排列
  
  ------------------------------------------vs2015-------------------------------------------
  
  // TEMPLATE FUNCTION is_permutation WITH PRED
  template<class _FwdIt1,
  class _FwdIt2,
  class _Pr> inline
  bool _Is_permutation_unchecked(_FwdIt1 _First1, _FwdIt1 _Last1,
  _FwdIt2 _First2, _Pr& _Pred)
  { // test if [_First1, _Last1) == permuted [_First2, ...), using _Pred
  for (; _First1 != _Last1; ++_First1, (void)++_First2)
  if (!_Pred(*_First1, *_First2))
  { // found first inequality, check match counts in suffix
  _FwdIt2 _Last2 = _STD next(_First2,
  _STD distance(_First1, _Last1));
  return (_Check_match_counts(_First1, _Last1,
  _First2, _Last2, _Pred));
  }
  
  return (true);
  }?
  ??????????
• search Search range for subsequence (function template ) 搜索 标准的范围查找 对应 find_end
• 观察本质
  template<class ForwardIterator1, class ForwardIterator2>
  ForwardIterator1 search ( ForwardIterator1 first1, ForwardIterator1 last1,
  ForwardIterator2 first2, ForwardIterator2 last2)
  {
  if (first2==last2) return first1; // specified in C++11
  
  while (first1!=last1)
  {
  ForwardIterator1 it1 = first1;
  ForwardIterator2 it2 = first2;
  while (*it1==*it2) { // or: while (pred(*it1,*it2)) for version 2
  ++it1; ++it2;
  if (it2==last2) return first1;
  if (it1==last1) return last1;
  }
  ++first1;
  }
  return last1;
  }
  ---------------------------------------------------------------------------------
  // search algorithm example
  #include <iostream> // std::cout
  #include <algorithm> // std::search
  #include <vector> // std::vector
  
  bool mypredicate (int i, int j) {
  return (i==j);
  }
  
  int main () {
  std::vector<int> haystack;
  
  // set some values: haystack: 10 20 30 40 50 60 70 80 90
  for (int i=1; i<10; i++) haystack.push_back(i*10);
  
  // using default comparison:
  int needle1[] = {40,50,60,70};
  std::vector<int>::iterator it;
  it = std::search (haystack.begin(), haystack.end(), needle1, needle1+4);
  
  if (it!=haystack.end())
  std::cout << "needle1 found at position " << (it-haystack.begin()) << ‘\n‘;
  else
  std::cout << "needle1 not found\n";
  
  // using predicate comparison:
  int needle2[] = {20,30,50};
  it = std::search (haystack.begin(), haystack.end(), needle2, needle2+3, mypredicate);
  
  if (it!=haystack.end())
  std::cout << "needle2 found at position " << (it-haystack.begin()) << ‘\n‘;
  else
  std::cout << "needle2 not found\n";
  
  return 0;
  }
  ---------------------------------------------------------------------------------------------
  Output:
  needle1 found at position 3
  needle2 not found
  
  解释：
  
  -------------------------------------vs2015------------------------------------------------
  // TEMPLATE FUNCTION search WITH PRED
  template<class _FwdIt1, class _FwdIt2, class _Pr> inline
  _FwdIt1 _Search_unchecked(_FwdIt1 _First1, _FwdIt1 _Last1,
  _FwdIt2 _First2, _FwdIt2 _Last2, _Pr& _Pred,
  forward_iterator_tag, forward_iterator_tag)
  { // find first [_First2, _Last2) satisfying _Pred, arbitrary iterators
  for (; ; ++_First1)
  { // loop until match or end of a sequence
  _FwdIt1 _Mid1 = _First1;
  for (_FwdIt2 _Mid2 = _First2; ; ++_Mid1, (void)++_Mid2)
  if (_Mid2 == _Last2)
  return (_First1);
  else if (_Mid1 == _Last1)
  return (_Last1);
  else if (!_Pred(*_Mid1, *_Mid2))
  break;
  }
  }?????????
• search_n Search range for elements (function template )
• 观察本质
  template<class ForwardIterator, class Size, class T>
  ForwardIterator search_n (ForwardIterator first, ForwardIterator last,
  Size count, const T& val)
  {
  ForwardIterator it, limit;
  ? Size i;
  
  limit=first; std::advance(limit,std::distance(first,last)-count);
  
  while (first!=limit)
  {
  it = first; i=0;
  while (*it==val) // or: while (pred(*it,val)) for the pred version
  { ++it; if (++i==count) return first; }
  ++first;
  }
  return last;
  }
  -------------------------------------------------------------------------------------
  // search_n example
  #include <iostream> // std::cout
  #include <algorithm> // std::search_n
  #include <vector> // std::vector
  
  bool mypredicate (int i, int j) {
  return (i==j);
  }
  
  int main () {
  int myints[]={10,20,30,30,20,10,10,20};
  std::vector<int> myvector (myints,myints+8);
  
  std::vector<int>::iterator it;
  
  // using default comparison:
  it = std::search_n (myvector.begin(), myvector.end(), 2, 30);
  
  if (it!=myvector.end())
  std::cout << "two 30s found at position " << (it-myvector.begin()) << ‘\n‘;
  else
  std::cout << "match not found\n";
  
  // using predicate comparison:
  it = std::search_n (myvector.begin(), myvector.end(), 2, 10, mypredicate);
  
  if (it!=myvector.end())
  std::cout << "two 10s found at position " << int(it-myvector.begin()) << ‘\n‘;
  else
  std::cout << "match not found\n";
  
  return 0;
  }
  ------------------------------------------------------------------------------------------
  Output:
  Two 30s found at position 2
  Two 10s found at position 5
  
  解释：##advance
  template <class InputIterator, class Distance>
  void advance (InputIterator& it, Distance n);
  迭代器辅助函数。
  使迭代器it偏移n，其中n为整数。?
  -----------------------------advance-----------------------
  ?
  #include <iostream> // std::cout
  #include <iterator> // std::advance
  #include <list> // std::list
  
  int main () {
  std::list<int> mylist;
  for (int i=0; i<10; i++) mylist.push_back (i*10);
  
  std::list<int>::iterator it = mylist.begin();
  
  std::advance (it,5);
  std::cout << "The sixth element in mylist is: " << *it << ‘\n‘;
  
  std::advance (it,-1);
  std::cout << "The fifth element in mylist is: " << *it << ‘\n‘;
  
  return 0;
  }?
  -------------------------advnce Deom output---------------------
  The sixth element in mylist is: 50
  The fifth element in mylist is: 40??
  ?
  ?????
  --------------------------------------vs2015-search_n--------------------------------------
  ?
  // TEMPLATE FUNCTION search_n WITH PRED
  template<class _FwdIt,class _Diff,class _Ty,class _Pr> inline
  _FwdIt _Search_n_unchecked(_FwdIt _First, _FwdIt _Last,
  _Diff _Count, const _Ty& _Val, _Pr& _Pred, forward_iterator_tag)
  { // find first _Count * _Val satisfying _Pred, forward iterators
  if (_Count <= 0)
  return (_First);
  
  for (; _First != _Last; ++_First)
  if (_Pred(*_First, _Val))
  { // found start of possible match, check it out
  _FwdIt _Mid = _First;
  
  for (_Diff _Count1 = _Count; ; )
  if (--_Count1 == 0)
  return (_First); // found rest of match, report it
  else if (++_Mid == _Last)
  return (_Last); // short match at end
  else if (!_Pred(*_Mid, _Val))
  { // short match not at end
  break;
  }
  
  _First = _Mid; // pick up just beyond failed match
  }
  
  return (_Last);
  }????
• 非变动型算法分类：
• 算法 粗略分类0
• 1 不带后缀
• 基本上算法的主要功能，在语义上表示出来。
  如：find count equal search
• 2 带后缀
• xxx_of of带有“如果”的意义，此种带“of”后缀的算法，一定会带一个函数，来进行判断，返回一个bool值。all_of功能就是：判断容器里面全部数据是不是一个什么（of）.如果是则返回true,否则返回faulse.
• xxx_if if带有“判断条件”的意义
• 算法 粗略分类1
• 搜索
  search
  search_n?
• 查找
  find
  find_if
  find_if_not
  find_end
  find_first_of????
• 是否相等(相同)
  equal?
  mismatch?
• 是否同一组
  is_permutation
• 计数
  count
  count_if?
• 小结：非变动型算法
  1 all_of any_of none_of这3个主要功能：用来测试，测试在容器中有没有符合条件的数据。
  2 ?for_each主要功能：巡访、遍历，具体是否改变，由程序员决定。
  3 ?搜索查找系列：find find_if find_if_not find_end find_first_of search search_n ##“搜查七种武器”
  find:值的查找 find_if 符合条件的查找 find_if_not 符合条件的查找取反 ?find_end 最后一个的、一整块符合条件的查找 find_first_of 查找符合条件的第一个元素 search 搜查最前一个的、一整块符合条件的 search_n 搜查一定偏移量的区间，查找符合特定条件的。
  4 ?统计计数count count_if
  5 比较 equal等。?
  ?

STL (13) 非变动型算法