STL算法---拷贝/删除/替换算法

最新推荐文章于 2023-11-24 19:14:15 发布
最新推荐文章于 2023-11-24 19:14:15 发布
阅读量835 收藏
点赞数
分类专栏： C/C++ STL STL笔记 文章标签： STL算法 拷贝删除替换算法 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bagboy_taobao_com/article/details/38927555
版权
C/C++ 同时被 3 个专栏收录
152 篇文章 1 订阅
订阅专栏
STL
23 篇文章 0 订阅
订阅专栏
STL笔记
13 篇文章 0 订阅
订阅专栏

1. copy / copy_backward(复制序列)


1.1 copy 复制序列

函数原形
template<class InIt, class OutIt> OutIt copy(InIt first, InIt last, OutIt x);

1.2 copy_backward

与copy相同，不过元素是从后面开始顺序拷贝填充
函数原形
template<class BidIt1, class BidIt2> BidIt2 copy_backward(BidIt1 first, BidIt1 last, BidIt2 x); 
/
#include "stdafx.h"
#include <algorithm>
#include <numeric>
#include <functional>
#include <vector>
#include <iostream>

int _tmain(int argc, _TCHAR* argv[])
{
	std::vector<int> nV2, nV1;
	std::vector<int>::iterator iter;

	nV1.clear();
	nV1.push_back(12);
	nV1.push_back(13);
	nV1.push_back(14);
	nV1.push_back(15);
	nV1.push_back(50);
	nV1.push_back(7);
	nV1.push_back(23);
	nV1.push_back(27);
	nV1.push_back(28);
	nV1.push_back(30);
	nV1.push_back(34);
	nV1.push_back(35);
	nV1.push_back(37);
	nV2.resize(nV1.size() + 1);
	// 调用前nV1: 12, 13, 14, 15, 50, 7, 23, 27, 28, 30, 34, 35, 37
	// 调用前nV2: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
	iter = std::copy(nV1.begin(), nV1.end(), nV2.begin());
	// 调用后nV2: 12, 13, 14, 15, 50, 7, 23, 27, 28, 30, 34, 35, 37, 0(iter)

	nV1.clear();
	nV1.push_back(12);
	nV1.push_back(13);
	nV1.push_back(14);
	nV1.push_back(15);
	nV1.push_back(50);
	nV1.push_back(7);
	nV1.push_back(23);
	nV1.push_back(27);
	nV1.push_back(28);
	nV1.push_back(30);
	nV1.push_back(34);
	nV1.push_back(35);
	nV1.push_back(37);
	nV2.clear();
	nV2.resize(nV1.size() + 1);
	// 调用前nV1: 12, 13, 14, 15, 50, 7, 23, 27, 28, 30, 34, 35, 37
	// 调用前nV2: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
	iter = std::copy_backward(nV1.begin(), nV1.end(), nV2.end());	// 注意x是nV2.end()
	// 调用后nV2: 0,12(iter),13,14,15,50,7,23,27,28,30,34,35,37
	return 0;
}
说明:
1. copy 是first->last从左到右顺序遍历, x从左向右前进填充.
2. copy_backward 是last->first从右到左顺序遍历, x从右到左后退填充.

2. iter_swap

交换两个ForwardIterator的值, 就是两个值的交互.
函数原形
template<class FwdIt1, class FwdIt2> void iter_swap(FwdIt1 x, FwdIt2 y); 
/
#include "stdafx.h"
#include <algorithm>
#include <numeric>
#include <functional>
#include <vector>
#include <iostream>

int _tmain(int argc, _TCHAR* argv[])
{
	std::vector<int> nV1;

	nV1.clear();
	nV1.push_back(12);
	nV1.push_back(13);
	nV1.push_back(14);
	nV1.push_back(15);
	nV1.push_back(50);
	// 调用前: 12, 13, 14, 15, 50
	std::iter_swap(nV1.begin(), nV1.begin() + 2);
	// 调用前: 14, 13, 12, 15, 50

	return 0;
}

