STL中的常用algorithm知识点

1.遍历前向迭代器(forward iterator)


template<class InputIterator, class Function>
   Function for_each(
      InputIterator _First, 
      InputIterator _Last,   //最后这个不算
      Function _Func  
   );  //注意这里是返回函数对象本身了, 


_Func: 函数对象,所谓函数对象就是这个参数可以是一个函数指针,也可以是一个对象(对象必须实现operator()函数)。而且在调用函数时,使用唯一的参数就是迭代器值类型的引用,或者常量引用,或者就是值本身。


函数原形: void Fn(TYPE& v)  void Fn(const TYPE& v)   void Fn(TYPE v)


这里举两个例子:


(1).容器中每个元素都乘以2




class Cfactor
{
public:
   void operator()(int& r) { r*=2;}   //这里因为乘2所以必须是引用
};


main()
{
vector<int> v;
//..增加元素
for_each(v.begin(), v.end(), Cfactor());


}




(2).求所有元素的和


class CSum
{
public:
 CSum():m_sum(0){}
 void operator()(int n){ m_sum += n;}
 operator int() { return m_sum;}
};


main()
{
  vector<int> vec;
  //add element
  CSum sum;
  int nSum = for_each<vector<int>::iterator, CSum&>(vec.begin(), vec.end(), sum);   //注意这里的函数对象必须是使用引用类型,否则传递的是对象sum的一个拷贝
                                                                                    //这里返回对象的引用,但因为重载了operator int所以会调用函数
}




2.计算等于某个值的元素数量(forward iterator)
template<class InputIterator, class Type>
   typename iterator_traits<InputIterator>::difference_type count(
      InputIterator _First, 
      InputIterator _Last, 
      const Type& _Val   
   );  //算法返回等于_Val的元素的个数,这个算法要求元素必须实现operator==操作




3.计算满足某条件的元素数量
template<class InputIterator, class Predicate>
   typename iterator_traits<InputIterator>::difference_type count_if(
      InputIterator _First, 
      InputIterator _Last,
      Predicate _Pred
   );


_Pred: 是一个函数对象,参数为元素类型的引用,或者常量引用,或者值,只有当函数返回true时才增加元素数量




函数原形:  bool Fn(TYPE& v)  bool Fn(const TYPE& v)   bool Fn(TYPE v)


4.查找等于某个值的迭代器的位置:
template<class InputIterator, class Type>
   InputIterator find(
      InputIterator _First, 
      InputIterator _Last, 
      const Type& _Val
   );  //若没有找到返回_Last


5.查找满足某条件的迭代器
template<class InputIterator, class Predicate>
   InputIterator find_if(
      InputIterator _First, 
      InputIterator _Last, 
      Predicate _Pred     //参考3
   );




//查找某一个范围的数字在另外一个范围内最后出现的位置:
template<class ForwardIterator1, class ForwardIterator2>
   ForwardIterator1 find_end(
      ForwardIterator1 _First1, 
      ForwardIterator1 _Last1,
      ForwardIterator2 _First2, 
      ForwardIterator2 _Last2
   );
//这里注意的是指_First2 - _Last2这一整个范围都等于第一个迭代器的最后一次的位置,而不是第二个迭代器中的任何一个,
//若函数调用失败返回_Last1




template<class ForwardIterator1, class ForwardIterator2, class Pr>
   ForwardIterator1 find_end(
      ForwardIterator1 _First1, 
      ForwardIterator1 _Last1,
      ForwardIterator2 _First2, 
      ForwardIterator2 _Last2,
      BinaryPredicate _Comp  //函数对象,两个参数前面是迭代器1后面是迭代器,若函数返回true则表示元素2满足1所要找的条件,否则就返回false
   );


这个函数对象若对_First2到_Last2中的每个元素调用都返回真的话则算法返回最后一次全为真的情况下迭代器1的开始元素的位置




template<class ForwardIterator1, class ForwardIterator2>
   ForwardIterator1 find_first_of(
      ForwardIterator1 _First1, 
      ForwardIterator1 _Last1,
      ForwardIterator2 _First2, 
      ForwardIterator2 _Last2
   );   //只要迭代器2中有任意一个元素与第一个迭代器的元素相等则返回迭代1的位置
