从零开始学C++之STL（七）：剩下5种算法代码分析与使用示例（remove 、rotate 、sort、lower_bound、accumulate）

最新推荐文章于 2022-11-09 08:32:47 发布
最新推荐文章于 2022-11-09 08:32:47 发布
阅读量410 收藏
点赞数
分类专栏： c/c++

转：http://blog.csdn.net/jnu_simba/article/details/9471503

一、移除性算法 （remove）

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// TEMPLATE FUNCTION remove_copy
 template <  class _InIt,
          class _OutIt,
          class _Ty >  inline
_OutIt _Remove_copy(_InIt _First, _InIt _Last,
                    _OutIt _Dest,  const _Ty &_Val, _Range_checked_iterator_tag)
{
     // copy omitting each matching _Val
    _DEBUG_RANGE(_First, _Last);
    _DEBUG_POINTER(_Dest);
     for (; _First != _Last; ++_First)
         if (!(*_First == _Val))
            *_Dest++ = *_First;
     return (_Dest);
}


template <  class _InIt,
          class _OutIt,
          class _Ty >  inline
_OutIt unchecked_remove_copy(_InIt _First, _InIt _Last,
                             _OutIt _Dest,  const _Ty &_Val)
{
     // copy omitting each matching _Val
     return _STD _Remove_copy(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Dest, _Val,
                             _STD _Range_checked_iterator_tag());
}


// TEMPLATE FUNCTION remove
 template <  class _FwdIt,
          class _Ty >  inline
_FwdIt remove(_FwdIt _First, _FwdIt _Last,  const _Ty &_Val)
{
     // remove each matching _Val
    _First = find(_First, _Last, _Val);
     if (_First == _Last)
         return (_First);     // empty sequence, all done
     else
    {
         // nonempty sequence, worth doing
        _FwdIt _First1 = _First;
         return (_STDEXT unchecked_remove_copy(++_First1, _Last, _First, _Val));
    }
}

如下图所示：


假设现在想要remove 的元素是3，则传入到 _Remove_copy 函数的3个参数如上图第一行所示，Val 即3。


接着遍历First ~ Last 区间的元素，将非移除元素拷贝到前面，覆盖前面的元素，最后的指向如图，函数返回的是Dest 位置，如下代


码所示：


for (; _First != _Last; ++_First)


 if (!(*_First == _Val))


            *_Dest++ = *_First;


由上图可看出移除性算法并没有改变元素的个数，如果要真正删除，可以将remove 的返回值传入erase 进行删除，如：


v.erase(remove(v.begin(), v.end(), 3), v.end()); 即会将后面两个元素4 和 5 删除掉。


在这里顺便提一下，erase 会使当前迭代器失效，但可以返回下一个迭代器，故如果需要在遍历中删除，下面的做法才是正确的：


 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <iostream>
#include <vector>

using  namespace std;

int main( void)
{
     int a[] = { 3,  1,  2,  3,  4};
    vector< int> v(a, a +  5);

     //for (vector<int>::iterator it=v.begin(); it!=v.end(); ++it)
     //{
     //  if (*it == 3)
     //      v.erase(it);          ERROR!
     //  else
     //      cout<<*it<<' ';
     //}
     for (vector< int>::iterator it = v.begin(); it != v.end();)
    {
         if (*it ==  3)
            it = v.erase(it);
         else
        {
            cout << *it <<  ' ';
            ++it;
        }
    }

    cout << endl;
     return  0;
}

示例代码1：

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using  namespace std;

void print_element( int n)
{
    cout << n <<  ' ';
}


int main( void)
{
     int a[] = {  1,  3,  2,  3,  4,  5 };
    vector< int> v(a, a +  6);

    for_each(v.begin(), v.end(), print_element);
    cout << endl;

     /*remove(v.begin(), v.end(), 3);
    for_each(v.begin(), v.end(), print_element);
    cout<<endl;*/

    v.erase(remove(v.begin(), v.end(),  3), v.end());
    for_each(v.begin(), v.end(), print_element);
    cout << endl;

     return  0;
}

二、变序性算法（ rotate）

 C++ Code 
1
2
3
4
5
6
7
template< class _FwdIt>  inline
void rotate(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last)
{
     // rotate [_First, _Last)
     if (_First != _Mid && _Mid != _Last)
        _Rotate(_CHECKED_BASE(_First), _CHECKED_BASE(_Mid), _CHECKED_BASE(_Last), _Iter_cat(_First));
}

rotate 调用了_Rotate，实际上_Rotate 继续调用了某个函数，内部实现代码比较长，而且不容易看懂，这边可以看一下简易的等价


版本实现，来自这里，如下：

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
template < class ForwardIterator>
void rotate (ForwardIterator first, ForwardIterator middle,
             ForwardIterator last)
{
    ForwardIterator next = middle;
     while (first != next)
    {
        swap (*first++, *next++);
         if (next == last) next = middle;
         else  if (first == middle) middle = next;
    }
}

