STL中的常用算法（二）

最新推荐文章于 2024-07-15 22:10:26 发布
最新推荐文章于 2024-07-15 22:10:26 发布
阅读量117 收藏 1
点赞数 1
分类专栏： STL C++ 笔记 文章标签： 算法 c++ 容器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51196603/article/details/121125301
版权
C++ 同时被 3 个专栏收录
12 篇文章 0 订阅
订阅专栏
笔记
12 篇文章 0 订阅
订阅专栏
STL
9 篇文章 0 订阅
订阅专栏

STL中的常用算法：

之前已经基本介绍了一些 C++ STL 中的常用容器，接下来就是 C++ STL 中的常用算法了；

这次主要介绍 C++ STL 中的常用拷贝和替换算法、常用算术生成算法、常用集合算法；

常用拷贝和替换算法：

1.copy() 算法：将容器内指定范围的元素拷贝到另一个容器中；

函数原型：copy(iterator begin,iterator end,iterator dest);

begin 是源容器的起始迭代器，end 是源容器的结束迭代器，dest 是目标容器的起始迭代器；

#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;

void myPrint(int value)
{
	cout << value << " ";
}

void test_1()  //常用拷贝和替换算法 copy() 
{
	int i = 0;
	vector<int> v1;  //源容器 
	
	for(i=0;i<10;i++)
	{
		v1.push_back(i+1);
	}
	
	vector<int> v2;  //目标容器
	
	//目标容器提前分配好内存空间
	v2.resize(v1.size());
	
	//将容器v1里面的元素拷贝到容器v2中 
	copy(v1.begin(),v1.end(),v2.begin());
	
	for_each(v2.begin(),v2.end(),myPrint);
	cout << endl;
}

int main()
{
	test_1();
	
	system("pause");
	return 0;
}

2.replace() 算法：将容器内指定的范围中的旧元素都替换为新元素；

函数原型：replace(iterator begin,iterator end,old_value,new_value);

begin 是起始迭代器，end 是结束迭代器，old_value 是旧元素（要被替换掉的元素），new_value 是新元素；

#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;

class MyPrint
{
public:
	void operator()(int value)
	{
		cout << value << " ";
	}	
};

void test_1()  //常用拷贝和替换算法 replace() 
{
	vector<int> v1;
	
	v1.push_back(10);
	v1.push_back(30);
	v1.push_back(40);
	v1.push_back(20);
	v1.push_back(50);
	v1.push_back(10);
	v1.push_back(30);
	v1.push_back(20);
	v1.push_back(10);
	
	cout << "替换前：" << endl;
	for_each(v1.begin(),v1.end(),MyPrint());
	cout << endl;
	
	//把容器v1中的全部的10替换为0 
	replace(v1.begin(),v1.end(),10,0);
	
	cout << "替换后：" << endl;
	for_each(v1.begin(),v1.end(),MyPrint());
	cout << endl;
}

int main()
{
	test_1();
	
	system("pause");
	return 0;
}

3.replace_if() 算法：根据条件将指定范围的满足条件的元素替换为指定的新元素；

函数原型：replace_if(iterator begin,iterator end,_Pred,new_value);

begin 是起始迭代器，end 是结束迭代器，_Pred是谓词，new_value 是新元素；

#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;

void myPrint(int value)
{
	cout << value << " ";
}