template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
   ForwardIterator1 find_first_of(
      ForwardIterator1 _First1, 
      ForwardIterator1 _Last1,
      ForwardIterator2 _First2, 
      ForwardIterator2 _Last2,
      BinaryPredicate _Comp     //函数对象,迭代1在前,迭代2在后,只要函数返回TRUE则返回迭代1元素的位置
   );












6.查找满足某一个区域内的元素的迭代器


template<class ForwardIterator1, class ForwardIterator2>
   ForwardIterator1 search(
      ForwardIterator1 _First1, 
      ForwardIterator1 _Last1,
      ForwardIterator2 _First2,   
      ForwardIterator2 _Last2
   );   //若第二个迭代器中所有元素均等于从某个位置开始时的第一个迭代器的那部分元素则返回第一个迭代器的位置,这个函数就是find_end的只返回第一次的位置


template<class ForwardIterator1, class ForwardIterator2, class Pr>
   ForwardIterator1 search(
      ForwardIterator1 _First1, 
      ForwardIterator1 _Last1,
      ForwardIterator2 _First2, 
      ForwardIterator2 _Last2
      BinaryPredicate _Comp      //这个函数对象就跟前面介绍的等于一样,也就是说只要都返回true时,算法就返回.
   );


函数原形:  bool Fn(TYPE e1, TYPE e2)         //e1为第一个迭代器中元素,e2为第二个








template<class ForwardIterator1, class Diff2, class Type>
   ForwardIterator1 search_n(
      ForwardIterator1 _First1, 
      ForwardIterator1 _Last1,
      Size2 _Count, 
      const Type& _Val
   );    //若迭代器中有范围等于_Count个Val则返回这个范围的开始位置
template<class ForwardIterator1, class Size2, class Type, class BinaryPredicate>
   ForwardIterator1 search_n(
      ForwardIterator1 _First1, 
      ForwardIterator1 _Last1,
      Size2 _Count, 
      const Type& _Val,
      BinaryPredicate _Comp    //函数对象,迭代器在前,_Val在后, 若函数对_Count个_Val与迭代器比较都为true的话则算法返回开始的位置
   );








7.随机访问迭代器的排序(这里只能是随机访问迭代)


template<class RandomAccessIterator>
   void sort(
      RandomAccessIterator _First, 
      RandomAccessIterator _Last
   );   //迭代器必须实现<=操作符,而且元素必须实现赋值操作
template<class RandomAccessIterator, class Pr>
   void sort(
      RandomAccessIterator _First, 
      RandomAccessIterator _Last, 
      BinaryPredicate _Comp
   );  




_Comp: 是一个函数对象,若返回true,则第一个元素排在第二个元素前面,否则排在后面


函数原形:  bool Fn(TYPE e1, TYPE e2)   bool Fn(TYPE& e1, TYPE& e2)




//前面使用的是快速排序法,是一个种不稳定排序法而stable_sort则是一种稳定排序法


template<class BidirectionalIterator>
   void stable_sort(
      BidirectionalIterator _First, 
      BidirectionalIterator _Last
   );
template<class BidirectionalIterator, class BinaryPredicate>
   void stable_sort(
      BidirectionalIterator _First, 
      BidirectionalIterator _Last,
      BinaryPredicate _Comp
   );




//部分排序


template<class RandomAccessIterator>
   void partial_sort(
      RandomAccessIterator _First, 
      RandomAccessIterator _SortEnd,
      RandomAccessIterator _Last
   );   //也就是所有元素都参与排序,但只有_First 到_SortEnd-1这部分才是有序的
template<class RandomAccessIterator, class BinaryPredicate>
   void partial_sort(
      RandomAccessIterator _First, 
      RandomAccessIterator _SortEnd,
      RandomAccessIterator _Last
      BinaryPredicate _Comp     //函数对象, 若返回true则前面元素排前面,后面元素排后面
   );




//下面将迭代1的排序结果保存到迭代2中,若迭代2大于迭代1则会将全部保存到2中,而若2小于1则只会将1的一部分放入到2中


template<class InputIterator, class RandomAccessIterator>
   RandomAccessIterator partial_sort_copy(
      InputIterator _First1, 
      InputIterator _Last1,
      RandomAccessIterator _First2, 
      RandomAccessIterator _Last2     //函数返回迭代2中以排序的下一个迭代器位置
   );
