STL中的常用algorithm知识点

最新推荐文章于 2022-06-01 23:46:24 发布
最新推荐文章于 2022-06-01 23:46:24 发布
阅读量1.1k 收藏
点赞数
分类专栏： STL C++/C 文章标签： STL algorithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangtiang/article/details/22795805
版权
STL 同时被 2 个专栏收录
15 篇文章 0 订阅
订阅专栏
C++/C
15 篇文章 0 订阅
订阅专栏
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返回的值,而函数的参数中第一个是前面的迭代,而第二个则是后面的迭代
   );



欧阳大哥2013
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL-.rar_C 知识点
09-24
STL编程，这里主要包含利用STL中的知识创建栈，堆，队列等知识，容易被遗忘的知识点
一些比较基础的知识点
Algor_pro_king_John的博客
11-08 240
树链剖分 这是一个很简单的知识点. 主要思想是把树按照重链进行剖分. 重链指的是一条由顶点与重儿子相连，再由重儿子与重儿子的重儿子相连……组成的链。 而重儿子则指的是一个点所有儿子中size最大的节点. 有了这个工具，我们再求解许多问题时都可以方便许多. 例如，题目要求两点LCA，那么只需要这样打就好了： int Go(int x, int y) { while (x...
algodoo学习（2）——判断函数
weixin_44004835的博客
06-01 925
algodoo的判断函数怎么写呢？
范型编程与STL--第二章iterator(迭代器)解析
菜菜鸟的成长记录
06-18 588
C++完成线性查找 c语言函数find查找只能查找某一个类型的数组,在C++中可以使用模板 template//C++模板 T *find2(T *first, T *last, T value); 更一般化 template Iterator find(iterator first, Iterator last, const T &value) { while (first != l
STL学习笔记6 ——浅谈迭代器
我有两颗糖
10-18 470
文章目录一、迭代器二、迭代器的使用三、迭代器辅助函数 一、迭代器 常用的迭代器按功能强弱分为输入迭代器、输出迭代器、前向迭代器、双向迭代器、随机访问迭代器 5 种。 前向迭代器（forward iterator） 假设 p 是一个前向迭代器，则 p 支持 ++p，p++，*p 操作，还可以被复制或赋值，可以用 == 和 != 运算符进行比较。此外，两个正向迭代器可以互相赋值。 支持前向迭代器的容器有：forward_list / unordered_map / unordered_multimap / u
STL常用algorithms
weixin_43619346的博客
08-24 143
// 简单查找算法，要求输入迭代器（input iterator） find(beg, end, val); // 返回一个迭代器，指向输入序列中第一个等于 val 的元素，未找到返回 end find_if(beg, end, unaryPred); // 返回一个迭代器，指向第一个满足 unaryPred 的元素，未找到返回 end find_if_not(beg, end, unaryPred); // 返回一个迭代器，指向第一个令 unaryPred 为 false 的元素，未找到返回 end co
STL知识点思维导图
12-18
组成的库来说提供了更好的代码重用机会。在C++标准中，STL被组织为下面的几个头文件：、、、、<algorithm>、、、、、、、、和。文件中主要介绍了前面八个的使用，并且重点介绍了他们的属性和一些成员函数的使用。
C++STL中algorithm里find()函数
01-06
C++STL中algorithm里find()函数 1.string中的运用 1.1函数原型及描述 函数1 size_type find(const string & str, size_type pos = 0) const 形参列表str：要查找的子字符串string变量，pos ：要查找的起始位位置 ...
stl.rar_STL中文手册
09-24
C++库函数参考手册，很有用的说~~本来叫C++库函数参考手册，说是有中文字符不让，所以为换成这个了
STL常用算法总结
qq_36534594的博客
03-22 515
常用遍历算法 头文件：<algorithm> <functional> <numeric> <algorithm>是所有STL文件中最大的一个，范围涉及比较、交换、查找、遍历操作、复制、修改等等 <functional>体积很小，只包含几个在序列上面进行简单数学运算的模板函数 <numeric>定义了一些模板类，用以声明函数对象 常用遍历算法 1. for_each//遍历容器 2. transform //搬运容器到另一个容器中
【C++ STL】算法 <algorithm>中各种算法解析
WTT_1988的专栏
07-07 1133
一，巡防算法         for_each(容器起始地址，容器结束地址，要执行的方法) [html] view plaincopy #include iostream>   #include algorithm>   #include vector>      using namespace std;     
模板元函数（七）
Landlord的专栏
01-30 829
2.3 数值元函数你甚至惊讶于用上面的表达可，元函数就可以产生数值。不，我们并不是要你给一个已经是数字的名字一个类型。一个具有数值结果的元函数的 ::type 结果是一个真正的类型，一个整型常数的包装器。而它的内嵌 ::value 是一个整形常量。我们会在第 4 章中展示其具体细节，但这个时候，下面的例子可以给你一个直观的感受：    struct five // 整形常量
algodoo是什么意思_algodoo在中学物理教学中的应用 (1)
weixin_30995429的博客
12-23 2497
Algodoo软件在中学物理教学中的应用黄伟(江苏省海安高级中学江苏海安226600)摘要：Algodoo软件是一款可以实现多种场景仿真的模拟软件，呈现在学生面前的不仅仅是其极具趣味性的卡通式画面，更重要的是它能够激发学生求知、创新的欲望。关键词：Algodoo软件；物理教学；仿真在中学物理教学中，由于时间、场地、设备、技术等条件的限制，很多物理情境得不到充分的展现。有时候仅靠老师描述，不够生动形...
c++ template之trait技法总结
水人的专栏
03-19 9672
Trait技法的最初目的是为了管理模板参数，有的时候模板中需要几个参数，但是往往有些参数是与main parameters紧密相关的，这时候可以使用trait技巧，从几个主要的模板参数中推导出相应的secondary template argument，并以默认模板参数的形式出现在模板中。实际上使用的trait技巧实例往往会有效地提高程序的效率，下面我结合STL小小的说说trait的实际运用。
STL 容器,算法,迭代器 总
guguarchieve的专栏
04-29 953
一、容器 作为STL的最主要组成部分－－容器，分为向量（vector），双端队列(deque)，表(list)，队列（queue），堆栈(stack)，集合(set)，多重集合(multiset)，映射(map)，多重映射(multimap)。容器 特性所在头文件向量vector可以用常数时间访问和修改任意元素，在序列尾部进行插入和删除时，具有常数时间复杂度，对任意项的插入和删除就有的时间复杂度与
【转】STL算法 <algorithm>中各种算法解析
weixin_30925411的博客
08-10 81
原文：http://blog.csdn.net/tianshuai1111/article/details/7674327 一，巡防算法 for_each(容器起始地址，容器结束地址，要执行的方法) #include <iostream> #include <algorithm> #include <vector> ...
18其他算法（algo）——单纯的数据处理
Revendell的博客
11-30 507
1、单纯的数据处理 有一些算法是只进行单纯的数据移动、线性查找、计数、循环遍历、逐一对元素施行指定运算等操作。这些算法运作逻辑都相对单纯、直观且易懂。 2、adjacent_find 找出第一组满足条件的相邻元素。在版本一中是相邻两元素相等，在版本二中是用户指定一个二元运算，两个操作数分别是相邻的两个元素。 template <class ForwardIterator> ForwardIterator adjacent_find(ForwardIterator first, Forw
常用 STL algorithm
12-10 895
争取把每次遇到的添加进来 第一个：  sort(); 默认对n个数进行从小到大排列 调用方法  sort(a,a+n);    //n为需要排序的个数 #include #include using namespace std; int main() { int a[4]={4,3,2,1}; sort(a,a+4); for(int i=0;i<4;i++) printf
python 迭代器
symoriaty的博客
08-31 1634
阿里云大学人工智能学前小测验-Python测试 3.下列关于迭代器说法错误的是 A. 迭代是访问集合元素的一种方式 B. 迭代器是一个可以记住遍历的位置的对象 C. 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束 D. 迭代器可以往前也可以后退 参考资料：https://www.cnblogs.com/python-road/p/10504474.html，感谢博主！...
STL中deque常用接口
最新发布
07-15
STL（标准模板库）中的 `deque`（双端队列）是一个动态数组，支持在队列的两端进行高效插入和删除操作。下面是一些 `deque` 常用的接口： 1. `push_back(value)`: 在 `deque` 的尾部插入一个元素。 2. `push_front...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值