C++提供的遍历、移动元素、查找、排序、集合的交并补运算的详细介绍——C++学习记录03

1. STL-常用算法

1.1 简介

算法模块主要由<algorithm><functional>和<numeric>组成
范围涉及到比较、交换、查找、遍历、复制和修改等操作
体积很小，只包括几个在序列上面进行简单数学运算的模板函数
定义了一些模板类，用以声明函数对象

1.2 遍历容器

1.2.1 for_each()遍历方法

1.2.2 仿函数输出（重载函数调用符()）

#include<iostream>
#include<algorithm>
#include<vector>
#include<string>

using namespace std;

// 1.for_each遍历容器输出
// 普通函数输出
void print01(int val) {
cout << val << " ";
}

// 仿函数输出
class print02 {
public:
void operator()(int val) {
cout << val << " ";
}
 };

void test01() {
vector<int> v;
for (int i = 0; i < 10; i++) {
v.push_back(i);
}

// 遍历算法，需要传入输出方式
for_each(v.begin(), v.end(), print01);// 普通函数不使用()
cout << endl;
for_each(v.begin(), v.end(), print02());// 仿函数使用()
cout << endl;

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

1.3 搬运容器元素

#include<iostream>
#include<algorithm>
#include<vector>
#include<string>

using namespace std;

// 2.搬运容器元素
class TransForm {
public:
int operator()(int val) {// 重载函数调用，返回元素本身
return val;
}
};
class MyPrint {
public:
void operator()(int val) {// 重载函数调用，进行元素输出
cout << val << " ";
}
};

void test02() {
vector<int> v1;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
}

vector<int> v2;// 目标容器
v2.resize(v1.size());// 目标容器开辟空间
// 开始进行搬运
transform(v1.begin(), v1.end(), v2.begin(), TransForm());

for_each(v2.begin(), v2.end(), MyPrint());
cout << endl;


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

1.4 查找元素

find 在指定容器中查找，返回值是元素的位置迭代器
find_if 可以更加灵活得查找元素，需要使用仿函数提供比较规则
adjacent_find 返回第一次相邻元素的位置迭代器
binary_search 二分查找效率很高，但是要求元素中的元素必须是有序的
count 统计元素个数
count_if 按条件统计元素个数，需要利用重载运算指定比较规则

#include<iostream>
#include<algorithm>
#include<vector>
#include<string>

using namespace std;


// 3.查找算法

// find可以在容器中查找指定的元素,返回值是迭代器
// find_if可以使得查找变得更加灵活，但是需要提供仿函数提供比较规则
class Person {
public:
string mname;
int mage;
Person(string name, int age) {// 构造函数
this->mname = name;
this->mage = age;
}
// 重载运算符==，局部函数进行重载
bool operator==(const Person &p) {// 重载运算符
if (this->mname == p.mname && this->mage == p.mage) {
return true;
}
return false;
}
};

void test03() {
vector<int> v;
for (int i = 0; i < 5; i++) {
v.push_back(i + 1);//将值压入
}
// 在vecotr中查找元素5
vector<int>::iterator it = find(v.begin(), v.end(), 5);
if (it == v.end()) {
cout << "没有找到元素5" << endl;
}
else {
cout << "找到：" << *it << endl;
}
}
void test04() {
vector<Person> v;
// 创建数据
Person p1("aaa", 10);
Person p2("bbb", 20);
Person p3("ccc", 30);
Person p4("ddd", 40);

v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);

vector<Person>::iterator it = find(v.begin(), v.end(), p2);

if (it == v.end()) {
cout << "没有找到" << endl;
}
else {
cout << "姓名：" << it->mname << "年龄:" << it->mage << endl;
}
}