template<class InputIterator, class RandomAccessIterator, class BinaryPredicate>
   RandomAccessIterator partial_sort_copy(
      InputIterator _First1, 
      InputIterator _Last1,
      RandomAccessIterator _First2, 
      RandomAccessIterator _Last2,
      BinaryPredicate _Comp   //函数对象, 都是迭代1的参数,若返回true则前面参数放入前面,否则放入到后面
   );










8.元素的删除(但不影响迭代器中元素的顺序,不会改变迭代器的大小,不会分配和销毁内存,不影响容器的容量等)(删除所有)


template<class ForwardIterator, class Type>
   ForwardIterator remove(
      ForwardIterator _First, 
      ForwardIterator _Last, 
      const Type& _Val
   );  //若没有指定的元素则返回_Last


算法返回剩余的元素的下一个迭代器例如:


{1,2,3,4,5,6,7} 若删除5则返回第6个位置
{1,2,3,4,5,5,6,5,7} 若删除5则返回第6个位置




元素必须实现=操作符。而且用户必须负责实现将返回值到_Last这段区域的元素的析构工作。




template<class ForwardIterator, class Predicate>
   ForwardIterator remove_if(
      ForwardIterator _First, 
      ForwardIterator _Last,
      Predicate _Pred    //函数对象,若元素返回为true则销毁这个元素
   );




函数原形：  bool Fn(TYPE)




将不等于指定值的元素,或者不满足指定条件的元素拷贝到另外一个迭代器中(源迭代器不改变)


template<class InputIterator, class OutputIterator, class Type>
   OutputIterator remove_copy(
      InputIterator _First, 
      InputIterator _Last, 
      OutputIterator _Result,
      const Type& _Val
   );  //输出最后_Result




template<class InputIterator, class OutputIterator, class Predicate>
   OutputIterator remove_copy_if(
      InputIterator _First, 
      InputIterator _Last, 
      OutputIterator _Result,
      Predicate _Pred   //函数原形 bool Fn(TYPE),不拷贝条件为true的元素
   );


















