子序列匹配(search,find_end,search_n)

search

　　版本一返回[first1,last1-(last2-first2)]中的第一个iterator i，使得满足对于[first2,last2)中的每个iterator j，*(i+(j-first2))==*j，也就是在在每个以i开头的第一个字序列中，必须与第二个子序列相同

　　版本二返回[first1,last1-(last2-first2)]中的第一个iterator i，使得满足对于[first2,last2)中的每个iterator j，表达式_Comp(*(i+(j-first2)),*j)为true，如果不满足，就向后移动第一个子序列的i，直到找到第一个满足的。

template<class ForwardIterator1, class ForwardIterator2>
   ForwardIterator1 search(
      ForwardIterator1 _First1,
      ForwardIterator1 _Last1,
      ForwardIterator2 _First2,
      ForwardIterator2 _Last2
   );
template<class ForwardIterator1, class ForwardIterator2, class Pr>
   ForwardIterator1 search(
      ForwardIterator1 _First1,
      ForwardIterator1 _Last1,
      ForwardIterator2 _First2,
      ForwardIterator2 _Last2
      BinaryPredicate _Comp
   );

search_n

　　找序列中count个相邻的元素形成的子序列，所有值都等于value，或binary_pred(*i,value)为true

　　count允许为0，允许0个元素值等于value，返回first

template<class ForwardIterator1,class Integer,class T>
   ForwardIterator1 search_n(
      ForwardIterator1 _First1,
      ForwardIterator1 _Last1,
      Integer count,
      const T& value
   );
template<class ForwardIterator1,class Integer,class T, class Binaypredicate>
   ForwardIterator1 search_n(
      ForwardIterator1 _First1,
      ForwardIterator1 _Last1,
      Integer count,
      const T& value
      BinaryPredicate _Comp
   );

adjcent_find

//版本一：默认操作是operator==
template <class _ForwardIter>
_ForwardIter adjacent_find(_ForwardIter __first, _ForwardIter __last) {
  /*
  情况1：若输入区间为空，则直接返回尾端last；
  情况2：若输入区间不为空，且存在相邻重复元素，则返回相邻元素的第一个元素的位置；
  情况3：若输入区间不为空，但是不存在相邻重复元素，则直接返回尾端last；
  */
  //情况1：
  if (__first == __last)//若输入区间为空
    return __last;//直接返回last
  //情况2：
  _ForwardIter __next = __first;//定义当前位置的下一个位置(即当前元素的相邻元素)
  while(++__next != __last) {//若还没到达尾端，执行while循环
    if (*__first == *__next)//相邻元素值相等，则找到相邻重复元素
      return __first;//返回第一个元素的位置
    __first = __next;//若暂时找不到，则继续找，直到到达区间尾端
  }
  //情况3：
  return __last;//直接返回尾端last
}

//版本二：用户指定的二元操作pred
//实现过程和版本一一样，只是判断规则不同
template <class _ForwardIter, class _BinaryPredicate>
_ForwardIter adjacent_find(_ForwardIter __first, _ForwardIter __last,
                           _BinaryPredicate __binary_pred);

find

　　找到第一个与value相等的元素返回。

template <class _InputIter, class _Tp>
inline _InputIter find(_InputIter __first, _InputIter __last,
                       const _Tp& __val,
                       input_iterator_tag)
{//若尚未到达区间的尾端，且未找到匹配的值，则继续查找
  while (__first != __last && !(*__first == __val))
    ++__first;
  //若找到匹配的值，则返回该位置
  //若找不到，即到达区间尾端，此时first=last，则返回first
  return __first;
}

find_if

template <class _InputIter, class _Predicate>
inline _InputIter find_if(_InputIter __first, _InputIter __last,_Predicate __pred,)
{//若尚未到达区间的尾端，且未找到匹配的值，则继续查找
  while (__first != __last && !__pred(*__first))
    ++__first;
  //若找到匹配的值，则返回该位置
  //若找不到，即到达区间尾端，此时first=last，则返回first
  return __first;
}

find_end

　　search是找到第一个匹配的子序列，而find_end()是找到最后一个匹配的子序列，其他与search相同；实现也是利用search，先找到第一个出现的点，然后再次基础上向后移动寻找再次出现的点

template<class ForwardIterator1, class ForwardIterator2>
   ForwardIterator1 find_end(
      ForwardIterator1 _First1,
      ForwardIterator1 _Last1,
      ForwardIterator2 _First2,
      ForwardIterator2 _Last2
   );
template<class ForwardIterator1, class ForwardIterator2, class Pr>
   ForwardIterator1 find_end(
      ForwardIterator1 _First1,
      ForwardIterator1 _Last1,
      ForwardIterator2 _First2,
      ForwardIterator2 _Last2
      BinaryPredicate _Comp
   );

find_first_of

　　在[first2,last2]某些元素作为查找目标，寻找他们在[first1,last1]区间内第一次出现的点。用两层for循环实现。

template<class ForwardIterator1, class ForwardIterator2>
   ForwardIterator1 find_first_of(
      ForwardIterator1 _First1,
      ForwardIterator1 _Last1,
      ForwardIterator2 _First2,
      ForwardIterator2 _Last2
   );
template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
   ForwardIterator1 find_first_of(
      ForwardIterator1 _First1,
      ForwardIterator1 _Last1,
      ForwardIterator2 _First2,
      ForwardIterator2 _Last2,
      BinaryPredicate _Comp
   );