假设一个容器有 1 2 3 4 5 6 六个元素，现在想把 1 2 放到后面去，可以这样写 rotate(v.begin(), v.begin()+2, v.end());  如下图所示：


即将first 与 next 对应的元素互换且不断向前推进，直到first == next 为止。


三、排序算法 （sort）

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
template< class _RanIt>  inline
void sort(_RanIt _First, _RanIt _Last)
{
     // order [_First, _Last), using operator<
    _DEBUG_RANGE(_First, _Last);
    std::_Sort(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Last - _First);
}

template <  class _RanIt,
          class _Pr >  inline
void sort(_RanIt _First, _RanIt _Last, _Pr _Pred)
{
     // order [_First, _Last), using _Pred
    _DEBUG_RANGE(_First, _Last);
    _DEBUG_POINTER(_Pred);
    std::_Sort(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Last - _First, _Pred);
}

sort 重载了两个版本，第一个版本只有2个参数，默认按从小到大排序（using operator<)；第二个版本有三个参数，即可以自定义比较逻辑


（_Pred）。它们都调用了标准库的std::_Sort， 跟踪进去发现比较复杂，在_Sort 内会根据一些条件选择不同的排序方式，如标准库的堆排序，合并


排序，插入排序等等。站在使用的角度看，没必要去深究，但如果是想学习相关的排序，那是很好的资源。


示例代码2：

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using  namespace std;

void print_element( int n)
{
    cout << n <<  ' ';
}

bool my_greater( int a,  int b)
{
     return a > b;
}

int main( void)
{
     int a[] = {  1,  2,  3,  4,  5,  6 };
    vector< int> v(a, a +  6);

    for_each(v.begin(), v.end(), print_element);
    cout << endl;

    rotate(v.begin(), v.begin() +  2, v.end());
    for_each(v.begin(), v.end(), print_element);
    cout << endl;

    sort(v.begin(), v.end());
    for_each(v.begin(), v.end(), print_element);
    cout << endl;

    sort(v.begin(), v.end(), my_greater);
    for_each(v.begin(), v.end(), print_element);
    cout << endl;

     return  0;
}

此外，sort 有个坑，如果你自己传递比较逻辑，需要注意，如下：



四、已序区间算法 （lower_bound 、upper_bound）


使用这些算法的前提是区间已经是有序的。

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// TEMPLATE FUNCTION lower_bound
 template <  class _FwdIt,
          class _Ty,
          class _Diff >  inline
_FwdIt _Lower_bound(_FwdIt _First, _FwdIt _Last,  const _Ty &_Val, _Diff *)
{
     // find first element not before _Val, using operator<
    _DEBUG_ORDER_SINGLE(_First, _Last,  true);
    _Diff _Count =  0;
    _Distance(_First, _Last, _Count);

     for (;  0 < _Count; )
    {
         // divide and conquer, find half that contains answer
        _Diff _Count2 = _Count /  2;
        _FwdIt _Mid = _First;
        std::advance(_Mid, _Count2);
        _DEBUG_ORDER_SINGLE(_Mid, _Last,  false);

         if (_DEBUG_LT(*_Mid, _Val))
            _First = ++_Mid, _Count -= _Count2 +  1;
         else
            _Count = _Count2;
    }
     return (_First);
}

template <  class _FwdIt,
          class _Ty >  inline
_FwdIt lower_bound(_FwdIt _First, _FwdIt _Last,  const _Ty &_Val)
{
     // find first element not before _Val, using operator<
    _ASSIGN_FROM_BASE(_First,
                      _Lower_bound(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Val, _Dist_type(_First)));
     return _First;
}

lower_bound() 返回第一个“大于等于给定值" 的元素位置，其实还重载了另一个low_bound 版本，如下：


 C++ Code 
1
2
3
4
5
6
7
// TEMPLATE FUNCTION lower_bound WITH PRED
 template <  class _FwdIt,
          class _Ty,
          class _Diff,
          class _Pr >  inline
_FwdIt _Lower_bound(_FwdIt _First, _FwdIt _Last,
                     const _Ty &_Val, _Pr _Pred, _Diff *)

也就是可以自定义比较逻辑，需要注意的是如果使用这个版本，那么区间应该本来就是按comp 方法排序的，如下面这句话：


The elements are compared using operator< for the first version, and comp for the second. The elements in the range shall already

 be sorted according to this same criterion (operator< or comp), or at least partitioned with respect to val.


由于是已序区间，所以函数内用的是二分查找，而两个版本主要的代码不同在于：


_DEBUG_LT(*_Mid, _Val)


_DEBUG_LT_PRED(_Pred, *_Mid, _Val)


