C++中STL的常用算法总结
目录
- 1.常用遍历算法
- 1.1 for_each
- 1.2 transform
- 2.常用查找算法
- 2.1 find
- 2.2 find_if
- 2.3 adjacent_find
- 2.4 binary_search
- 2.5 count
- 2.6 count_if
- 3.常用排序算法
- 3.1 sort
- 3.2 random_shuffe
- 3.3 merge
- 3.4 reverse
- 4.常用拷贝和替换算法
- 4.1 copy
- 4.2 replace
- 4.3 replace_if
- 4.4 swap
- 5.常用算术生成算法
- 5.1 accumulate
- 5.2 fill
- 6.常用集合算法
- 6.1 set_intersection
- 6.2 set_union
- 6.3 set_difference
算法主要由头文件<algorithm><functional><numeric>组成。
<algorithm>是所有STL头文件中最大的一个，范围包括比较、交换、查找、遍历、复制、修改等。
<functional>定义了一些模版类，常用的仿函数等。
<numeric>体积很小，只包括几个在序列上面进行简单数学运算的模版函数。
1.常用遍历算法
1.1 for_each
能力：
遍历容器的算法
函数原型：
for_each(iterator begin, iterator end, _func);
- begin: 开始迭代器
- end: 结束迭代器
- _func: 函数或函数对象（即仿函数）
上面_func参数写法:
如果是普通函数：就写 函数名
如果是仿函数：需要写 类名()
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
using namespace std;
void print1(int val) {
cout << val << " ";
}
class print2 {
public:
void operator()(int val) {
cout << val << " ";
}
};
void test() {
vector<int> v;
for (int i = 0; i < 10; i++) {
v.push_back(i);
}
// 利用普通和函数 print1
for_each(v.begin(), v.end(), print1);
cout << endl;
// 利用仿函数 print2()
for_each(v.begin(), v.end(), print2());
}
int main() {
test();
system("pause");
return 0;
}
1.2 transform
能力：
搬运容器到另一个容器中
函数原型：
transform(iterator begin1, iterator end1, iterator begin2, _func);
- begin1：源容器开始迭代器
- end1： 源容器结束迭代器
- begin2： 目标容器开始迭代器
- _func： 普通函数或仿函数
注意：
在使用transform搬运容器之前，必须要给目标容器提前开辟空间，不然会报错。通常用 resize()
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
using namespace std;
class Transform {
public:
int operator()(int val) {
return val + 100;
}
};
class MyPrint{
public:
void operator()(int val) {
cout << val << " ";
}
};
void test() {
vector<int> v;
for (int i = 0; i < 5; i++) {
v.push_back(i);
}
vector<int> v2;//目标容器
v2.resize(v.size());// 必须要给目标容器提前开辟空间，开辟搬运容器空间的大小即可。
transform(v.begin(), v.end(), v2.begin(), Transform());
for_each(v2.begin(), v2.end(), MyPrint());
cout << endl;
}
int main() {
test();
system("pause");
return 0;
}
2.常用查找算法
主要包含：
- find 查找元素
- find_if 按条件查找元素
- adjacent_find 查找相邻重复元素
- binary_search 二分查找法
- count 统计元素个数
- count_if 按条件统计元素个数
2.1 find
能力：
查找指定元素，若找到，返回指定元素迭代器；若未找到，返回结束迭代器end().
函数原型：
find(iterator begin, iterator end, value);
- begin： 开始迭代器
- end： 结束迭代器
- value： 要查找的元素
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
using namespace std;
// 常用算法 find
// find查找内置数据类型
void test() {
vector<int> v;
for (int i = 0; i < 5; i++) {
v.push_back(i);
}
vector<int>::iterator pos = find(v.begin(), v.end(), 2);
if (pos != v.end()) {
cout << "find " << *pos << endl;
}
else {
cout << "not find 2" << endl;
}
pos = find(v.begin(), v.end(), 10);
if (pos != v.end()) {
cout << "find " << *pos << endl;
}
else {
cout << "not find 10" << endl;
}
}
// 查找自定义数据类型
class Person {
public:
Person(string name, int age) {
this->m_name = name;
this->m_age = age;
}
// 需要重载==,才能判断查找的值
bool operator==(const Person& p) {
if (this->m_name == p.m_name && this->m_age == p.m_age) {
return true;
}
else {
return false;
}
}
string m_name;
int m_age;
};
void test2() {
vector<Person> v;
v.push_back(Person("echo", 20));
v.push_back(Person("tom", 19));
v.push_back(Person("lucy", 18));
Person p("tom", 19);
vector<Person>::iterator pos = find(v.begin(), v.end(), p);
if (pos !=v.end()) {
cout << " find p name = "<<( * pos).m_name
<<" age = "<<pos->m_age
<< endl;
}
else {
cout << "not find p" << endl;
}
}
int main() {
test2();
system("pause");
return 0;
}
2.2 find_if
能力：
按条件查找元素。
按值查找元素，若找到，返回指定元素迭代器，若未找到，返回结束迭代器。
函数原型：
find_if(iterator begin, iterator end, _pred);
- begin： 开始迭代器
- end： 结束迭代器
- _pred： 普通函数或仿函数（需要是返回bool类型的函数）
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
// find_if
using namespace std;
// 查找内置数据类型
bool GreaterFive(int a) {
return a > 5;
}
void test() {
vector<int> v;
for (int i = 0; i < 10; i++) {
v.push_back(i);
}
vector<int>::iterator pos=find_if(v.begin(), v.end(), GreaterFive);
if (pos != v.end()) {
cout << "找到大于5的元素：" << *pos << endl;
}
else {
cout << "未找到" << endl;
}
}
//自定义数据类型
class Person {
public:
Person(string name, int age) {
this->m_name = name;
this->m_age = age;
}
string m_name;
int m_age;
};
// 仿函数
class GreaterAge18 {
public:
bool operator()(const Person& p) {
// 年龄大于18岁
return p.m_age > 18;
}
};
void test2() {
vector<Person> v;
v.push_back(Person("tom", 18));
v.push_back(Person("echo", 20));
v.push_back(Person("lucy", 19));
vector<Person>::iterator pos = find_if(v.begin(), v.end(), GreaterAge18());
if (pos != v.end()) {
cout << "找到年龄大于18的人。姓名：" << pos->m_name
<< " 年龄：" << pos->m_age << endl;
}
else {
cout << "未找到" << endl;
}
}
int main() {
// test();
test2();
system("pause");
return 0;
}
2.3 adjacent_find
能力：
查找相邻重复元素，若存在，返回指定位置迭代器，若不存在，返回迭代器end()。
函数原型：
adjacent_find(iterator begin, iterator end);
- begin： 开始迭代器
- end： 结束迭代器
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
using namespace std;
// 查找相邻重复元素 adjacent_find
void test() {
vector<int> v;
v.push_back(0);
v.push_back(1);
v.push_back(0);
v.push_back(3);
v.push_back(4);
v.push_back(3);
v.push_back(3);
vector<int>::iterator pos = adjacent_find(v.begin(), v.end());
if (pos != v.end()) {
cout << "查找到相邻元素重复：" << *pos << endl;
}
else {
cout << "未找到相邻重复元素" << endl;
}
}
int main() {
test();
system("pause");
return 0;
}
2.4 binary_search
能力：
查找指定元素是否存在。若存在，返回true。若不存在，返回false。
注意：
只能在有序序列才可用。
函数原型：
bool binary_search(iterator begin, iterator end, value);
- begin： 开始迭代器
- end： 结束迭代器
- value： 要查找的元素
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
using namespace std;
// binary_search 查找元素是否存在
void test() {
vector<int> v;
v.push_back(1);
v.push_back(3);
v.push_back(2);
v.push_back(5);
v.push_back(4);
// 只有在有序序列中才是准确的，如果没有sort排序测试出 未找到
sort(v.begin(), v.end());
bool ret = binary_search(v.begin(), v.end(), 3);
if (ret) {
cout << "找到元素" << endl;
}
else {
cout << "未找到元素" << endl;
}
}
int main() {
test();
system("pause");
return 0;
}
2.5 count
能力：
统计元素个数
函数原型：
count(iterator begin, iterator end, value);
- begin： 开始迭代器
- end： 结束迭代器
- value： 要统计的元素
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
using namespace std;
// count 统计
// 内置数据类型
void test() {
vector<int> v;
v.push_back(1);
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(1);
int n=count(v.begin(), v.end(), 1);
cout << "容器中1的个数为：" << n << endl;
}
// 自定义数据类型
class Person {
public:
Person(string name, int age) {
this->m_name = name;
this->m_age = age;
}
bool operator==(const Person& p) {
if ( this->m_name == p.m_name && this->m_age == p.m_age) {
return true;
}
else {
return false;
}
}
string m_name;
int m_age;
};
void test2() {
vector<Person> v;
v.push_back(Person("test1", 10));
v.push_back(Person("test2", 20));
v.push_back(Person("test1", 30));
v.push_back(Person("test1", 10));
Person p("test1", 10);
int n = count(v.begin(), v.end(), p);
cout << "name = test1, age = 10 的元素个数为：" << n << endl;
}
int main() {
//test();
test2();
system("pause");
return 0;
}
2.6 count_if
能力：
按条件统计元素个数。
函数原型：
count_if(iterator begin, iterator end, _pred);
- begin： 开始迭代器
- end： 结束迭代器
- _pred： 谓词
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
using namespace std;
// count 统计
// 内置数据类型
class Greater3 {
public:
bool operator()(int val) {
return val > 3;
}
};
void test() {
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
int n = count_if(v.begin(), v.end(), Greater3());
cout << "容器中大于3个数为：" << n << endl;
}
// 自定义数据类型
class Person {
public:
Person(string name, int age) {
this->m_name = name;
this->m_age = age;
}
string m_name;
int m_age;
};
class GreaterAge20 {
public:
bool operator()(const Person& p) {
// 年龄大于20
return p.m_age > 20;
}
};
void test2() {
vector<Person> v;
v.push_back(Person("test1", 10));
v.push_back(Person("test2", 20));
v.push_back(Person("test3", 30));
v.push_back(Person("test4", 50));
v.push_back(Person("test5", 40));
Person p("test1", 10);
int n = count_if(v.begin(), v.end(), GreaterAge20());
cout << "年龄大于20的元素个数为：" << n << endl;
}
int main() {
//test();
test2();
system("pause");
return 0;
}
3.常用排序算法
3.1 sort
能力：
对容器内元素排序
函数原型：
sort(iterator begin, iterator end, _pred);
- begin： 开始迭代器
- end： 结束迭代器
- _pred：谓词
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
using namespace std;
void print(int val) {
cout << val << " ";
}
void test() {
vector<int> v;
v.push_back(1);
v.push_back(5);
v.push_back(4);
v.push_back(2);
v.push_back(3);
// 利用sort 默认升序
sort(v.begin(), v.end());
for_each(v.begin(), v.end(), print);
cout << endl;
// 改为降序
sort(v.begin(), v.end(), greater<int>());
for_each(v.begin(), v.end(), print);
}
int main() {
test();
system("pause");
return 0;
}
3.2 random_shuffe
能力：
也叫洗牌。将指定范围内的元素随机打乱次序。
函数原型：
random_shuffle(iterator begin, iterator end);//也叫洗牌。将指定范围内的元素随机打乱次序。
begin： 开始迭代器
end： 结束迭代器
注意：
使用时，需要加随机数种子，才能真实的随机起来，每次不一样。
#include<ctime> srand((unsigned int)time(NULL));
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
#include<ctime>
using namespace std;
// random_shuffle 洗牌 将制定范围内元素打乱次序
void print(int val) {
cout << val << " ";
}
void test() {
// 随机数种子，让random_shuffle真实的随机起来
srand((unsigned int)time(NULL));
vector<int> v;
for (int i = 0; i < 10; i++) {
v.push_back(i);
}
for_each(v.begin(), v.end(), print);
cout << endl;
// 洗牌打乱顺序
random_shuffle(v.begin(), v.end());
for_each(v.begin(), v.end(), print);
}
int main() {
test();
system("pause");
return 0;
}
输出：
0 1 2 3 4 5 6 7 8 9
8 1 9 2 0 5 7 3 4 6
3.3 merge
能力：
两个有序容器元素合并，并存储到目标容器中。
注意：
两个容器必须是有序的，才能合并。
两个容器的排序必须是一致的，都是升序或降序。
需要先给目标容器开辟空间。
函数原型：
merge(iterator begin1, iterator end1, iterator begin2, iterator end2, iterator target_begin);
- begin1： 容器1开始迭代器
- end1： 容器1结束迭代器
- begin2：容器2开始迭代器
- end2：容器2结束迭代器
- target_begin：目标容器开始迭代器
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
using namespace std;
// merge 将两个有序容器元素合并到一个目标容器中
void print(int val) {
cout << val << " ";
}
void test() {
vector<int> v1;
vector<int> v2;
// 两个容器需要是有序，且排序一致，都是升序或降序
for (int i = 0; i < 10; i++) {
v1.push_back(i);
v2.push_back(100 + i);
// v2.push_back(100 - i); // 程序会崩溃
}
vector<int> v3;
// 需要提前给目标容器分配空间
v3.resize(v1.size() + v2.size());
merge(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin());
for_each(v3.begin(), v3.end(), print);
}
int main() {
test();
system("pause");
return 0;
}
3.4 reverse
能力：
将容器元素进行反转。
函数原型：
reverse(iterator begin, iterator end);
- begin： 容器1开始迭代器
- end： 容器1结束迭代器
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
using namespace std;
// reverse 将容器元素反转
// 将string内容反转
void test() {
string a = "abcdefg";
reverse(a.begin(), a.end());
cout << a << endl;
}
// vector容器元素反转
void print(int val) {
cout << val << " ";
}
void test2() {
vector<int>v;
for (int i = 0; i < 10; i++) {
v.push_back(i);
}
reverse(v.begin(), v.end());
for_each(v.begin(), v.end(), print);
}
int main() {
test();
test2();
system("pause");
return 0;
}
4.常用拷贝和替换算法
4.1 copy
能力：
将容器内指定范围内的元素拷贝到目标容器。
注意：
使用copy前需要提前给目标容器开辟空间。
函数原型：
copy(iterator begin, iterator end, iterator target_begin);
- begin：容器开始迭代器
- end：容器结束迭代器
- target_begin：目标容器开始迭代器
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
using namespace std;
// copy 将容器内指定范围内元素拷贝到目标容器
void print(int val) {
cout << val << " ";
}
void test() {
vector<int> v;
for (int i = 0; i < 10; i++) {
v.push_back(i);
}
vector<int> tv;
// 使用copy前需要提前给目标容器开辟空间
tv.resize(v.size());
copy(v.begin(), v.end(), tv.begin());
for_each(tv.begin(), tv.end(), print);
}
int main() {
test();
system("pause");
return 0;
}
4.2 replace
能力：
将容器指定范围的旧元素替换为新元素
函数原型：
replace(iterator begin, iterator end, oldvalue, newvalue);
- begin： 开始迭代器
- end： 结束迭代器
- oldvalue： 旧元素
- newvalue： 新元素
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
using namespace std;
// replace 将容器内旧元素替换为新元素
void print(int val) {
cout << val << " ";
}
void test() {
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(1);
v.push_back(1);
v.push_back(3);
replace(v.begin(), v.end(), 1, 10);
for_each(v.begin(), v.end(), print);
}
int main() {
test();
system("pause");
return 0;
}
4.3 replace_if
能力：
将容器区间内满足条件的元素，替换成新元素
函数原型：
replace_if(iterator begin, iterator end, _pred, newvalue);
- begin： 开始迭代器
- end： 结束迭代器
- _pred： 谓词
- newvalue： 新元素
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
using namespace std;
// replace_if 将容器区间内满足条件的元素，替换成新元素
bool greater3less9(int val) {
// 大于三且小于9
return val > 3 && val < 9;
}
void print(int val) {
cout << val << " ";
}
void test() {
vector<int>v;
for (int i = 0; i < 10; i++) {
v.push_back(i);
}
for_each(v.begin(), v.end(), print);
cout << endl;
// 将大于3且小于9的元素替换成100
replace_if(v.begin(), v.end(), greater3less9,100);
for_each(v.begin(), v.end(), print);
}
int main() {
test();
system("pause");
return 0;
}
4.4 swap
能力：
互换两个容器的元素
注意：
交互的两个容器是同种类型
函数原型：
swap(container c1, container c2);
- c1： 容器1
- c2： 容器2
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
using namespace std;
// swap 互换两个容器的元素
void print(int val) {
cout << val << " ";
}
void test() {
vector<int>v1;
vector<int>v2;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
v2.push_back(100 + i);
}
for_each(v1.begin(), v1.end(), print);
cout << endl;
for_each(v2.begin(), v2.end(), print);
cout << endl;
swap(v1, v2);
cout <<"交换容器后：" << endl;
for_each(v1.begin(), v1.end(), print);
cout << endl;
for_each(v2.begin(), v2.end(), print);
cout << endl;
}
int main() {
test();
system("pause");
return 0;
}
5.常用算术生成算法
5.1 accumulate
能力：
计算容器区间内元素之和
函数原型：
accumlate(iterator begin, iterator end, value);
- begin： 开始迭代器
- end： 结束迭代器
- value： 起始值
示例：
#include <iostream>
#include <string>
#include<vector>
#include<numeric>
using namespace std;
//accumulate 计算容器区间内元素之和
void test() {
vector<int>v;
for (int i = 0; i < 10; i++) {
v.push_back(i);
}
vector<int>::iterator beg = v.begin();
vector<int>::iterator end = v.begin()+5;
// 计算前4个元素之和
int ret=accumulate(beg,end, 0);
cout << ret << endl;
}
int main() {
test();
system("pause");
return 0;
}
5.2 fill
能力：
向容器指定范围区间，填充指定的元素
注意：
填充的元素数据类型，与容器中元素的数据类型要保持一致。
函数原型：
fill(iterator begin, iterator end, value);
- begin： 开始迭代器
- end： 结束迭代
- value： 填充的值
示例：
#include <iostream>
#include <string>
#include<vector>
#include<numeric>
#include<algorithm>
using namespace std;
// fill 向容器中指定范围区间，填充指定元素
void print(int val) {
cout << val << " ";
}
void test() {
vector<int>v;
v.resize(10);
vector<int>::iterator beg = v.begin();
vector<int>::iterator end = v.begin() + 5;
fill(beg, end, 1000);
for_each(v.begin(), v.end(), print);
cout << endl;
}
int main() {
test();
system("pause");
return 0;
}
6.常用集合算法
集合的概念：
交集：包含两个集合相同的元素
并集：包含两个集合全部元素
差集：一个集合去掉也存在另一个集合中的元素，剩下来的元素。
注意，本章节三个求集合算法使用时：
求集合的两个容器，都必须是有序序列，且排序规则一致。
目标容器需要提前开辟空间。
6.1 set_intersection
能力：
求两个容器的交集
注意：
两个容器必须是有序序列，且排序规则一致；
要先开辟目标容器空间，可以取目标容器中中较小的空间。（最特殊情况，大容器包含小容器元素，目标容器空间元素个数等于小容器元素个数）
函数原型：
vector<int>::iterator taget_end= set_intersection(iteraor begin1, iterator end1, iterator begin2, iterator end2, iterator taget_begin);
- taget_end：返回目标容器的最后一个元素的迭代器地址
- begin1： 容器1开始迭代器
- end1： 容器1结束迭代器
- begin2：容器2开始迭代器
- end2：容器2结束迭代器
- target_begin：目标容器开始迭代器
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
//#include<numeric>
using namespace std;
//set_intersection 求容器交集
void print(int val) {
cout << val << " ";
}
void test() {
vector<int> v1;
vector<int>v2;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
v2.push_back(i + 5);
}
for_each(v1.begin(), v1.end(), print);
cout << endl;
for_each(v2.begin(), v2.end(), print);
cout << endl;
vector<int> vt;
// 求交集 要先开辟目标容器空间
// 可以取目标容器中中较小的空间
vt.resize(min(v1.size(),v2.size()));
// 返回目标容器的最后一个元素的迭代器地址
vector<int>::iterator itEnd = set_intersection(v1.begin(), v1.end(),
v2.begin(), v2.end(), vt.begin());
cout << "交集：" << endl;
for_each(vt.begin(), itEnd, print);
}
int main() {
test();
system("pause");
return 0;
}
输出：
0 1 2 3 4 5 6 7 8 9
5 6 7 8 9 10 11 12 13 14
交集：
5 6 7 8 9
6.2 set_union
能力：
求两个容器的并集
注意：
两个容器必须是有序序列，且排序规则一致；
目标容器需要先开辟空间，要等于两个容器空间之和。（最特殊情况，两个容器没有交集，并集元素个数等于两个容器元素个数之和）
函数原型：
vector<int>::iterator taget_end= set_union(iteraor begin1, iterator end1, iterator begin2, iterator end2, iterator taget_begin);
- taget_end：返回目标容器的最后一个元素的迭代器地址
- begin1： 容器1开始迭代器
- end1： 容器1结束迭代器
- begin2：容器2开始迭代器
- end2：容器2结束迭代器
- target_begin：目标容器开始迭代器
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
using namespace std;
//set_union 求容器并集
void print(int val) {
cout << val << " ";
}
void test() {
vector<int> v1;
vector<int>v2;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
v2.push_back(i + 5);
}
for_each(v1.begin(), v1.end(), print);
cout << endl;
for_each(v2.begin(), v2.end(), print);
cout << endl;
vector<int> vt;
// 求并集 需要先开辟目标容器空间
// 可以取两个容器空间之和
vt.resize(v1.size() + v2.size());
// 返回目标容器的最后一个元素的迭代器地址
vector<int>::iterator itEnd = set_union(v1.begin(), v1.end(),
v2.begin(), v2.end(), vt.begin());
cout << "并集：" << endl;
for_each(vt.begin(), itEnd, print);
cout << endl;
}
int main() {
test();
system("pause");
return 0;
}
输出：
0 1 2 3 4 5 6 7 8 9
5 6 7 8 9 10 11 12 13 14
并集：
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
6.3 set_difference
能力：
求两个容器的差集
注意：
两个容器必须是有序序列，且排序规则一致；
目标容器需要先开辟空间，要等于第一个容器空间。（最特殊的情况就是两个容器没有交集，差集的元素个数与第一个容器元素一样）
函数原型：
vector<int>::iterator taget_end= set_difference(iteraor begin1, iterator end1, iterator begin2, iterator end2, iterator taget_begin);
- taget_end：返回目标容器的最后一个元素的迭代器地址
- begin1： 容器1开始迭代器
- end1： 容器1结束迭代器
- begin2：容器2开始迭代器
- end2：容器2结束迭代器
- target_begin：目标容器开始迭代器
示例：
#include <iostream>
#include <string>
#include<vector>
#include<algorithm>
//#include<numeric>
using namespace std;
//set_difference 求容器差集
void print(int val) {
cout << val << " ";
}
void test() {
vector<int> v1;
vector<int>v2;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
v2.push_back(i+5);
}
for_each(v1.begin(), v1.end(), print);
cout << endl;
for_each(v2.begin(), v2.end(), print);
cout << endl;
// 求v1和v2的差集
vector<int> vt1;
// 求差集需要先给目标容器开辟空间
// 最特殊的情况，两个容器没有差集，空间可以设定为第一个容器的大小
vt1.resize(v1.size());
// 返回目标容器的最后一个元素的迭代器地址
vector<int>::iterator itEnd = set_difference(v1.begin(),v1.end(),
v2.begin(),v2.end(),vt1.begin());
cout << "v1和v2的差集：" << endl;
for_each(vt1.begin(), itEnd, print);
cout << endl;
// 求v2和v1的差集：
vector<int> vt2;
// 求差集需要先给目标容器开辟空间
// 最特殊的情况，两个容器没有差集，空间可以设定为第一个容器的大小
vt2.resize(v2.size());
// 返回目标容器的最后一个元素的迭代器地址
vector<int>::iterator itEnd2 = set_difference(v2.begin(), v2.end(),
v1.begin(), v1.end(), vt2.begin());
cout << "v2和v1的差集：" << endl;
for_each(vt2.begin(), itEnd2, print);
cout << endl;
}
int main() {
test();
system("pause");
return 0;
}
输出：
0 1 2 3 4 5 6 7 8 9
5 6 7 8 9 10 11 12 13 14
v1和v2的差集：
0 1 2 3 4
v2和v1的差集：
10 11 12 13 14
以上就是C++中STL的常用算法总结的详细内容，更多关于C++ STL常用算法的资料请关注我们其它相关文章！
相关推荐
-
C++ STL中五个常用算法使用教程及实例讲解
目录 前言 sort()排序 常用遍历算法for_each() 常用遍历算法 搬运transform() 查找算法find 删除操作erase() 实例应用 前言 在C++中使用STL算法都要包含一个算法头文件 #include<algorithm> 这样我们才能使用这个STL算法函数 sort()排序 Sort函数包含在头文件为#include<algorithm>的c++标准库中,是一个专门用来排序的高效的函数,我们在解决问题时可以方便快捷的排列顺序. sort()函数中有三个
-
C++ STL中常见的算法使用方式
目录 什么是STL? 0. < algorithm> 是什么: 1. Non-modifying sequence operations: 1.1 find:(Find value in range) 1.2 count:(Count appearances of value in range) 1.3 equal:(Test whether the elements in two ranges are equal) 1.4 search:(Search range for subsequen
-
C++ STL 中的数值算法示例讲解
目录 1.iota 2.accumulate 3.partial_sum 4.adjacent_difference 5.inner_product 以下算法均包含在头文件 numeric 中 1.iota 该函数可以把一个范围内的序列从给定的初始值开始累加先看用法.例:假设我需要一个长度为10,从5开始递增的序列 vector<int> a(10); iota(begin(a), end(a), 5); for (auto x : a) { cout << x <<
-
c++ STL常用遍历算法
需要引入头文件#include<algorithm> 1.for_each #include<iostream> using namespace std; #include <vector> #include <algorithm> class MyPrint { public: void operator()(int val) const{ cout << val << " "; } }; void printV
-
C++中STL的常用算法总结
目录 1.常用遍历算法 1.1 for_each 1.2 transform 2.常用查找算法 2.1 find 2.2 find_if 2.3 adjacent_find 2.4 binary_search 2.5 count 2.6 count_if 3.常用排序算法 3.1 sort 3.2 random_shuffe 3.3 merge 3.4 reverse 4.常用拷贝和替换算法 4.1 copy 4.2 replace 4.3 replace_if 4.4 swap 5.常用算术生
-
javascript中数组的常用算法深入分析
前言 Array是Javascript构成的一个重要的部分,它可以用来存储字符串.对象.函数.Number,它是非常强大的.因此深入了解Array是前端必修的功课.本文将给大家详细介绍了javascript中数组的常用算法,下面话不多说了,来一起看看详细的介绍吧 一.不改变原数组,返回新数组(字符串) 1.concat() 连接两个或者多个数组,两边的原始数组都不会变化,返回的是被连接数组的一个副本. 2.join() 把数组中所有的元素放入到一个字符串中,返回字符串 var a = [1
-
计算机科学中32个常用的基础算法
奥地利符号计算研究所(Research Institute for Symbolic Computation,简称RISC)的Christoph Koutschan博士在自己的页面上发布了一篇文章,提到他做的一个调查,参与者大多数是计算机科学家,他请这些科学家投票选出最重要的算法,以下是这次调查的结果,按照英文名称字母顺序排序: 1.A* 搜索算法--图形搜索算法,从给定起点到给定终点计算出路径.其中使用了一种启发式的估算,为每个节点估算通过该节点的最佳路径,并以之为各个地点排定次序.算法以得到
-
stl常用算法(Algorithms)介绍(stl排序算法、非变序型队列)
算法:用来处理群集内的元素.它们可以出于不同的目的而搜寻,排序,修改,使用那些元素.是一种应用在容器上以各种方法处理其内存的行为或功能,如sort(排序),copy(拷贝)- 算法由模板函数体现,这些函数不是容器类的成员函数,是独立的函数,它们可以用于STL容器,也可以用于普通的C++数组等. 头文件:#include<algorithm> 在STL的泛型算法中有4类基本的算法: 1)变序型队列算法: 可以改变容器内的数据: 2)非变序型队列算法:处理容器内的数据而不改变他们: 3)排序值算法
-
c++中的string常用函数用法总结
标准c++中string类函数介绍 注意不是CString之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必 担心内存是否足够.字符串长度等等,而且作为一个类出现,他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要.我们可以用 = 进行赋值操作,== 进行比较,+ 做串联(是不是很简单?).我们尽可以把它看成是C++的基本数据类型. 好了,进入正题---首先,为了在我们的程序中使用string类型,我们必须包含头文件 <string>
-
PHP面试常用算法(推荐)
一.冒泡排序 基本思想: 对需要排序的数组从后往前(逆序)进行多遍的扫描,当发现相邻的两个数值的次序与排序要求的规则不一致时,就将这两个数值进行交换.这样比较小(大)的数值就将逐渐从后面向前面移动. //冒泡排序 <?php function mysort($arr) { for($i = 0; $i < count($arr); $i++) { $isSort = false; for ($j=0; $j< count($arr) - $i - 1; $j++) { if($arr[$
-
php计算两个整数的最大公约数常用算法小结
本文实例讲述了php计算两个整数的最大公约数常用算法.分享给大家供大家参考.具体如下: 复制代码 代码如下: <?php //计时,返回秒 function microtime_float () { list( $usec , $sec ) = explode ( " " , microtime ()); return ((float) $usec + (float) $sec ); } /////////////////////////////////
-
Python常用算法学习基础教程
本节内容 算法定义 时间复杂度 空间复杂度 常用算法实例 1.算法定义 算法(Algorithm)是指解题方案的准确而完整的描述,是一系列解决问题的清晰指令,算法代表着用系统的方法描述解决问题的策略机制.也就是说,能够对一定规范的输入,在有限时间内获得所要求的输出.如果一个算法有缺陷,或不适合于某个问题,执行这个算法将不会解决这个问题.不同的算法可能用不同的时间.空间或效率来完成同样的任务.一个算法的优劣可以用空间复杂度与时间复杂度来衡量. 一个算法应该具有以下七个重要的特征: ①有穷性(Fin
-
PHP常用算法和数据结构示例(必看篇)
实例如下: </pre><pre name="code" class="php"><?php /** * Created by PhpStorm. * User: qishou * Date: 15-8-2 * Time: 上午9:12 */ header("content-type:text/html;charset=utf-8"); $arr = array(3,5,8,4,9,6,1,7,2); echo im