class GreaterThirty
{
public:
	bool operator()(int value)
	{
		if(value>30)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
};

void test_1()  //常用拷贝和替换算法 replace_if() 
{
	vector<int> v1;
	
	v1.push_back(10);
	v1.push_back(40);
	v1.push_back(20);
	v1.push_back(30);
	v1.push_back(50);
	v1.push_back(20);
	v1.push_back(40);
	v1.push_back(50);
	v1.push_back(30);
	
	cout << "替换前：" << endl;
	for_each(v1.begin(),v1.end(),myPrint);
	cout << endl;
	
	//将大于30的元素替换为0 
	replace_if(v1.begin(),v1.end(),GreaterThirty(),0);
	
	cout << "替换后：" << endl;
	for_each(v1.begin(),v1.end(),myPrint);
	cout << endl;
}

int main()
{
	test_1();
	
	system("pause");
	return 0;
}

4.swap() 算法：互换两个容器的元素；

函数原型：swap(container c1,container c2);

c1 是容器一，c2 是容器二，需要注意的是，这里发生互换的两个容器必须是同种类型的；

#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;

class MyPrint
{
public:
	void operator()(int value)
	{
		cout << value << " "; 
	}
};

void test_1()  //常用拷贝和替换算法 swap() 
{
	int i = 0;
	vector<int> v1;  //容器v1
	vector<int> v2;  //容器v2
	
	for(i=0;i<10;i++)
	{
		v1.push_back(i+1);  //1 2 3 4 5 6 7 8 9 10
		v2.push_back(i+101);  //101 102 103 104 105 106 107 108 109 110
	}
	
	cout << "互换前：" << endl;
	for_each(v1.begin(),v1.end(),MyPrint());
	cout << endl;
	for_each(v2.begin(),v2.end(),MyPrint());
	cout << endl;
	
	cout << "——————————————————————" << endl;
	
	//将容器v1和容器v2进行互换
	swap(v1,v2);
	
	cout << "互换后：" << endl;
	for_each(v1.begin(),v1.end(),MyPrint());
	cout << endl;
	for_each(v2.begin(),v2.end(),MyPrint());
	cout << endl;
}

int main()
{
	test_1();
	
	system("pause");
	return 0;
}

常用算术生成算法：算术生成算法属于小型的算法，使用时需要包含它的头文件 #include <numeric>；

1.accumulate() 算法：计算指定范围内的元素的累积总和；

函数原型：accumulate(iterator begin,iterator end,value);

begin 是起始迭代器，end 是结束迭代器，value 是起始累加值，该算法返回该范围内的元素总和；

#include <iostream>
#include <vector>
#include <numeric>
 
using namespace std;

void test_1()  //常用算术生成算法 accumulate() 
{
	int i = 0;
	vector<int> v1;
	
	for(i=0;i<=100;i++)
	{
		v1.push_back(i);  //1~101
	}
	
	//计算容器v1所有元素的总和（起始累加值为0）
	int total_1 = accumulate(v1.begin(),v1.end(),0);  //5050
	
	//计算容器v1所有元素的总和（起始累加值为1000） 
	int total_2 = accumulate(v1.begin(),v1.end(),1000);  //6050 
	
	cout << "容器内所有元素总和为：" << total_1 << endl;
	
	cout << "容器内所有元素总和为：" << total_2 << endl;
}

int main()
{
	test_1();
	
	system("pause");
	return 0;
}

2.fill() 算法：向指定范围内填充指定元素；

函数原型：fill(iterator begin,iterator end,value);

begin 是起始迭代器，end 是结束迭代器，value 是指定的用于填充的元素；

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
 
using namespace std;

void myPrint(int value)
{
	cout << value << " ";
}

void test_1()  //常用算术生成算法 fill() 
{
	vector<int> v1;
	
	//指定容器v1的大小为10，默认会以0进行填充 
	v1.resize(10);
	
	cout << "填充值修改前：" << endl;
	for_each(v1.begin(),v1.end(),myPrint);
	cout << endl;
	
	//后期修改填充值，用10来填充容器v1 
	fill(v1.begin(),v1.end(),10);
	
	cout << "填充值修改后：" << endl;
	for_each(v1.begin(),v1.end(),myPrint);
	cout << endl;
}

int main()
{
	test_1();
	
	system("pause");
	return 0;
}

常用集合算法：

1.set_intersection() 算法：求两个集合的交集；

函数原型：set_intersection(iterator begin_1,iterator end_1,iterator begin_2,iterator end_2,iterator dest);

begin_1 是容器 1 的起始迭代器，end_1 是容器 1 的结束迭代器，begin_2 是容器 2 的起始迭代器，end_2 是容器 2 的结束迭代

器，dest 是目标容器的起始迭代器，该算法会返回交集中最后一个元素的迭代器；

注意：

1.要求交集的两个容器必须为有序序列，且排序规则一致；

2.目标容器需要提前分配好内存空间，否则是无法获得两个集合的交集的；

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
 
using namespace std;

class MyPrint
{
public:
	void operator()(int value)
	{
		cout << value << " ";
	}	
};

void test_1()  //常用集合算法 set_intersection() 
{
	int i = 0;
	vector<int> v1;  //容器v1
	vector<int> v2;  //容器v2
	
    //向容器v1和容器v2有序地插入元素
	for(i=0;i<10;i++)
	{
		v1.push_back(i);  //0 1 2 3 4 5 6 7 8 9
		v2.push_back(i+5);  //5 6 7 8 9 10 11 12 13 14
	}
	
	vector<int> v_Target;  //目标容器
	
	//目标容器需要提前开辟内存空间
	//交集中，元素数量最大的情况就是，大集合包含小集合，此时该交集的大小为小集合的大小，因此我们只要开辟到空间为小集合的大小即可，其他的情况下，开辟的大小均小于该情况
	v_Target.resize(min(v1.size(),v2.size()));
	
	//求容器v1和容器v2的交集
	vector<int>::iterator itEnd =set_intersection(v1.begin(),v1.end(),v2.begin(),v2.end(),v_Target.begin());
	
	//输出：5 6 7 8 9 
	for_each(v_Target.begin(),itEnd,MyPrint());
	cout << endl;
	
	//输出：5 6 7 8 9 0 0 0 0 0 
	for_each(v_Target.begin(),v_Target.end(),MyPrint());
	cout << endl;
}

int main()
{
	test_1();
	
	system("pause");
	return 0;
}

2.set_union() 算法：求两个集合的并集；

函数原型：set_union(iterator begin_1,iterator end_1,iterator begin_2,iterator end_2,iterator dest);

begin_1 是容器 1 的起始迭代器，end_1 是容器 1 的结束迭代器，begin_2 是容器 2 的起始迭代器，end_2 是容器 2 的结束迭代

器，dest 是目标容器的起始迭代器，该算法会返回并集中最后一个元素的迭代器；

注意：

1.要求并集的两个容器必须为有序序列，且排序规则一致；

2.目标容器需要提前分配好内存空间，否则是无法获得两个集合的并集的；

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
 
using namespace std;

void myPrint(int value)
{
	cout << value << " ";
}

void test_1()  //常用集合算法 set_union() 
{
	int i = 0;
	vector<int> v1;  //容器v1
	vector<int> v2;  //容器v2
	
    //向容器v1和容器v2有序地插入元素
	for(i=0;i<10;i++)
	{
		v1.push_back(i);  //0 1 2 3 4 5 6 7 8 9
		v2.push_back(i+5);  //5 6 7 8 9 10 11 12 13 14
	}
	
	vector<int> v_Target;  //目标容器
	
	//目标容器需要提前开辟内存空间
	//并集中，元素数量最大的情况就是，两个集合完全不同，此时该并集的大小为原来两个集合的大小的总和，因此我们只要开辟到空间为两个集合的大小的总和即可，其他的情况下，开辟的大小均小于该情况
	v_Target.resize(v1.size()+v2.size());
	
	//求容器v1和容器v2的并集
	vector<int>::iterator itEnd = set_union(v1.begin(),v1.end(),v2.begin(),v2.end(),v_Target.begin());
	
	//输出：0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 
	for_each(v_Target.begin(),itEnd,myPrint);
	cout << endl;
	
	//输出：0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 0 0 0 0 0
	for_each(v_Target.begin(),v_Target.end(),myPrint);
	cout << endl;
}

int main()
{
	test_1();
	
	system("pause");
	return 0;
}

3.set_difference 算法：求两个集合的差集；

函数原型：set_difference(iterator begin_1,iterator end_1,iterator begin_2,iterator end_2,iterator dest);

begin_1 是容器 1 的起始迭代器，end_1 是容器 1 的结束迭代器，begin_2 是容器 2 的起始迭代器，end_2 是容器 2 的结束迭代

器，dest 是目标容器的起始迭代器，该算法会返回差集中最后一个元素的迭代器；

注意：

1.要求并集的两个容器必须为有序序列，且排序规则一致；

2.目标容器需要提前分配好内存空间，否则是无法获得两个集合的差集的；

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
 
using namespace std;

//常用集合算法 set_difference()

class MyPrint
{
public:
	void operator()(int value)
	{
		cout << value << " ";
	}	
};

void test_1()  //容器v1和容器v2的差集（v1中除去v1和v2的交集的剩下的元素） 
{
	int i = 0;
	vector<int> v1;  //容器v1
	vector<int> v2;  //容器v2
	
    //向容器v1和容器v2有序地插入元素
	for(i=0;i<10;i++)
	{
		v1.push_back(i);  //0 1 2 3 4 5 6 7 8 9
		v2.push_back(i+5);  //5 6 7 8 9 10 11 12 13 14
	}
	
	vector<int> v_Target;  //目标容器
	
	//目标容器需要提前开辟内存空间
	//差集中，最特殊的情况有两种情况（大集合包含小集合或两个集合完全不同），但差集中元素数量最多的情况是，两个集合完全不同的情况 
	//此时差集的大小应该设置为两个集合中较大的那个集合的大小，因此我们只要开辟到空间为较大的集合的大小即可，其他的情况下，开辟的大小均小于特殊的情况
	v_Target.resize(max(v1.size(),v2.size()));
	
	//求容器v1和容器v2的差集
	vector<int>::iterator itEnd = set_difference(v1.begin(),v1.end(),v2.begin(),v2.end(),v_Target.begin());
	
	//输出：0 1 2 3 4 
	for_each(v_Target.begin(),itEnd,MyPrint());
	cout << endl;
	
	//输出：0 1 2 3 4 0 0 0 0 0
	for_each(v_Target.begin(),v_Target.end(),MyPrint());
	cout << endl;
}

void test_2()  //容器v2和容器v1的差集（v2中除去v1和v2的交集的剩下的元素）
{
	int i = 0;
	vector<int> v1;  //容器v1
	vector<int> v2;  //容器v2
	
    //向容器v1和容器v2有序地插入元素
	for(i=0;i<10;i++)
	{
		v1.push_back(i);  //0 1 2 3 4 5 6 7 8 9
		v2.push_back(i+5);  //5 6 7 8 9 10 11 12 13 14
	}
	
	vector<int> v_Target;  //目标容器
	
	//目标容器需要提前开辟内存空间
	//差集中，最特殊的情况有两种情况（大集合包含小集合或两个集合完全不同），但差集中元素数量最多的情况是，两个集合完全不同的情况 
	//此时差集的大小应该设置为两个集合中较大的那个集合的大小，因此我们只要开辟到空间为较大的集合的大小即可，其他的情况下，开辟的大小均小于特殊的情况
	v_Target.resize(max(v1.size(),v2.size()));
	
	//求容器v1和容器v2的差集
	vector<int>::iterator itEnd = set_difference(v2.begin(),v2.end(),v1.begin(),v1.end(),v_Target.begin());
	
	//输出：10 11 12 13 14 
	for_each(v_Target.begin(),itEnd,MyPrint());
	cout << endl;
	
	//输出：10 11 12 13 14 0 0 0 0 0
	for_each(v_Target.begin(),v_Target.end(),MyPrint());
	cout << endl;
}

int main()
{
	test_1();
	test_2();
	
	system("pause");
	return 0;
}

STL 常用算法篇幅较长，我总共将其分为了两个部分，大致介绍了一些常用的遍历算法、查找算法、排序算法、拷贝和替换算法、算术生成算法、集合算法，希望对大家有帮助，共勉！

笔记中有错误的地方，欢迎指出，欢迎大家讨论！

Yauge丶
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL 简单 copy 算法的实现
chengonghao的博客
06-06 2453
1.简介          不论是对客户端或对STL内部而言，copy() 都是一个常常被调用的函数。由于copy进行的是复制操作，而复制操作不外乎运用赋值运算符（assignment operator）或复制构造函数（copy constructor），但是某些元素的类型是trivial assignment operator，因此如果能使用内存直接进行复制（例如使用C标准函数memmove、
浅析STL中的常用算法
09-05
在这个话题中，我们将深入探讨STL中的常用算法，这些算法通常用于处理和操作容器中的数据。 首先，我们讨论非变异算法，即那些不会改变原有数据结构的算法。这类算法主要涉及对序列数据的操作，如查找、统计和匹配...
STL源码剖析——copy函数
Johnsonjjj的博客
08-02 1177
前言 最近在看《STL 源码剖析》，恰好看到copy函数这里。书上写的这个函数比较复杂，因为涉及到比较多提高效率的方法。因此我这篇博客就当做个简单的记录吧。 copy函数的原型如下： template<class InputIterator, class OutputIterator> inline OutputIterator copy( InputIterator first, InputIterator last, OutputIte
STL算法之copy
系统 运维
04-15 179
STL算法之copy copy 使用必须包含头文件&lt;algorithm&gt; 由于copy进行的是复制操作，而复制操作不外乎assignment operator和copy constructor(copy算法用的是前者)，但是某些元素型别用于的是trivial assginment operator，因此，如果能够使用内存直接复制行为(例如C标准函数memmove或memcpy)，...
STL_算法（16）_复制元素 copy() copy_backward()
taotaoahui
08-16 612
copy() copy_backward() 以上两个对所有容器都适用的 注意: 1, 没有copy_if()算法，可以使用remove_copy_if()算法； 2，复制过程中要逆转元素次序，使用reverse_copy()算法； 3，把容器内所有元素赋值给另一个容器，要使用赋值操作符或者容器的assign()成员函数； 4，复制过程中删除某些元素，使用remove_copy()和
STL中copy算法
w512的专栏
11-17 2519
STL中通过使用copy函数以提供一种方便的方式来输出容器中的元素。函数copy作为泛型算法的一部分，任何容器类型都可以使用。由于我们需要频繁的初始容器的元素，因此在继续讨论容器之前，先学习一下copy函数的用法。 copy函数不只是输出容器的元素。通常，它允许我们复制元素从一个地方到另一个地方。例如输出vector的元素或复制vector的元素到另一个vector，我们可以使用copy
STL常用算法
qq_24472227的博客
06-06 1136
1、常用遍历算法 2、常用查找算法 3、常用排序算法 4、常用拷贝和替换算法 5、常用算术生成算法 6、常用集合算法
C++中STL常用算法
兰天禄的博客
04-02 861
STL的常用算法1、常用的遍历算法1、for_each:遍历容器元素2、transform算法 将指定容器区间元素搬运到另一容器中2、常用的查找算法2.1、find算法 查找元素2、find_if条件查找2.3、adjacent_find算法 查找相邻重复元素2.4、binary_search算法 二分查找法（容器必须有序）2.5、count算法 统计元素出现次数2.6、count_if算法 统计...
STL常用算法——遍历算法
万里顾一程的博客
10-28 437
ransform() 可以将函数应用到容器的元素上，并将这个函数返回的值保存到另一个容器中，它返回的迭代器指向输出容器所保存的最后一个元素的下一个位置。for_each：遍历容器，对容器中的每一个元素调用函数或函数对象。
STL【算法】| 常用算法大集合
weixin_45926547的博客
03-08 1702
文章目录一、简介1.1 类别1.1.1 _if结尾1.1.2 _copy尾词1.1.3 算法类别二、非变动性算法2.1 简介2.2 常见算法2.2.1 元素计数2.2.2 最大值和最小值2.2.3 搜寻元素三、变动性算法3.1 简介3.2 常用3.3 移除性算法四、变序性算法五、排序算法六、已序区间算法七、数值算法 一、简介 STL算法都被设计用来处理一个或多个迭代器区间；多数情况下只需提供起点即可； STL算法采用覆盖模式而非安插模式； 1.1 类别 1.1.1 _if结尾 当此类算法有两种形式
c++模板stl常用算法
09-01
stl常用算法，模板stl常用算法，
STL常用算法大全
12-02
STL 常用算法大全 STL（Standard Template Library）提供了丰富的算法库，涵盖了查找、排序、数值计算等多方面的算法。这些算法可以帮助开发者快速、高效地处理数据。 查找算法（13 个） 1. `adjacent_find`：在...
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 226
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 459
算法014：找到字符串中所有字母异位词
代码随想录算法训练营第三十二天
weixin_44791877的博客
07-14 246
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
树与二叉树
最新发布
2201_76027754的博客
07-15 787
树和二叉树
摩尔投票算法
qq_55846232的博客
07-14 483
摩尔投票算法的介绍以及相关例题的讲解
手撕七大排序(三)
Zbldx的博客
07-14 324
手撕七大排序 （三）
C++函数模板与类模板详解：STL常用算法实现
- 逻辑抽象：类模板使程序员能够将算法从数据类型的具体实现中抽离出来，专注于逻辑结构，提高代码的可重用性和模块化。 - 举例： ```cpp template class ArraySorter { public: void sortArray(T* array, ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值