upper_bound 与 lower_bound 类似，不过返回的是第一个”大于给定值“ 的元素位置。


示例代码3：

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using  namespace std;

void print_element( int n)
{
    cout << n <<  ' ';
}


int main( void)
{
     int a[] = {  1,  10,  10,  14,  15,  16 };
    vector< int> v(a, a +  6);

    for_each(v.begin(), v.end(), print_element);
    cout << endl;

    vector< int>::iterator it;
    it = lower_bound(v.begin(), v.end(),  10);
     if (it != v.end())
    {
        cout << it - v.begin() << endl;
    }

    it = upper_bound(v.begin(), v.end(),  10);
     if (it != v.end())
    {
        cout << it - v.begin() << endl;
    }

     return  0;
}


五、数值算法（accumulate）


 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
// TEMPLATE FUNCTION accumulate
 template <  class _InIt,
          class _Ty >  inline
_Ty _Accumulate(_InIt _First, _InIt _Last, _Ty _Val)
{
     // return sum of _Val and all in [_First, _Last)
    _DEBUG_RANGE(_First, _Last);
     for (; _First != _Last; ++_First)
        _Val = _Val + *_First;
     return (_Val);
}

template <  class _InIt,
          class _Ty >  inline
_Ty accumulate(_InIt _First, _InIt _Last, _Ty _Val)
{
     // return sum of _Val and all in [_First, _Last)
     return _Accumulate(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Val);
}

// TEMPLATE FUNCTION accumulate WITH BINOP
 template <  class _InIt,
          class _Ty,
          class _Fn2 >  inline
_Ty _Accumulate(_InIt _First, _InIt _Last, _Ty _Val, _Fn2 _Func)
{
     // return sum of _Val and all in [_First, _Last), using _Func
    _DEBUG_RANGE(_First, _Last);
    _DEBUG_POINTER(_Func);
     for (; _First != _Last; ++_First)
        _Val = _Func(_Val, *_First);
     return (_Val);
}

template <  class _InIt,
          class _Ty,
          class _Fn2 >  inline
_Ty accumulate(_InIt _First, _InIt _Last, _Ty _Val, _Fn2 _Func)
{
     // return sum of _Val and all in [_First, _Last), using _Func
     return _Accumulate(_CHECKED_BASE(_First), _CHECKED_BASE(_Last), _Val, _Func);
}


accumulate 重载了两个版本，第一个版本实现的是累加，第二个版本带_Func 参数，可以自定义计算，比如累乘等。代码都比较好理解，就不赘述


了。看下面的示例代码4：

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <numeric>
using  namespace std;

void print_element( int n)
{
    cout << n <<  ' ';
}

int mult( int a,  int b)
{
     return a * b;
}

int main( void)
{
     int a[] = {  1,  2,  3,  4,  5 };
    vector< int> v(a, a +  5);

    for_each(v.begin(), v.end(), print_element);
    cout << endl;

     // 累加
    cout << accumulate(v.begin(), v.end(),  0) << endl;

     // 累乘
    cout << accumulate(v.begin(), v.end(),  1, mult) << endl;

     return  0;
}

参考：

C++ primer 第四版
Effective C++ 3rd
C++编程规范