3. remove / remove_copy / remove_if / remove_copy_if (删除操作)


3.1 remove

删除[first, last)内所有等于val的全部元素。例如在std::vector中元素被左移.
函数原形
template<class FwdIt, class T> FwdIt remove(FwdIt first, FwdIt last, const T& val);

3.2 remove_copy

将所有不匹配元素复制到一个制定容器，返回OutputIterator指向被拷贝的末元素的下一个位置
函数原形
template<class InIt, class OutIt, class T> OutIt remove_copy(InIt first, InIt last, OutIt x, const T& val);

3.3 remove_if

删除指定范围内输入操作结果为true的所有元素
函数原形
template<class FwdIt, class Pred> FwdIt remove_if(FwdIt first, FwdIt last, Pred pr);

3.4 remove_copy_if

将所有不匹配元素拷贝到一个指定容器
函数原形
template<class InIt, class OutIt, class Pred> OutIt remove_copy_if(InIt first, InIt last, OutIt x, Pred pr); 
/
#include "stdafx.h"
#include <algorithm>
#include <numeric>
#include <functional>
#include <vector>
#include <iostream>

class MyObject1
{  
public:
	MyObject1(){}
	~MyObject1(){}
	// 括号操作符
    bool operator()(int val1)  
    {  
        return (0 > val1);
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
	std::vector<int> nV2, nV1;
	std::vector<int>::iterator iter;

	nV1.clear();
	nV1.push_back(12);
	nV1.push_back(13);
	nV1.push_back(14);
	nV1.push_back(15);
	nV1.push_back(50);
	nV1.push_back(14);
	nV1.push_back(23);
	nV1.push_back(27);
	nV1.push_back(28);
	nV1.push_back(30);
	nV1.push_back(34);
	nV1.push_back(35);
	nV1.push_back(37);
	// 调用前nV1: 12, 13, 14, 15, 50, 14, 23, 27, 28, 30, 34, 35, 37
	iter = std::remove(nV1.begin(), nV1.end(), 14);
	// 调用后nV1: 12, 13, 15, 50, 23, 27, 28, 30, 34, 35, 37, 35(iter), 37
	// 明显最后面两个元素是无效的, remove后元素被左移了, 最后面的35和37只是没有清除.

	nV1.clear();
	nV1.push_back(12);
	nV1.push_back(13);
	nV1.push_back(14);
	nV1.push_back(15);
	nV1.push_back(50);
	nV1.push_back(14);
	nV1.push_back(23);
	nV1.push_back(27);
	nV1.push_back(28);
	nV1.push_back(30);
	nV1.push_back(34);
	nV1.push_back(35);
	nV1.push_back(37);
	nV2.resize(nV1.size());
	// 调用前nV1: 12, 13, 14, 15, 50, 14, 23, 27, 28, 30, 34, 35, 37
	iter = std::remove_copy(nV1.begin(), nV1.end(), nV2.begin(), 14);
	// 调用前nV1: 12, 13, 14, 15, 50, 14, 23, 27, 28, 30, 34, 35, 37
	// 调用后nV2: 12, 13, 15, 50, 23, 27, 28, 30, 34, 35, 37, 0(iter), 0

	nV1.clear();
	nV1.push_back(12);
	nV1.push_back(13);
	nV1.push_back(-14);
	nV1.push_back(15);
	nV1.push_back(50);
	nV1.push_back(-14);
	nV1.push_back(23);
	nV1.push_back(27);
	nV1.push_back(28);
	nV1.push_back(30);
	nV1.push_back(34);
	nV1.push_back(35);
	nV1.push_back(37);
	// 调用前nV1: 12, 13, -14, 15, 50, -14, 23, 27, 28, 30, 34, 35, 37
	iter = std::remove_if(nV1.begin(), nV1.end(), MyObject1());
	// 调用后nV1: 12, 13, 15, 50, 23, 27, 28, 30, 34, 35, 37, 35(iter), 37
	// 明显最后面两个元素是无效的, remove后元素被左移了, 最后面的35和37只是没有清除.

	return 0;
}

4. replace / replace_copy / replace_if / replace_copy_if (替换操作)

4.1 replace

将指定范围内所有等于vold的元素都用vnew代替
函数原形
template<class FwdIt, class T> void replace(FwdIt first, FwdIt last,const T& vold, const T& vnew);

4.2 replace_copy

与replace类似，不过将结果写入另一个容器
函数原形
template<class InIt, class OutIt, class T> OutIt replace_copy(InIt first, InIt last, OutIt x, const T& vold, const T& vnew);

4.3 replace_if

将指定范围内所有操作结果为true的元素用新值代替
函数原形
template<class FwdIt, class Pred, class T> void replace_if(FwdIt first, FwdIt last, Pred pr, const T& val);

4.4 replace_copy_if

与replace_if，不过将结果写入另一个容器
函数原形
template<class InIt, class OutIt, class Pred, class T> OutIt replace_copy_if(InIt first, InIt last, OutIt x, Pred pr, const T& val); 
/
#include "stdafx.h"
#include <algorithm>
#include <numeric>
#include <functional>
#include <vector>
#include <iostream>

class MyObject1
{  
public:
	MyObject1(){}
	~MyObject1(){}
	// 括号操作符
    bool operator()(int val1)  
    {  
        return (0 > val1);
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
	std::vector<int> nV2, nV1;
	std::vector<int>::iterator iter;

	nV1.clear();
	nV1.push_back(12);
	nV1.push_back(13);
	nV1.push_back(14);
	nV1.push_back(15);
	nV1.push_back(50);
	nV1.push_back(14);
	nV1.push_back(23);
	nV1.push_back(27);
	nV1.push_back(28);
	nV1.push_back(30);
	nV1.push_back(34);
	nV1.push_back(35);
	nV1.push_back(37);
	// 调用前nV1: 12, 13, 14, 15, 50, 14, 23, 27, 28, 30, 34, 35, 37
	std::replace(nV1.begin(), nV1.end(), 14, -14);
	// 调用后nV1: 12, 13, -14, 15, 50, -14, 23, 27, 28, 30, 34, 35, 37

	nV1.clear();
	nV1.push_back(12);
	nV1.push_back(13);
	nV1.push_back(14);
	nV1.push_back(15);
	nV1.push_back(50);
	nV1.push_back(14);
	nV1.push_back(23);
	nV1.push_back(27);
	nV1.push_back(28);
	nV1.push_back(30);
	nV1.push_back(34);
	nV1.push_back(35);
	nV1.push_back(37);
	nV2.clear();
	nV2.resize(nV1.size());
	// 调用前nV1: 12, 13, 14, 15, 50, 14, 23, 27, 28, 30, 34, 35, 37
	iter = std::replace_copy(nV1.begin(), nV1.end(), nV2.begin(), 14, -14);
	// 调用前nV1: 12, 13, 14, 15, 50, 14, 23, 27, 28, 30, 34, 35, 37
	// 调用后nV2: 12, 13, -14, 15, 50, -14, 23, 27, 28, 30, 34, 35, 37, end(iter)

	nV1.clear();
	nV1.push_back(12);
	nV1.push_back(13);
	nV1.push_back(-14);
	nV1.push_back(15);
	nV1.push_back(50);
	nV1.push_back(-14);
	nV1.push_back(23);
	nV1.push_back(27);
	nV1.push_back(28);
	nV1.push_back(30);
	nV1.push_back(34);
	nV1.push_back(35);
	nV1.push_back(37);
	// 调用前nV1: 12, 13, -14, 15, 50, -14, 23, 27, 28, 30, 34, 35, 37
	std::replace_if(nV1.begin(), nV1.end(), MyObject1(), 14);
	// 调用后nV1: 12, 13, 14, 15, 50, 14, 23, 27, 28, 30, 34, 35, 37, end(iter)

	return 0;
}

5. swap / swap_ranges 

5.1 swap

交换存储在两个对象中的值
函数原形
template<class T> void swap(T& x, T& y);

5.2 swap_ranges

将指定范围内的元素与另一个序列元素值进行交换
函数原形
template<class FwdIt1, class FwdIt2> FwdIt2 swap_ranges(FwdIt1 first, FwdIt1 last, FwdIt2 x); 
/
#include "stdafx.h"
#include <algorithm>
#include <numeric>
#include <functional>
#include <vector>
#include <iostream>

int _tmain(int argc, _TCHAR* argv[])
{
	std::vector<int> nV2, nV1;
	std::vector<int>::iterator iter;

	int a = 1;
	int b = 2;
	std::swap(a, b);	// 交还a和b的值

	nV1.clear();
	nV1.push_back(12);
	nV1.push_back(13);
	nV1.push_back(50);
	nV1.push_back(14);
	nV1.push_back(15);
	nV2.clear();
	nV2.resize(nV1.size());
	nV2.push_back(26);
	nV2.push_back(18);
	nV2.push_back(27);

	// 调用前nV1: 12, 13, 50, 14, 15
	// 调用前nV2: 0, 0, 0, 0, 0, 26, 18, 27
	std::swap_ranges(nV1.begin(), nV1.end(), nV2.begin());
	// 调用后nV1: 0, 0, 0, 0, 0
	// 调用后nV2: 12, 13, 50, 14, 15, 26, 18, 27

	return 0;
}
说明:
1. swap_ranges中, nV2.size()要大于等于nV1.size()

6. unique / unique_copy (清除序列中重复元素)

6.1 unique

清除序列中连续重复元素。例如: 11, 12, 12, 14 调用后变成 11, 12, 14. 
例如在std::vector中元素被左移.
重载版本使用自定义比较操作
函数原形
template<class FwdIt> FwdIt unique(FwdIt first, FwdIt last);
template<class FwdIt, class Pred> FwdIt unique(FwdIt first, FwdIt last, Pred pr);

6.2 unique_copy

与unique类似，不过把结果输出到另一个容器
函数原形
template<class InIt, class OutIt> OutIt unique_copy(InIt first, InIt last, OutIt x);
template<class InIt, class OutIt, class Pred> OutIt unique_copy(InIt first, InIt last, OutIt x, Pred pr); 
/
#include "stdafx.h"
#include <algorithm>
#include <numeric>
#include <functional>
#include <vector>
#include <iostream>

class MyObject1
{  
public:
	MyObject1(){}
	~MyObject1(){}
	// 括号操作符
    bool operator()(int val1)  
    {  
        return (0 > val1);
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
	std::vector<int> nV2, nV1;
	std::vector<int>::iterator iter;

	nV1.clear();
	nV1.push_back(12);
	nV1.push_back(13);
	nV1.push_back(14);
	nV1.push_back(14);
	nV1.push_back(50);
	nV1.push_back(14);
	nV1.push_back(23);
	nV1.push_back(27);
	nV1.push_back(28);
	nV1.push_back(30);
	nV1.push_back(34);
	nV1.push_back(35);
	nV1.push_back(37);
	// 调用前nV1: 12, 13, 14, 14, 50, 14, 23, 27, 28, 30, 34, 35, 37
	iter = std::unique(nV1.begin(), nV1.end());
	// 调用后nV1: 12, 13, 14, 50, 14, 23, 27, 28, 30, 34, 35, 37, 37(iter)
	// 明显最后面的37是无效的, remove后元素被左移了.

	nV1.clear();
	nV1.push_back(12);
	nV1.push_back(13);
	nV1.push_back(14);
	nV1.push_back(14);
	nV1.push_back(50);
	nV1.push_back(14);
	nV1.push_back(23);
	nV1.push_back(27);
	nV1.push_back(28);
	nV1.push_back(30);
	nV1.push_back(34);
	nV1.push_back(35);
	nV1.push_back(37);
	nV2.resize(nV1.size());
	// 调用前nV1: 12, 13, 14, 14, 50, 14, 23, 27, 28, 30, 34, 35, 37
	iter = std::unique_copy(nV1.begin(), nV1.end(), nV2.begin());
	// 调用前nV1: 12, 13, 14, 14, 50, 14, 23, 27, 28, 30, 34, 35, 37
	// 调用后nV2: 12, 13, 14, 50, 14, 23, 27, 28, 30, 34, 35, 37, 0(iter)

	return 0;
}

小大小丑
关注
专栏目录
STL常用的拷贝和替换算法
希望我的博客，能帮上你解决学习中工作中所遇到的问题
10-26 289
copy() vector vecIntA; vecIntA.push_back(1); vecIntA.push_back(3); vecIntA.push_back(5); vecIntA.push_back(7); vecIntA.push_back(9); vector vecIntB; vecIntB.resize(5); //扩大空间 copy(vecIntA.begin(), vecIntA.end(), vecIntB.begin()); //vecIntB: {1,3,5,7,9} r
C++进阶STL-常用的拷贝和替换算法
zzyczzyc的博客
10-12 345
copy 例子：将v1的第二个元素开始到最后一个元素，拷贝给v2 #include &amp;quot;stdafx.h&amp;quot; #include &amp;amp;lt;iostream&amp;amp;gt; #include &amp;amp;lt;algorithm&amp;amp;gt; #include &amp;amp;lt;vector&amp;amp;gt; using namespace std;
STL中删除和替换算法 （15 个）
The Road Less Traveled
05-21 303
1. copy: 复制字符串 templateclass InputIterator, class OutputIterator> OutputIterator copy ( InputIterator first, InputIterator last, OutputIterator result ) { while (first!=last) *result++ = *firs
STL常用算法（复制、交换、替换、填充、生成、删除、排序、集合操作）
ukston_C的博客
06-19 310
//pioi#include"iostream" using namespace std; #include"vector" #include"string" #include"algorithm" #include"functional" #include"iterator" /*复制*/ //copy和copy_backward void print(int &amp;n) {
算法--数组的增删 替换，插入所有操作
java川
05-26 308
所有关于数组的操作 如添加元素，删除元素，替换指定位置元素的算法思想，共同点是 都需要使用到新的数组， 然后复制元素到新的数组 最后需要用新数组替换旧数组。 替换数组中的指定元素，直接替换就可以。 import java.util.Arrays; import java.util.Scanner; import java.util.ArrayList; public class ObjectAr...
【深度学习基础】反向传播法（2）
『程序员·小李』的博客
06-12 830
深度学习中，各部分的反向传播实现。我们先来看看ReLU函数的特点：函数图像：对应的导数为：这也就说明了，当输入大于0时，梯度的反向传播为原样，否则，反向传播为0 代码实现： SIGMOD的函数：函数图像： 根据导数计算公式，导函数： 对于此导数，可以进一步简化：我们可以得到反向传播的计算图： 代码实现：...
《深度学习入门》5.5.1ReLu层的实现——关于数组的使用问题
goryeon的博客
09-24 2382
书上的代码： class Relu: def __init__(self): self.mask = None#属性mask的类型为NoneType def forward(self, x): self.mask = (x <= 0)#self.mask是一个数组（大于0的为False,小于0的为True） out = x...
c++入门笔记-stl常用算法-拷贝和替换/算数生成/集合
weixin_43754049的博客
07-12 297
算法简介： copy //容器内指定范围的元素拷贝到另一容器中 replace //将容器内指定范围的旧元素修改为新元素 repalce_if //容器内指定范围满足条件的元素替换为新元素 swap //互换两个容器元素copy： 函数原型：copy(iterator beg, iterator end, iterator dest) //按值查找元素 找到返回指定位置迭代器 找不到返回结束迭代器位置
STL-常用算法
m0_65462883的博客
08-19 411
STL-常用算法 算法主要是由头文件 组成 是所有STL头文件中最大的一个，范围涉及到比较、交换、查找、遍历操作、复制、修改等等 体积很小，只包括几个在序列上面进行简单数学运算的模板函数 定义了一些模板类,用以声明函数对象
C++ Day10 STL02-适配器与算法 （本篇笔记16000字，整理不易，拿去赶快干）
最新发布
aisheisadas的博客
11-24 1544
重载函数调用运算符的类实例化的对象就叫函数对象又名仿函数函数对象和()触发重载函数调用运算符的执行。作用为算法提供策略。
使用数组的splice方法实现数组的添加、删除、替换（区分slice方法）
m0_48895748的博客
10-31 3243
使用数组的splice方法实现数组的添加、删除、替换，区分splice方法，关于数组的其他方法在上一篇中有发布
误差反向传播法（二）【神经网络以层的方式实现】
深度学习领域优质创作者，CSDN博客专家
09-26 666
我们来看激活函数层的实现 ReLU层 import numpy as np class Relu: def __init__(self): self.mask=None def forward(self,x): self.mask=(x<=0)#[[False True][ True False]] out=x.copy() out[self.mask]=0#将True设为0 return out def b
copy.copy(x)和copy.deepcopy(x)
卜亚风
11-24 884
浅拷贝和深拷贝之间的区别 仅 与复合对象（包含其他对象的对象，如列表或类实例）相关! 在Python中，对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。 浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复制 深拷贝：外围和内部元素都进行了...
STL算法描述
MyStudy
05-05 944
STL算法部分主要由头文件,,组成。要使用STL中的算法函数必须包含头文件，对于数值算法须包含，中则定义了一些模板类，用来声明函数对象。    STL中算法大致分为四类：        1、非可变序列算法：指不直接修改其所操作的容器内容的算法。        2、可变序列算法：指可以修改它们所操作的容器内容的算法。        3、排序算法：包
深度学习笔记---在计算图思想下实现简单神经网络的各个计算层
weixin_44711653的博客
01-31 959
# 1.导入 在上篇博客中，例子z = (x+y)^2的计算层就是两个节点。 二层神经网络利用计算图的思想可以按照如下简单表示 上图中的黑色框均表示计算层，Affine表示加权和层，ReLU表示ReLU激活函数层，SoftmaxWithLoss表示Softmax激活函数和Loss损失函数的组合层。 # 2.用Python实现各个计算层 1.Affine层的实现 求加权和的过程就...
Copy 方法 和 ostream 迭代器
weixin_33815613的博客
04-12 153
目录 头文件 #include <algorithm> template<class inputIterator, class outputIterator> outputIterator copy(InputIterator beg,InputIterator end, outputIterator beg) 从原型上看主要作用是将一个容...
对象克隆以及clone()方法实现时的深拷贝和浅拷贝
JKSon_66的博客
07-16 2878
版权声明：本文为博主原创文章，未经博主允许不得转载.........
删除算法
qq_35968818的博客
03-22 2103
删除算法即从数据集合中删除指定的数据元素。删除一个数据元素只要包含两步：第一步为查找，即找到要删除的数据元素。第二步为删除，即将其后元素以此前移。数据集合可分为两类：数据集合无重复值和数据集合中含重复值。
C++ STL六大组件-3-Algorithm(算法) 
cyy2learn的博客
08-20 649
C++ STL六大组件-简析 ------------------------------------------ C++ STL六大组件-1-Container(容器) C++ STL六大组件-2-Adapter(适配器) C++ STL六大组件-3-Algorithm(算法) 算法简介 算法分类 非可变序列算法 可变序列算法 排序算法 数值算法 算法细分 查找算法（13个） 排序和通用算法(14个) 删除...
C++ STL 常用算法详解：遍历、查找、排序与更多
4. 常用拷贝和替换算法 - copy: 拷贝一个迭代器范围内的元素到另一个位置。 - replace: 替换所有匹配指定值的元素。 - replace_if: 如果满足条件，则替换元素。 5. 常用算术生成算法 - accumulate: 计算指定区间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值