class GreaterFive {
public:
bool operator()(int val) {// 函数调用符重载
return val > 5;
}

};
// find_if查找
void test05() {
vector<int> v;
for (int i = 0; i < 10; i++) {
v.push_back(i + i);
}

//find_if按条件查找使查找更加灵活，提供的仿函数可以改变不同的策略
vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
if (it == v.end()) {
cout << "没有找到！" << endl;
}
else {
cout << "找到大于5的数字:" << *it << endl;
}
}

// adjacent_find查找
// 返回相邻元素的第一个位置的迭代器
void test06() {
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(2);
v.push_back(2);
v.push_back(4);
v.push_back(4);
v.push_back(1);
v.push_back(3);

vector<int>::iterator it = adjacent_find(v.begin(), v.end());
if (it == v.end()) {
cout << "找不到！" << endl;
}
else {
cout << "找到相邻重复元素为：" << *it << endl;
}
}
// binary_search
// 二分查找效率很高，但是要求容器中的元素必须是有序的
void test07() {
vector<int> v;
for (int i = 0; i < 10; i++) {
v.push_back(i);
}

bool ret = binary_search(v.begin(), v.end(), 2);
if (ret) {
cout << "找到了" << endl;
}
else {
cout << "未找到" << endl;
}
}
// count统计元素个数
void test08() {
vector<int> v;
for (int i = 0; i < 10; i++) {
v.push_back(i);
}
int num = count(v.begin(), v.end(), 2);
cout << "2的个数为：" << num << endl;

vector<Person> v1;
Person p1("诸葛亮", 20);
Person p2("刘备", 24);
Person p3("关羽", 30);
Person p4("典韦", 24);
Person p5("蒙恬", 35);

v1.push_back(p1);
v1.push_back(p2);
v1.push_back(p3);
v1.push_back(p4);
v1.push_back(p5);

Person p("诸葛亮", 20);
int pnum = count(v1.begin(), v1.end(), p);
cout << "诸葛亮人数为:" << pnum << endl;
}

//count_if按条件统计元素个数
class Greater4 {
public:
bool operator()(int val) {// 函数调用重载
return val > 4;
}
};
void test09() {
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(4);
v.push_back(5);
v.push_back(3);
v.push_back(4);
v.push_back(4);

int num = count_if(v.begin(), v.end(), Greater4());
cout << "大于4的个数为：" << num << endl;
}
int main()
{

//test01();
//test02();
//test03();
//test04();
//test05();
//test06();
//test07();
//test08();
test09();
system("pause");
return 0;
}

1.5 排序

sort() 默认升序排序
cort(v.begin(),v.end(),greater());// 降序排序
random_shuffle随机打乱元素
merge合并两个容器
reverse反转容器
copy复制容器
replace替换元素
replace_if按条件替换元素

#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<ctime>

using namespace std;

// 4. 排序
void myPrint(int val) {
cout << val << " ";
}
// sort排序
void test01() {
vector<int> v;
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
v.push_back(50);
v.push_back(60);
v.push_back(70);

// 默认升序排序
sort(v.begin(), v.end());
for_each(v.begin(), v.end(), myPrint);
cout << endl;

// 降序排序
sort(v.begin(), v.end(), greater<int>());
for_each(v.begin(), v.end(), myPrint);
cout << endl;

}

// random_shuffle

class myPrint {
public:
void operator()(int val) {// 重载函数调用
cout << val << " ";
}
};
void test02() {
srand((unsigned int)time(NULL));
vector<int> v;
for (int i = 0; i < 10; i++) {
v.push_back(i);
}
// 使用for_each遍历
for_each(v.begin(), v.end(), myPrint);
cout << endl;

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

}
// 3. 合并两个容器
void test03() {
vector<int> v1;
vector<int> v2;
for (int i = 0; i < 5; i++) {
v1.push_back(i);
v2.push_back(i + 1);
}
vector<int> vtarget;
vtarget.resize(v1.size() + v2.size()); // 调整存储大小
// 向量融合，融合的向量必须是有序的
merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vtarget.begin());
// 遍历输出
for_each(vtarget.begin(), vtarget.end(), myPrint);
cout << endl;

}
// 反转向量
void test04() {
vector<int> v;
for (int i = 0; i < 10; i++) {
v.push_back(i);
}
cout << "反转前：" << endl;
for_each(v.begin(), v.end(), myPrint);
cout << endl;
cout << "反转后：" << endl;
reverse(v.begin(), v.end());// 反转向量
for_each(v.begin(), v.end(), myPrint);
cout << endl;

}