confiself
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
11-10
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
C++文件操作基础+实战
weixin_45498562的博客
08-01 943
目录 C++文件操作理论 1、打开文件用于读和写 open（） 2、检查文件打开是否成功 fail（） 3、读或者写 read（）,write（） 4、检查是否读完 EOF（end of file) 5、使用完文件后关闭文件 close（） 6、文件的打开方式 C++文件操作基础实战 1、以追加数据的方式打开文件test_demo.txt,向该文件写入我们输入的数据 ...
C++STL accumulate函数
weixin_43890415的博客
03-03 2790
accmulate函数可用于计算特定范围内元素的和 定义于numeric头文件 #include<numeric> 1.若 vector容器为int型 int sum = accumulate(v.begin(),v.end(),0); sum的值即为v容器中所有元素之和 三个形参中头两个形参指定要累加的元素范围，第三个形参指累加的初值，返回类型为第三个实参的类型。 2.若vector容器为string类型 string sum = accumulate(v.begin(),v.end().
数组左旋转k位 —— C++标准算法库中最悲剧的函数：rotate
weixin_34178244的博客
05-27 191
要将一个数组的所有元素向左旋转k位，通常有三种算法： 算法1（分组交换）： 若a长度大于b，将ab分成a0a1b，交换a0和b，得ba1a0，只需再交换a1 和a0。 若a长度小于b，将ab分成ab0b1，交换a和b0，得b0ab1，只需再交换a 和b1。 不断将数组划分和交换，直到不能再划分为止。分组过程与求最大公约数很相似。 读写内存各 n到2*n次 算法2 (...
小于号重载须注意的问题——strict weak ordering
jcwKyl的专栏
07-11 5678
  这是今天写程序中遇到的两个诡异的问题。我的IDE是VC++2005 ExpressiEdition。 第一个问题是关于map的。话不多说，以下20多行的C++代码重现了我遇到的问题： #include #include using namespace std;
掌握C++ STL：深入理解与应用lower-bound函数.txt
02-24
lower_bound函数
掌握STL之lower-bound函数：提升搜索效率的利器.txt
最新发布
02-24
lower_bound函数
从逆向角度看C++ STL代码之std::map
11-13
从逆向角度看C++ STL代码之std::map
STL.rar_C++ STL_STL_site:www.pudn.com_visual c
09-23
stl容器简介，包括STL概念及具体容器使用方法等
从零开始学C++之STL（七）：剩下5种算法代码分析与使用示例（remove 、rotate 、sort、lower_bound、accumulate）...
winform采集
07-26 138
一、移除性算法 （remove） C++ Code &lt;nobr&gt;1&lt;br&gt; 2&lt;br&gt; 3&lt;br&gt; 4&lt;br&gt; 5&lt;br&gt; 6&lt;br&gt; 7&lt;br&gt; 8&lt;br&gt; 9&lt;br&gt; 10&lt;
c++ std::rotate()的用法（一看就懂）
weixin_44378800的博客
06-02 8049
c++ std::rotate()的用法（一看就懂！）
C++11标准模板（STL）- 算法（std::rotate）
qq_40788199的博客
11-09 1523
1) 进行元素范围上的左旋转。 具体而言， std::rotate 交换范围 [first, last) 中的元素，方式满足元素 n_first 成为新范围的首个元素，而 n_first - 1 成为最后元素。 此函数的前提条件是 [first, n_first) 和 [n_first, last) 为合法范围。
STL中sort函数的自定义排序问题
温暖不了你的心的博客
02-22 138
定义 template<class _RanIt> inline void sort(_RanIt _First, _RanIt _Last) template<class _RanIt,class _Pr> inline void sort(_RanIt _First, _RanIt _Last, _Pr _Pred) 提供两种调用方式，一种是使用默认的<操作符（升序）比较；一种可以自定义函数 使用 #include<iostream> #include&l
错误 1 error C2782: “_FwdIt std::partition(_FwdIt,_FwdIt,_Pr)”: 模板 参数“_FwdIt”不明确 f:\2017-8\9 排序\9 排序\m
huanghxyz的博客
09-10 847
问题出在写快速排序算法的时候，被调用函数放在了调用函数的后面，而刚好被调用函数的函数名称是一个系统函数，发生了实参与形参不匹配的情况。 由于报错信息莫名其妙，系统函数的形参名字与自己写的函数形参很不一样，所以找了半天的bug。 养成良好的编程习惯很重要。 解决办法：把被调用函数放在调用函数前面即可，或者在调用函数前面增加被调用函数的声明。 源代码如下： /* 快速排序，冒泡排序的进阶版
C++ STL算法lower_bound（16）
苦逼的程序猿
12-13 344
函数原型 //不带谓词 template<class _FwdIt, class _Ty> _NODISCARD inline _FwdIt lower_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val) //带谓词 template<class _FwdIt, class _Ty, class _Pr> _NODISCARD inline _FwdIt upper_bound(_FwdIt _First, _FwdI
除自身以外数组的乘积-左右累乘-c++
weixin_45594172的博客
09-28 822
除自身以外数组的乘积-左右累乘-c++
C++ Traits技术
weixin_30809173的博客
05-10 282
要想深入的理解STL的迭代器、分配器等，就必须了解C++模板编程中的一个技巧——Traits。 1、问题的提出 C++的模板特性为泛型编程提供了支持。这样我们就可以编写更加通用的代码，而不必过分去关心参数的类型。然而事实却是，类型的不同，很多时候却影响到了算法中的某个小小的实现。举个标准库里的类string,wstring。 其实它们对应的是两个模板，前者单字符，后者宽字符。 ...
c++ vector容器每个数相乘_C++中sizeof(vector)的问题
weixin_42110362的博客
01-26 2586
我们知道在C/C++中，sizeof() 是一个判断数据类型或者表达式长度的运算符，以字节为单位。当用 sizeof 判断一个vector类型的变量所占的内存大小时，结果会是什么呢？比如下面这段代码：#include <iostream> #include <vector> using namespace std; int main() { vector<i...
c++使用std::find实现lower_bound
05-27
使用`std::find`实现`std::lower_bound`的算法时间复杂度是$O(n)$，不如STL中的`std::lower_bound`的时间复杂度是$O(\log n)$。不过，这里仍然展示一下如何使用`std::find`实现`std::lower_bound`。 ```c++ #...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值