9.迭代器的元素拷贝(前向迭代器,元素必须实现赋值操作。目标容量必须要大于源


template<class InputIterator, class OutputIterator>
   OutputIterator copy(
      InputIterator _First, 
      InputIterator _Last, 
      OutputIterator _DestBeg
   );  //将_First-_Last的元素依次拷贝到以_DestBeg开始的迭代器中,函数返回 _DestBeg + (_Last - _First).也就是有效的下一个




10.反向拷贝(双向迭代器,目标要大于源)


template<class BidirectionalIterator1, class BidirectionalIterator2>
   BidirectionalIterator2 copy_backward(
      BidirectionalIterator1 _First, 
      BidirectionalIterator1 _Last,  //这个不包括
      BidirectionalIterator2 _DestEnd   //这个不包括
   );  //依次实现 *--DestEnd = *--_Last拷贝, 并返回目标的最开始一个: _DestEnd - (_Last - _First)




11.相邻比较,若迭代器中有两个相邻的元素相等或者满足指定的条件,则返回第一个元素的迭代


template<class ForwardIterator>
   ForwardIterator adjacent_find(
      ForwardIterator _First, 
      ForwardIterator _Last
   );
template<class ForwardIterator , class BinaryPredicate>
   ForwardIterator adjacent_find(
      ForwardIterator _First, 
      ForwardIterator _Last, 
      BinaryPredicate _Comp);   //函数对象




函数原形:  bool Fn(TYPE e1, TYPE e2)        //若两个相邻的元素使得函数满足条件为true,则返回e1的迭代






template<class InputIterator1, class InputIterator2>
   pair<InputIterator1, InputIterator2> mismatch(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2   //一次从_First1和_First2比较,若不相等时则返回一个对这个对中第一个是第一个迭代器的位置,而第二个则是第二个迭代器位置
  );
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
   pair<InputIterator1, InputIterator2> mismatch(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2
      BinaryPredicate _Comp     //函数对象,迭代1在前迭代2在后,若函数返回false则返回两个参数的迭代的位置,若为true则继续.
   );






12.二分搜索(迭代必须是有序的,默认升序)


template<class ForwardIterator, class Type>
   bool binary_search(
      ForwardIterator _First, 
      ForwardIterator _Last,
      const Type& _Val         //元素必须实现<操作符。 迭代器在左边,元素在右边(同时也会有元素在左,迭代在右. 也就是用<来实现等于操作)
   );     //用小于实现等于的方法是:  !(a < b) && !(b < a)
template<class ForwardIterator, class Type, class BinaryPredicate>
   bool binary_search(
      ForwardIterator _First, 
      ForwardIterator _Last,
      const Type& _Val, 
      BinaryPredicate _Comp  //函数对象,返回bool 接收两个参数,一个迭代器一个_Val。 若有一个迭代器和_Val, 无论两边的顺序如何调用_Comp都返回真,则算法返回真
   );




13.元素的填充


template<class ForwardIterator, class Type>
   void fill(
      ForwardIterator _First, 
      ForwardIterator _Last,   //不填充
      const Type& _Val
   );




template<class OutputIterator, class Size, class Type>
   void fill_n(
      OutputIterator _First, 
      Size _Count,    //填充_Count个
      const Type& _Val
   ); 


前面的是用一个具体的值来填充,也可以用一个函数对象来填充


template<class ForwardIterator, class Generator>
   void generate(
      ForwardIterator _First, 
      ForwardIterator _Last, 
      Generator _Gen    //每个元素都用函数对象返回的值来填充
   );


函数原形:  TYPE Fn()        TYPE& Fn()




template<class OutputIterator, class Size, class Generator>
   void generate_n(
      OutputIterator _First, 
      Size _Count, 
      Generator _Gen
   );




前面的填充只是一个固定值或者一个函数对象。


template<class InputIterator, class OutputIterator, class UnaryFunction>
   OutputIterator transform(
      InputIterator _First1, 
      InputIterator _Last1, 
      OutputIterator _Result,  //对输入迭代器的每个元素分别调用_Func,并把返回赋值给_Result
      UnaryFunction _Func    //函数原形:  TYPE Fn(TYPE)   TYPE& Fn(TYPE&)
   );
template<class InputIterator1, class InputIterator2, class OutputIterator,
   class BinaryFunction>
   OutputIterator transform(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      OutputIterator _Result,
      BinaryFunction _Func     //前面函数对象只接受一个参数,而这个函数对象接收两个参数
   );


函数原形:  TYPE Fn(TYPE e1, TYPE e2)    //第一个在前第二个在后










14.依次比较两个迭代器的元素在(_First1到_Last1这个范围内)是否完全相等(算法只会比到第一个迭代器到结束为止)


//此函数要求迭代器的有效长度要等于或者大于第一个迭代器
//这个算法通常用在依次对两个迭代器的元素进行比较的情况


template<class InputIterator1, class InputIterator2>
   bool equal(
      InputIterator1 _First1, 
      InputIterator1 _Last1, 
      InputIterator2 _First2  //_First1与_First2比较,然后依次比较,若完全相等则返回true
   );
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
   bool equal(
      InputIterator1 _First1, 
      InputIterator1 _Last1, 
      InputIterator2 _First2, 
      BinaryPredicate _Comp  //函数对象
   );


_Comp: 若对迭代器1和2的每个元素依次调用函数都为true则算法返回true.


函数原形:  bool Fn(TYPE e1, TYPE e2)           //迭代器1的元素在前面,迭代器2的元素在后面






获取某个有序区域内小于等于指定元素和大于指定元素的迭代器对


template<class ForwardIterator, class Type>
   pair<ForwardIterator, ForwardIterator> equal_range(
      ForwardIterator _First,
      ForwardIterator _Last, 
      const Type& _Val          //迭代器对的第一个小于等于,第二个对大于
   );
template<class ForwardIterator, class Type, class Pr>
   pair<ForwardIterator, ForwardIterator> equal_range(
      ForwardIterator _First,
      ForwardIterator _Last, 
      const Type& _Val, 
      BinaryPredicate _Comp    //函数对象,接收两个参数一个是迭代器中的,一个是_Val,位置不固定, 但若前面小于后面则返回true,而前面等于后面则返回false
   );










15.反转迭代器的元素
template<class BidirectionalIterator>
   void reverse(
      BidirectionalIterator _First, 
      BidirectionalIterator _Last   //这个不算
   );  //这里只反转值而不反转迭代




16.将一个范围的迭代器,从后向前分别拷贝给另外一个迭代器(目标必须大于等于源)


template<class BidirectionalIterator, class OutputIterator>
   OutputIterator reverse_copy(
      BidirectionalIterator _First, 
      BidirectionalIterator _Last, 
      OutputIterator _Result   //目标必须是一个前向迭代,即依次拷贝 _Result++ = --_Last
   );  //返回_Result最后一个的下一个。




17.元素的交换


template<class ForwardIterator>
   void rotate(
      ForwardIterator _First, 
      ForwardIterator _Middle, 
      ForwardIterator _Last
   );


经过运算后_Middle到_Last-1将放到前面,而_First到_Middle则放到后面


18.将交换的元素拷贝到别的迭代
template<class ForwardIterator, class OutputIterator>
   OutputIterator rotate_copy(
      ForwardIterator _First, 
      ForwardIterator _Middle,
      ForwardIterator _Last, 
      OutputIterator _Result    //这个输出参考(16)
   );




19.集合算法(若要正常,则迭代器应该是有序的


(1).子集判断,判断迭代2是否是1的子集,这两个迭代器必须是升序的.而且元素必须实现<操作符


template<class InputIterator1, class InputIterator2>
   bool includes(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      InputIterator2 _Last1
   );
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
   bool includes(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      InputIterator2 _Last1,
      BinaryPredicate _Comp
   );






(2).并集操作


template<class InputIterator1, class InputIterator2, class OutputIterator>
   OutputIterator set_union(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      InputIterator2 _Last2, 
      OutputIterator _Result        //元素必须实现<操作。 若左边小于右边则左边在前面而后边在后面
   );
template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryPredicate>
   OutputIterator set_union(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      InputIterator2 _Last2, 
      OutputIterator _Result,
      BinaryPredicate _Comp    //函数对象, 两参数若返回true则前面参数在前后边参数在后
   );


//若两个都是有序的则不会有重复元素,若是无序则可能出现重复元素,在有序的情况下若有相等的则只会增加第一个迭代的元素.




(3).交集
template<class InputIterator1, class InputIterator2, class OutputIterator>
   OutputIterator set_intersection(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      InputIterator2 _Last2, 
      OutputIterator _Result
   );
template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryPredicate>
   OutputIterator set_intersection(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      InputIterator2 _Last2, 
      OutputIterator _Result,
      BinaryPredicate _Comp
   );




(4).差集
template<class InputIterator1, class InputIterator2, class OutputIterator>
   OutputIterator set_difference(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      InputIterator2 _Last2, 
      OutputIterator _Result
   );
template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryPredicate>
   OutputIterator set_difference(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      InputIterator2 _Last2, 
      OutputIterator _Result,
      BinaryPredicate _Comp
   );




(5).对称差
template<class InputIterator1, class InputIterator2, class OutputIterator>
   OutputIterator set_symmetric_difference(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      InputIterator2 _Last2, 
      OutputIterator _Result
   );
template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryPredicate>
   OutputIterator set_symmetric_difference(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      InputIterator2 _Last2, 
      OutputIterator _Result,
      BinaryPredicate _Comp
   );






20.交换两迭代器内容
template<class ForwardIterator1, class ForwardIterator2>
   void iter_swap(
      ForwardIterator1 _Left,
      ForwardIterator2 _Right
   );




交换两个元素
template<class Type>
   void swap(
      Type& _Left, 
      Type& _Right
   );




交换两个区域的值
template<class ForwardIterator1, class ForwardIterator2>
   ForwardIterator2 swap_ranges(
      ForwardIterator1 _First1, 
      ForwardIterator1 _Last1,
      ForwardIterator2 _First2
   );  //函数返回_First2 + _Last1 - First1














21.随机洗牌


template<class RandomAccessIterator>
   void random_shuffle(
      RandomAccessIterator _First, 
      RandomAccessIterator _Last
   );
template<class RandomAccessIterator, class RandomNumberGenerator>
   void random_shuffle(
      RandomAccessIterator _First, 
      RandomAccessIterator _Last, 
      RandomNumberGenerator& _Rand  //函数对象
   );


函数原形:  distance_type fn(distance_type i)     //算法依次从1-(_Last-_First)做为参数调用函数对象,函数对象返回的结果应该在0到N-1之间




22.元素的替换


template<class ForwardIterator, class Type>
   void replace(
      ForwardIterator _First, 
      ForwardIterator _Last,
      const Type& _OldVal, 
      const Type& _NewVal
   );




template<class ForwardIterator, class Predicate, class Type>
   void replace_if(
      ForwardIterator _First, 
      ForwardIterator _Last,
      Predicate _Pred,    //参考(23) 
      const Type& _Val
   );




23.替换指定的元素,并将最后的结果拷贝一个新的迭代器中


template<class InputIterator, class OutputIterator, class Type>
   OutputIterator replace_copy(
      InputIterator _First, 
      InputIterator _Last, 
      OutputIterator _Result,  //输出的结果
      const Type& _OldVal, 
      const Type& _NewVal
   );  //返回_Result + _Last - _First


template<class InputIterator, class OutputIterator, class Predicate, class Type>
   OutputIterator replace_copy_if(
      InputIterator _First, 
      InputIterator _Last, 
      OutputIterator _Result, 
      Predicate _Pred,    //函数对象
      const Type& _Val
   );


函数原形:  bool Fn(TYPE e)    //若迭代中元素调用函数为true则替换并拷贝到目标








24.关于堆的函数


(1).构造一个堆


template<class RandomAccessIterator>
   void make_heap(
      RandomAccessIterator _First, 
      RandomAccessIterator _Last
   );   //默认构造出一个大根堆, 元素必须实现 <操作。 


template<class RandomAccessIterator, class BinaryPredicate>
   void make_heap(
      RandomAccessIterator _First, 
      RandomAccessIterator _Last,
      BinaryPredicate _Comp    //函数对象， 两个参数右子树元素在前，左子树在后。
   );




(2).重新构建一个堆


template<class RandomAccessIterator>
   void push_heap(
      RandomAccessIterator _First, 
      RandomAccessIterator _Last     //最新元素放在_Last-1处而_First -- _Last-2已经是一个大根堆
   );
template<class RandomAccessIterator, class BinaryPredicate>
   void push_heap(
      RandomAccessIterator _First, 
      RandomAccessIterator _Last,
      BinaryPredicate _Comp
   );






template<class RandomAccessIterator>
   void pop_heap(
      RandomAccessIterator _First, 
      RandomAccessIterator _Last
   );
template<class RandomAccessIterator, class BinaryPredicate>
   void pop_heap(
      RandomAccessIterator _First, 
      RandomAccessIterator _Last,
      BinaryPredicate _Comp
   );




(3).排序一个堆


template<class RandomAccessIterator>
   void sort_heap(
      RandomAccessIterator _First, 
      RandomAccessIterator _Last
   );
template<class RandomAccessIterator, class Pr>
   void sort_heap(
      RandomAccessIterator _First, 
      RandomAccessIterator _Last,
      BinaryPredicate _Comp
   );






25.消除相邻的重复元素


template<class ForwardIterator>
   ForwardIterator unique(
      ForwardIterator _First, 
      ForwardIterator _Last
   );
template<class ForwardIterator, class Pr>
   ForwardIterator unique(
      ForwardIterator _First, 
      ForwardIterator _Last,
      BinaryPredicate _Comp    //参考list中的说明
   );


//返回不连贯的最后一个元素的下一个




26.将相邻不重复的元素拷贝到另外一个迭代器中


template<class InputIterator, class OutputIterator>
   OutputIterator unique_copy(
      InputIterator _First, 
      InputIterator _Last, 
      OutputIterator _Result
   );
template<class InputIterator, class OutputIterator, class BinaryPredicate>
   OutputIterator unique_copy(
      InputIterator _First, 
      InputIterator _Last, 
      OutputIterator _Result,
      BinaryPredicate _Comp,  //参考前面
   );






27.在有序的迭代器中查找元素应该放入的位置：


//查找大于等于_Val的迭代器位置


template<class ForwardIterator, class Type>     //这里是升序
   ForwardIterator lower_bound(
      ForwardIterator _First, 
      ForwardIterator _Last,
      const Type& _Val     //元素必须实现<操作运算。迭代器元素在左,_Val在右。若比较为真则应该继续用下一个迭代比较，这样就最后得到大于等于_Val的位置


   );    //返回第一个大于等于_Val的元素的迭代器所在的位置，若所有都小于则返回_Last,若所有都大于等于则返回_First,也就是返回第一个可以安插的地方


template<class ForwardIterator, class Type, class BinaryPredicate>
   ForwardIterator lower_bound(
      ForwardIterator _First, 
      ForwardIterator _Last,
      const Type& _Val,
      BinaryPredicate _Comp  //函数对象, 两个参数迭代在左,_Val在右,若返回true则应该继续用下一个迭代比较_Val,否则继续查看前一个,若前一个小则返回左边迭代.返回的是迭代器的位置,也就是返回最后一个可以安插的地方
   );


//也就是查找满足条件fn(IT,_VAL)的第一个值






//查找大于_Val的迭代器的位置


template<class ForwardIterator, class Type>
   ForwardIterator upper_bound(
      ForwardIterator _First, 
      ForwardIterator _Last,
      const Type& _Val     //元素必须实现<操作符, _Val在左,迭代器在右,当比较为真时则返回迭代器,否则用下一个迭代继续比较
   );
template<class ForwardIterator, class Type, class Pr>
   ForwardIterator upper_bound(
      ForwardIterator _First, 
      ForwardIterator _Last,
      const Type& _Val,
      BinaryPredicate _Comp  //函数对象: 两个参数, _Val在左, 迭代器在右,当返回为true时则返回迭代器,否则用下一个继续比较,也就是查找满足条件fn(_Val,IT)的第一个值
   );






28.元素的划分


//不稳定划分
template<class BidirectionalIterator, class Predicate>
   BidirectionalIterator partition(
      BidirectionalIterator _First, 
      BidirectionalIterator _Last, 
      BinaryPredicate _Comp      //函数对象,接收一个参数, 若返回true则元素被放到前面部分,而返回false则放到后面部分,
   );  //函数返回不满足条件的元素的开始位置.




//稳定划分
template<class BidirectionalIterator, class Predicate>
   BidirectionalIterator stable_partition(
      BidirectionalIterator _First, 
      BidirectionalIterator _Last,
      Predicate _Pred
   );






29.字典比较


template<class InputIterator1, class InputIterator2>
   bool lexicographical_compare(
      InputIterator1 _First1,
      InputIterator1 _Last1,
      InputIterator2 _First2,
      InputIterator2 _Last2
   );
template<class InputIterator1, class InputIterator2, class BinaryPredicate>
   bool lexicographical_compare(
      InputIterator1 _First1,
      InputIterator1 _Last1, 
      InputIterator2 _First2, 
      InputIterator2 _Last2,
      BinaryPredicate _Comp       //函数对象， 两个参数，可以是迭代器1也可以是迭代2。若返回
   );


//依次比较两个迭代器的每个元素,若在比较中有第一个迭代元素小于第二个的话则返回true,否则返回false。若是相等则继续比较
注意若在_First1 到_Last1这段长度内都相等时若迭代2中还要长时返回true,而没有长度时返回false






30.查找最大，最小值


template<class Type>
   const Type& max(
      const Type& _Left, 
      const Type& _Right
   );
template<class Type, class Pr>
   const Type& max(
      const Type& _Left, 
      const Type& _Right,
      BinaryPredicate _Comp         //函数对象, 若返回真则返回后面后面参数,
   );




template<class ForwardIterator>
   ForwardIterator max_element(
      ForwardIterator _First, 
      ForwardIterator _Last          //必须实现<操作符
   );
template<class ForwardIterator, class BinaryPredicate>
   ForwardIterator max_element(
      ForwardIterator _First, 
      ForwardIterator _Last, 
      BinaryPredicate _Comp    //函数对象,若返回为真,则表示第一个小于第二个,也表示第二个有可能是最大
   );




template<class ForwardIterator>
   ForwardIterator min_element(
      ForwardIterator _First, 
      ForwardIterator _Last    //必须实现 <操作符
   );
template<class ForwardIterator, class BinaryPredicate>
   ForwardIterator min_element(
      ForwardIterator _First, 
      ForwardIterator _Last,
      BinaryPredicate _Comp   //函数对象,若返回为真,则表示第一个元素小于第二个元素,也表示第一个元素可能是最小
   );






31.合并排序,将两个有序的迭代合并返回到第三个迭代,函数返回_Result + _Last1-_First1 + _Last2 - First2.若有重复时则只将第一个迭代放入新迭代中


template<class InputIterator1, class InputIterator2, class OutputIterator>
   OutputIterator merge(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      InputIterator2 _Last2, 
      OutputIterator _Result          //必须实现 < 操作
   );
template<class InputIterator1, class InputIterator2, class OutputIterator, class BinaryPredicate>
   OutputIterator merge(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      InputIterator2 _Last2, 
      OutputIterator _Result
      BinaryPredicate _Comp    //函数对象, 迭代2在前面,迭代1在后面,  若函数返回true则将第一个参数放入新迭代,否则将第二个放入
   );




32.就地合并
template<class BidirectionalIterator>
   void inplace_merge(
      BidirectionalIterator _First, 
      BidirectionalIterator _Middle,  //_First - _Middle-1 是一个有序的区域,  _Middle - _Last - 1是另外一个区域, 执行后将合并为一个新的有序区域
      BidirectionalIterator _Last     //必须实现 < 操作
   );
template<class BidirectionalIterator, class Pr>
   void inplace_merge(
      BidirectionalIterator _First, 
      BidirectionalIterator _Middle,
      BidirectionalIterator _Last,
      BinaryPredicate _Comp   //函数对象
   );






33.拆分有序
template<class RandomAccessIterator>
   void nth_element(
      RandomAccessIterator _First, 
      RandomAccessIterator _Nth, 
      RandomAccessIterator _Last
   );              //使得以_Nth为中介其左边的所有元素都小于等于右边的所有元素
template<class RandomAccessIterator, class BinaryPredicate>
   void nth_element(
      RandomAccessIterator _First, 
      RandomAccessIterator _Nth, 
      RandomAccessIterator _Last,
      BinaryPredicate _Comp
   );




34.一系列数值算法,必须包括<numeric>头文件


(1).求累加
template<class InputIterator, class Type>
   Type accumulate(
      InputIterator _First, 
      InputIterator _Last, 
      Type _Val           //将迭代的所有元素都加上_Val,并返回累加的结果, 必须实现+运算, 而且_Val则左边
   );
template<class InputIterator, class Type, class Fn2>
   Type accumulate(
      InputIterator _First, 
      InputIterator _Last, 
      Type _Val, 
      BinaryOperation _Binary_op   //函数对象,原形为:  Type Fn(Type, *迭代器)。 对每个元素调用函数对象，并将结果继续保存给_Val
   );




(2).求内积


template<class InputIterator1, class InputIterator2, class Type>
   Type inner_product(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      Type _Val
   );              //依次求 _Val = _Val + *迭代1 *  *迭代2,  最后返回最后结果,


template<class InputIterator1, class InputIterator2, class Type,
   class BinaryOperation1, class BinaryOperation2>
   Type inner_product(
      InputIterator1 _First1, 
      InputIterator1 _Last1,
      InputIterator2 _First2, 
      Type _Val, 
      BinaryOperation1 _Binary_op1, 
      BinaryOperation2 _Binary_op2
   );  //两个函数对象  _Val = Op1(_Val, Op2(*迭代1, *迭代2));






(3).部分累加
template<class InputIterator, class OutIt>
   OutputIterator partial_sum(
      InputIterator _First, 
      InputIterator _Last,
      OutputIterator _Result   //*_Result =  *_First1,  *(_Result + 1) = *(_First + 1) + *_Result
   );


template<class InputIterator, class OutIt, class Fn2>
   OutputIterator partial_sum(
      InputIterator _First, 
      InputIterator _Last,
      OutputIterator _Result, 
      BinaryOperation _Binary_op   //_Result的第一个元素为_First,而其后的每个元素都是op(前面的累加和, *迭代器)
   );




//上面的算法中,若迭代器为空则返回_Result


(4).相邻差


template<class InputIterator, class OutIterator>
   OutputIterator adjacent_difference(
      InputIterator _First, 
      InputIterator _Last,
      OutputIterator _Result   //在输出中,第一个元素是_First,而以后的元素都是后面的一个减去前面的一个的值
   );


template<class InputIterator, class OutIterator, class BinaryOperation>
   OutputIterator adjacent_difference(
      InputIterator _First, 
      InputIterator _Last,
      OutputIterator _Result, 
      BinaryOperation _Binary_op   //在输出中,第一个元素是_First,而以后的元素都是调用op返回的值,而函数的参数中第一个是前面的迭代,而第二个则是后面的迭代
   );