// 复制向量
void test05() {
vector<int> v1;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
}

vector<int> v2;
v2.resize(v1.size());// 需要开辟空间
// 复制
copy(v1.begin(), v1.end(), v2.begin());
for_each(v2.begin(), v2.end(), myPrint);
cout << endl;
}

// 替换元素
void test06() {
vector<int> v;
v.push_back(10);
v.push_back(6);
v.push_back(5);
v.push_back(7);
v.push_back(2);
v.push_back(12);
v.push_back(90);
v.push_back(12);

cout << "替换前：" << endl;
for_each(v.begin(), v.end(), myPrint);
cout << endl;

// 替换
cout << "替换后" << endl;
replace(v.begin(), v.end(), 12, 12000);
for_each(v.begin(), v.end(), myPrint);
cout << endl;
}

int main()
{
//test01();
//test02();
//test03();
//test04();
//test05();
test06();

system("pause");
return 0;
}
5. numeric方法
accumulate统计总和
fill以某一个元素填充数据
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<ctime>
#include<numeric>

using namespace std;

class myPrint {
public:
void operator()(int val) {
cout << val << " ";
}
};

void test01() {
vector<int> v1;
for (int i = 0; i < 100; i++) {
v1.push_back(i);
}

// 统计总和
int total = accumulate(v1.begin(), v1.end(), 0);
cout << "total=" << total << endl;
}

//填充数据
void test02() {
vector<int> v;
v.resize(10);
fill(v.begin(), v.end(), 100);
for_each(v.begin(), v.end(), myPrint());
cout << endl;
}

int main()
{
//test01();
test02();
system("pause");
return 0;
}

1.6 交集、并集、差集

set_intersection 交集
set_union 并集
set_difference 差集

#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<ctime>
#include<numeric>

using namespace std;

class myPrint {
public:
void operator()(int val) {
cout << val << " ";
}
};
// 交集
void test01()
{
vector<int> v1;
vector<int> v2;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
v2.push_back(i + 5);
}

vector<int> vTarget;
//取两个里面较小的值给目标容器开辟空间
vTarget.resize(min(v1.size(), v2.size()));

//返回目标容器的最后一个元素的迭代器地址
vector<int>::iterator itEnd =
set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

for_each(vTarget.begin(), itEnd, myPrint());
cout << endl;
}

// set_union两个集合找并集
void test02()
{
vector<int> v1;
vector<int> v2;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
v2.push_back(i + 5);
}

vector<int> vTarget;
//取两个容器的和给目标容器开辟空间
vTarget.resize(v1.size() + v2.size());

//返回目标容器的最后一个元素的迭代器地址
vector<int>::iterator itEnd =
set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

for_each(vTarget.begin(), itEnd, myPrint());
cout << endl;
}

// 差集，求取差集必须集合容器要有序
void test01()
{
vector<int> v1;
vector<int> v2;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
v2.push_back(i + 5);
}

vector<int> vTarget;
//取两个里面较大的值给目标容器开辟空间
vTarget.resize(max(v1.size(), v2.size()));

//返回目标容器的最后一个元素的迭代器地址
cout << "v1与v2的差集为： " << endl;
vector<int>::iterator itEnd =
set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
for_each(vTarget.begin(), itEnd, myPrint());
cout << endl;


cout << "v2与v1的差集为： " << endl;
itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());
for_each(vTarget.begin(), itEnd, myPrint());
cout << endl;
}

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