STL day04下 函数对象和各种常用的算法

摘要

尽管今天主要内容是STL中的算法，但是还是有一部分函数对象的概念，这里不做赘述，但是其中重点学习谓词和仿函数的运用，这里是重点，在STL常用算法中，谓词和仿函数是经常要使用的。

下面总结下，STL的重点，是多要联系，熟练记住各种结构，STL是一种非常好用的工具，里面有各种算法，可以节省大量时间，

重点为：operator的使用，STL的算法往往都是默认的，不能同时处理多种数据类型，同时在算法中 带_if这种的算法，基本都可以处理复杂问题，同样他们需要重载（）。来扩宽数据类型的支持范围

第二，是各种拷贝、复制、合并、作差的算法，一旦涉及创造新的数据时，一定要先开辟内存空间，不然就会报错。

目录

STL- 函数对象

函数对象

函数对象概念

 函数对象使用

谓词

谓词概念

一元谓词

二元谓词

内建函数对象

 内建函数对象意义

算术仿函数

关系仿函数

逻辑仿函数

STL- 常用算法

 常用遍历算法

for_each

transform

常用查找算法

 find

find_if

adjacent_find

binary_search

count统计

count_if

常用排序算法

sort

random_shuffle

merge

reverse

常用拷贝和替换算法

copy

replace

replace_if

swap

常用算术生成算法

 accumulate

fill

常用集合算法

 set_intersection

set_union

set_difference

---

STL- 函数对象

函数对象

函数对象概念

概念：

• 重载函数调用操作符的类，其对象常称为函数对象

• 函数对象使用重载的()时，行为类似函数调用，也叫仿函数

本质：

函数对象(仿函数)是一个类，不是一个函数

 函数对象使用

特点：

• 函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值

• 函数对象超出普通函数的概念，函数对象可以有自己的状态（函数内部有自己的属性）

• 函数对象可以作为参数传递（这样是用的时候，先确定有无重载，没有不识别）

//1、函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
class my_add
{
public:
	int operator()(int v1, int v2)
	{
		return v1 + v2;
	}
};
//2、函数对象可以有自己的状态
class my_print
{
public:
	my_print()
	{
	this->count = 0;
	}
	void operator()(string test)
	{
		cout << test << endl;
		count++;  //统计使用次数
	}
	int count;//内部自己的状态
};
//3、函数对象可以作为参数传递
void do_print(my_print& mp, string test)
{
	mp(test);
}
void test01()
{
	my_add myadd;
	cout << myadd(10, 10) << endl;

	my_print my_p;
	my_p("hello world");
	my_p("hello world");
	my_p("hello world");
	my_p("hello world");
	cout << "调用次数" << my_p.count << endl;
}

void test03()
{
	my_print my_p;
	do_print(my_p, "hello c++");
}

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

总结：

• 仿函数写法非常灵活，可以作为参数进行传递。好好练吧

谓词

谓词概念

概念：

• 返回bool类型的仿函数称为谓词

• 如果operator()接受一个参数，那么叫做一元谓词

• 如果operator()接受两个参数，那么叫做二元谓词

一元谓词

#include<iostream>
using namespace std;
#include <vector>
#include <string>
#include<algorithm>//运算的标准头文件
//仿函数 返回类型是bool的数据类型的就叫谓词
//一元谓词

class greater_five
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};

void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	//查找容器中，有没有大于5的数字
	//greater_five()匿名的函数对象
	vector<int>::iterator it = find_if(v.begin(), v.end(), greater_five());
	if (it == v.end())
	{
		cout << "未找到大于5的数字" << endl;
	}
	else
	{
		cout << "找到了" << *it << endl;
	}
	
}

int main()
{
	test01();

	system("pause");
	return 0;
}

find_if是一个新学的内容，，就是find_if(在某种条件下寻找)

总结：参数只有一个的谓词，称为一元谓词

二元谓词

参数只有两个的谓词，称为二元谓词

 

//二元谓词
class my_compare
{
public:
	bool operator()(int val1,int val2)
	{
		return val1 > val2;
	}
};


void test01()
{
	vector<int> v;
	v.push_back(10);
	v.push_back(40);
	v.push_back(20);
	v.push_back(30);
	v.push_back(50);
	
	sort(v.begin(), v.end());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << "  ";
	}
	cout << endl;

	//使用函数对象，改变算法策略，变为排序规则为从大到小
	sort(v.begin(), v.end(), my_compare());
	cout << "----------------------------" << endl;

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

内建函数对象

 内建函数对象意义

概念：

• STL内建了一些函数对象，标准的仿函数通用

分类:

• 算术仿函数

• 关系仿函数

• 逻辑仿函数

用法：

• 这些仿函数所产生的对象，用法和一般函数完全相同

• 使用内建函数对象，需要引入头文件 #include<functional>

算术仿函数

功能描述：

• 实现四则运算

• 其中negate是一元运算，其他都是二元运算

仿函数原型：

• template<class T> T plus<T> //加法仿函数

• template<class T> T minus<T> //减法仿函数

• template<class T> T multiplies<T> //乘法仿函数

• template<class T> T divides<T> //除法仿函数

• template<class T> T modulus<T> //取模仿函数

• template<class T> T negate<T> //取反仿函数

使用内建函数对象时，需要引入头文件 #include <functional>

//仿函数 返回类型是bool的数据类型的就叫谓词


//二元谓词
void test01()
{
	negate<int> n;//取反仿函数  就是取50相反值 =-50
	cout << n(50) << endl;
}

//plus
void test02()
{
	plus<int> p;//计算二元仿函数的时候，要写一个还是两个？一个，他默认传递的都是同种数据
	//因此更复杂的运算建议重载
	cout << p(20, 40) << endl;
}

int main() {

	test01();
	test02();

	system("pause");

	return 0;
}

关系仿函数

功能描述：

• 实现关系对比

仿函数原型：

• template<class T> bool equal_to<T> //等于

• template<class T> bool not_equal_to<T> //不等于

• template<class T> bool greater<T> //大于

• template<class T> bool greater_equal<T> //大于等于

• template<class T> bool less<T> //小于

• template<class T> bool less_equal<T> //小于等于

#include <algorithm>

class my_compare
{
	public:
		bool operator()(int val1,int val2)
		{
			return val1 > val2;
		}
};
void test01()
{
	vector<int> v;

	v.push_back(10);
	v.push_back(30);
	v.push_back(50);
	v.push_back(40);
	v.push_back(20);

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << "   ";
	}
	cout << endl;

	//sort(v.begin(), v.end(), my_compare());
	//自己实现仿函数

	//系统提供的
	sort(v.begin(), v.end(), greater<int>());
	//greater是系统提供的，甚至不需要写仿函数，在<内>写好数据类型即可，但是不支持多种数据，

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << "   ";
	}
	//STL内建仿函数  大于仿函数

}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：关系仿函数中最常用的就是greater<>大于

逻辑仿函数

功能描述：

• 实现逻辑运算

函数原型：

• template<class T> bool logical_and<T> //逻辑与

• template<class T> bool logical_or<T> //逻辑或

• template<class T> bool logical_not<T> //逻辑

#include <vector>
#include <functional>
#include <algorithm>
void test01()
{
	vector<bool> v;
	v.push_back(true);
	v.push_back(false);
	v.push_back(true);
	v.push_back(false);

	for (vector<bool>::iterator it = v.begin();it!= v.end();it++)
	{
		cout << *it << " ";
	}
	cout << endl;

	//逻辑非  将v容器搬运到v2中，并执行逻辑非运算
	vector<bool> v2;
	v2.resize(v.size());
	transform(v.begin(), v.end(),  v2.begin(), logical_not<bool>());
	for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：逻辑仿函数实际应用较少，了解即可

STL- 常用算法

概述:

• 算法主要是由头文件<algorithm> <functional> <numeric>组成。

• <algorithm>是所有STL头文件中最大的一个，范围涉及到比较、 交换、查找、遍历操作、复制、修改等等

• <numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数

• <functional>定义了一些模板类,用以声明函数对象。

 常用遍历算法

学习目标：

• 掌握常用的遍历算法

算法简介：

• for_each //遍历容器

• transform //搬运容器到另一个容器中

for_each

功能描述：

• 实现遍历容器

函数原型：

• for_each(iterator beg, iterator end, _func);

  // 遍历算法 遍历容器元素

  // beg 开始迭代器

  // end 结束迭代器

  // _func 函数或者函数对象

#include<iostream>
using namespace std;
#include <vector>
#include <string>
#include<functional>//运算的标准头文件

//仿函数 返回类型是bool的数据类型的就叫谓词

#include <algorithm>

//普通函数
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，写一大堆的迭代器，但是for_each一行就搞定。
	//普通实现，自己写的
	for_each(v.begin(), v.end(), print01);
	cout << endl;
	//仿函数实现
	for_each(v.begin(), v.end(), print02());

}

int main() {

	test01();

	system("pause");

	return 0;
}

其他实现要用for，写一大堆的迭代器，但是for_each一行就搞定。

总结：for_each在实际开发中是最常用遍历算法，需要熟练掌握

transform

功能描述：

• 搬运容器到另一个容器中，还可以进行一些数据处理

函数原型：

• transform(iterator beg1, iterator end1, iterator beg2, _func);

          ↑原容器头    ↑原容器尾  ↑新容器头    ↑某些算法

//beg1 源容器开始迭代器

//end1 源容器结束迭代器

//beg2 目标容器开始迭代器

//_func 函数或者函数对象

 正常版搬运

处理数据版

 

#include <vector>

#include <algorithm>


class banyun
{
public:
	int operator()(int v)
	{
		//正常版
		//return v;
		//做逻辑运算版
		return v + 100;
	}

};
class MyPrint
{
public:
	void operator()(int val)
	{
		cout << val << "  ";
	}
};
void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	
	vector <int>v_target;//目标容器
	v_target.resize(v.size());
	//因此目标容器必须提前开辟空间

	transform(v.begin(), v.end(), v_target.begin(), banyun());
	for_each(v_target.begin(), v_target.end(), MyPrint());
	cout << endl;
	//如果这里直接运行会崩溃掉，因为他没有开辟空间
}

int main() {

	test01();

	system("pause");

	return 0;
}

常用查找算法

学习目标：

• 掌握常用的查找算法

算法简介：

• find //查找元素

• find_if //按条件查找元素

• adjacent_find //查找相邻重复元素

• binary_search //二分查找法

• count //统计元素个数

• count_if //按条件统计元素个数

 find

功能描述：

• 查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()

函数原型：

• find(iterator beg, iterator end, value);

  // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

  // beg 开始迭代器

  // end 结束迭代器

  // value 查找的元素

void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	//查找容器中是否有 5 这个元素
	//不管找到与否都会返回一个迭代器
	vector <int> ::iterator it= find(v.begin(), v.end(), 5);
	if (it == v.end())
	{
		cout << "没有找到" << endl;
	}
	else
	{
		cout << "找到了： " << *it << endl;
	}
}
class person
{
public:
	person(string name, int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	//重载==号，让底层的find知道如何对比person数据
	bool operator==(const person& p)
	{//使用指针访问，同时const修饰，防止修改
		//指针访问到的m_name等于p的name时候，并且年龄也想通，就返回真，否则就返回假
		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 test02()
{
	vector<person>v;
	//创建数据
	person p1("aaa", 17);
	person p2("bbb", 23);
	person p3("ccc", 43);
	person p4("ddd", 23);
	person p5("eee", 45);
	//插入数据
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);

	vector<person>::iterator it = find(v.begin(), v.end(), p2);
	if (it == v.end())
	{
		cout << "没有找到" << endl;
	}
	else
	{        //注意这里用的指针的方式->，解出内存地址
		cout << "找到了： " << "姓名是" << it->m_name<<"年龄是:  " << it->m_age << endl;
	}
}

int main() {

	test02();

	system("pause");

	return 0;
}

总结： 利用find可以在容器中找指定的元素，返回值是迭代器

find_if

功能描述：

• 按条件查找元素

函数原型：

• find_if(iterator beg, iterator end, _Pred);

  // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

  // beg 开始迭代器

  // end 结束迭代器

  // _Pred 函数或者谓词（返回bool类型的仿函数）

#include <vector>

#include<string>
#include <algorithm>

class greater_five
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};

void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}
	//查找容器中是否有 5 这个元素
	//不管找到与否都会返回一个迭代器
	vector <int> ::iterator it= find_if(v.begin(), v.end(),greater_five());
	if (it == v.end())
	{
		cout << "没有找到" << endl;
	}
	else
	{
		cout << "找到了： " << *it << endl;
	}
}

class person
{
public:
	person(string name, int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	string m_name;
	int m_age;

};
class greater_20
{
public:
	bool operator ()(person& p)
	{
		return p.m_age > 20;
	}
};
void test02()
{
	vector<person>v;
	//创建数据
	
	person p1("aaa", 17);
	person p2("bbb", 23);
	person p3("ccc", 43);
	person p4("ddd", 23);
	person p5("eee", 45);
	//插入数据
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
	//找到年龄大于20的人
	vector <person>::iterator it = find_if(v.begin(), v.end(), greater_20());
	if (it == v.end())
	{
		cout << "没有找到" << endl;
	}
	else
	{
		cout << "找到姓名:" << it->m_name << "  年龄：" << it->m_age << endl;
	}
}

int main()
{

	//test01();
	test02();
	system("pause");

	return 0;
}

就是find升级版，更灵活，但是要频繁operator去重载。

adjacent_find

功能描述：

• 查找相邻重复元素（就是相邻的两个袁术互相比较，相同就输出的封装算法）

函数原型：

• adjacent_find(iterator beg, iterator end);

  // 查找相邻重复元素,返回相邻元素的第一个位置的迭代器

  // beg 开始迭代器

  // end 结束迭代器

#include<string>
#include <algorithm>


void test01()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(5);
	v.push_back(2);
	v.push_back(4);
	v.push_back(4);
	v.push_back(3);

	//查找相邻重复元素
	vector<int>::iterator it = adjacent_find(v.begin(), v.end());
	if (it == v.end()) {
		cout << "找不到!" << endl;
	}
	else {
		cout << "找到相邻重复元素为:" << *it << endl;
	}
}

int main()
{

	test01();
	
	system("pause");

	return 0;
}

binary_search

功能描述：

• 查找指定元素是否存在，和emty一样吧？只不过是封装的？

函数原型：

• bool binary_search(iterator beg, iterator end, value);

  // 查找指定的元素，查到 返回true 否则false

  // 注意: 在无序序列中不可用

  // beg 开始迭代器

  // end 结束迭代器

  // value 查找的元素

#include <algorithm>
#include <vector>

void test01()
{
	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;
	}
}

int main() {

	test01();

	system("pause");

	return 0;
}

二分查找法查找效率很高，值得注意的是查找的容器中元素必须的有序序列

如果是无序序列，结果就不知道是否正确了

count统计

功能描述：

• 统计元素个数

函数原型：

• count(iterator beg, iterator end, value);

  // 统计元素出现次数

  // beg 开始迭代器

  // end 结束迭代器

  // value 统计的元素

#include <algorithm>
#include <vector>

//内置数据类型
void test01()
{
	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(v.begin(), v.end(), 4);

	cout << "4的个数为： " << num << 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_Age == p.m_Age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	string m_Name;
	int m_Age;
};

void test02()
{
	vector<Person> v;

	Person p1("刘备", 35);
	Person p2("关羽", 35);
	Person p3("张飞", 35);
	Person p4("赵云", 30);
	Person p5("曹操", 25);

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
    
    Person p("诸葛亮",35);

	int num = count(v.begin(), v.end(), p);
	cout << "num = " << num << endl;
}
int main() {

	//test01();

	test02();

	system("pause");

	return 0;
}

总结： 统计自定义数据类型时候，需要配合重载 operator==

count_if

功能描述：

• 按条件统计元素个数

函数原型：

• count_if(iterator beg, iterator end, _Pred);

  // 按条件统计元素出现次数

  // beg 开始迭代器

  // end 结束迭代器

  // _Pred 谓词

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

//常用查找算法
class greater_20
{
public:
	bool operator()(int val)
	{
		return val > 3;
	}
};
void test01()
{
	
	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(), greater_20());

	cout << "大于3的个数为： " << num << endl;
}
class person
{
public:
	person(string name, int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	string m_name;
	int m_age;
};
class age_less30
{
public:
	bool operator ()(const person& p)
	{
		return p.m_age > 30;
	}
};
void test02()
{
	vector<person>v;

	person p1("刘备", 35);
	person p2("关羽", 35);
	person p3("张飞", 35);
	person p4("赵云", 30);
	person p5("曹操", 25);

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

	int num= count_if(v.begin(), v.end(), age_less30());
	cout << "大于30岁的个数：" << num << endl;
}


int main()
{

	//test01();
	test02();
	system("pause");

	return 0;
}

常用排序算法

学习目标：

• 掌握常用的排序算法

算法简介：

• sort //对容器内元素进行排序

• random_shuffle //洗牌 指定范围内的元素随机调整次序

• merge // 容器元素合并，并存储到另一容器中

• reverse // 反转指定范围的元素

sort

功能描述：

• 对容器内元素进行排序

函数原型：

• sort(iterator beg, iterator end, _Pred);

  // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

  // beg 开始迭代器

  // end 结束迭代器

  // _Pred 谓

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


//常用查找算法
void my_print(int val)
{
	cout << val << endl;
}
void test01()
{
	
	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);
	//普通方法 升序
	sort(v.begin(), v.end());
	cout << "普通方法 升序" << endl;
	for_each(v.begin(), v.end(), my_print);

	//倒序排列
	sort(v.begin(), v.end(), greater<int>());
	//两种方法，一种仿函数判断，一种直接写一个greater
	cout << "倒序排列" << endl;
	for_each(v.begin(), v.end(), my_print);
}


int main()
{
	test01();
	system("pause");

	return 0;
}

sort属于开发中最常用的算法之一，需熟练掌握

random_shuffle

功能描述：

• 洗牌 指定范围内的元素随机调整次序

函数原型：

• random_shuffle(iterator beg, iterator end);

  // 指定范围内的元素随机调整次序

  // beg 开始迭代器

  // end 结束迭代器

 

#include<iostream>
using namespace std;
#include <vector>
#include<string>
#include <algorithm>
#include<ctime>
class my_print
{
public:
	void operator ()(int val)
	{
		cout << val << "  ";
	}
	
};
void test01()
{
	srand((unsigned int)time(NULL));
	//加上这种函数后，所有的rand函数都变成当前时间作为随机数
	vector<int> v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
}
	//利用洗牌的算法，打乱顺序
	random_shuffle(v.begin(), v.end());
	for_each(v.begin(), v.end(), my_print());
	cout << endl;
}

int main()
{
	test01();
	system("pause");

	return 0;
}

总结：random_shuffle洗牌算法比较实用，使用时记得加随机数种子

merge

功能描述：

• 两个容器元素合并，并存储到另一容器中

函数原型：

• merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

  // beg1 容器1开始迭代器 // end1 容器1结束迭代器 // beg2 容器2开始迭代器 // end2 容器2结束迭代器 // dest 目标容器开始迭代器

• // 容器元素合并，并存储到另一容器中

  // 注意: 两个容器必须是有序的

  #include<iostream>
  using namespace std;
  #include <vector>
  #include<string>
  #include <algorithm>
  class my_print
  {
  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 + 2);
  	}
  
  	//目标容器
  	vector<int >v_target;
  	//目标容器需要提前开辟空间,否则内存溢出
  	v_target.resize(v1.size() + v2.size());
  	//合并  需要两个有序序列
  	merge(v1.begin(), v1.end(), v2.begin(), v2.end(), v_target.begin());
  	for_each(v_target.begin(), v_target.end(),my_print());
  }
  
  int main()
  {
  	test01();
  	system("pause");
  
  	return 0;
  }

reverse

功能描述：

• 将容器内元素进行反转

函数原型：

• reverse(iterator beg, iterator end);

  // 反转指定范围的元素

  // beg 开始迭代器

  // end 结束迭代器

#include <algorithm>
#include <vector>

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

void test01()
{
	vector<int> v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(50);
	v.push_back(20);
	v.push_back(40);

	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;
}

int main() {

	test01();

	system("pause");

	return 0;
}

常用拷贝和替换算法

学习目标：

• 掌握常用的拷贝和替换算法

算法简介：

• copy // 容器内指定范围的元素拷贝到另一容器中

• replace // 将容器内指定范围的旧元素修改为新元素

• replace_if // 容器内指定范围满足条件的元素替换为新元素

• swap // 互换两个容器的元素

copy

功能描述：

• 容器内指定范围的元素拷贝到另一容器中

函数原型：

• copy(iterator beg, iterator end, iterator dest);

  // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

  // beg 开始迭代器

  // end 结束迭代器

  // dest 目标起始迭代器

#include<iostream>
using namespace std;
#include <vector>
#include<string>
#include <algorithm>
class my_print
{
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.resize(v1.size());
	copy(v1.begin(), v1.end(),v2.begin());
	for_each(v2.begin(), v2.end(), my_print());
}


int main()
{
	test01();
	system("pause");

	return 0;
}

总结：利用copy算法在拷贝时，目标容器记得提前开辟空间

replace

功能描述：

• 将容器内指定范围的旧元素修改为新元素

函数原型：

• replace(iterator beg, iterator end, oldvalue, newvalue);

  // 将区间内旧元素 替换成 新元素

  // beg 开始迭代器

  // end 结束迭代器

  // oldvalue 旧元素

  // newvalue 新元素

 

#include<string>
#include <algorithm>
class my_print
{
public:
	void operator()(int val)
	{
		cout << val << "  ";
	}
};

void test01()
{
	vector<int> v;
	v.push_back(20);
	v.push_back(30);
	v.push_back(20);
	v.push_back(40);
	v.push_back(50);
	v.push_back(10);
	v.push_back(20);

	cout << "替换前：" << endl;
	for_each(v.begin(), v.end(), my_print());
	cout << endl;
	//将容器中的20 替换成 2000
	cout << "替换后：" << endl;
	replace(v.begin(), v.end(), 20, 2000);
	//根据条件替换，但默认的只适合int型，重载后兴许可以替换更复杂的
	for_each(v.begin(), v.end(), my_print());
}

int main()
{
	test01();
	system("pause");

	return 0;
}

replace会替换区间内满足条件的元素

replace_if

功能描述:

• 将区间内满足条件的元素，替换成指定元素

函数原型：

• replace_if(iterator beg, iterator end, _pred, newvalue);

  // 按条件替换元素，满足条件的替换成指定元素

  // beg 开始迭代器

  // end 结束迭代器

  // _pred 谓词

  // newvalue 替换的新元

#include <algorithm>
#include <vector>

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

class ReplaceGreater30
{
public:
	bool operator()(int val)
	{
		return val >= 30;
	}

};

void test01()
{
	vector<int> v;
	v.push_back(20);
	v.push_back(30);
	v.push_back(20);
	v.push_back(40);
	v.push_back(50);
	v.push_back(10);
	v.push_back(20);

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

	//将容器中大于等于的30 替换成 3000
	cout << "替换后：" << endl;
	replace_if(v.begin(), v.end(), ReplaceGreater30(), 3000);
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

replace_if按条件查找，可以利用仿函数灵活筛选满足的条件

swap

功能描述：

• 互换两个容器的元素

函数原型：

• swap(container c1, container c2);

  // 互换两个容器的元素

  // c1容器1

  // c2容器2

#include <algorithm>
#include <vector>

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+100);
	}

	cout << "交换前： " << endl;
	for_each(v1.begin(), v1.end(), myPrint());
	cout << endl;
	for_each(v2.begin(), v2.end(), myPrint());
	cout << endl;

	cout << "交换后： " << endl;
	swap(v1, v2);
	for_each(v1.begin(), v1.end(), myPrint());
	cout << endl;
	for_each(v2.begin(), v2.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：swap交换容器时，注意交换的容器要同种类型

常用算术生成算法

学习目标：

• 掌握常用的算术生成算法

注意：

• 算术生成算法属于小型算法，使用时包含的头文件为 #include <numeric>

算法简介：

• accumulate // 计算容器元素累计总和

• fill // 向容器中添加元素

 accumulate

功能描述：

• 计算区间内 容器元素累计总和

函数原型：

• accumulate(iterator beg, iterator end, value);

  // 计算容器元素累计总和

  // beg 开始迭代器

  // end 结束迭代器

  // value 起始值

#include <numeric>
#include <vector>
void test01()
{
	vector<int> v;
	for (int i = 0; i <= 100; i++) {
		v.push_back(i);
	}

	int total = accumulate(v.begin(), v.end(), 0);

	cout << "total = " << total << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：accumulate使用时头文件注意是 numeric，这个算法很实用

fill

功能描述：

• 向容器中填充指定的元素

函数原型：

• fill(iterator beg, iterator end, value);

  // 向容器中填充元素

  // beg 开始迭代器

  // end 结束迭代器

  // value 填充的值

#include <numeric>
#include <vector>
#include <algorithm>

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

void test01()
{

	vector<int> v;
	v.resize(10);
	//填充
	fill(v.begin(), v.end(), 100);

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

int main() {

	test01();

	system("pause");

	return 0;
}

总结：利用fill可以将容器区间内元素填充为 指定的值

常用集合算法

学习目标：

• 掌握常用的集合算法

算法简介：

• set_intersection // 求两个容器的交集

• set_union // 求两个容器的并集

• set_difference // 求两个容器的差集

 set_intersection

功能描述：

• 求两个容器的交集

函数原型：

• set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

  // 求两个集合的交集

  // 注意:两个集合必须是有序序列

  // beg1 容器1开始迭代器 // end1 容器1结束迭代器 // beg2 容器2开始迭代器 // end2 容器2结束迭代器 // dest 目标容器开始迭代器

#include <vector>
#include <algorithm>

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;
}

int main() {

	test01();

	system("pause");

	return 0;
}

• 求交集的两个集合必须的有序序列

• 目标容器开辟空间需要从两个容器中取小值

• set_intersection返回值既是交集中最后一个元素的位置

set_union

功能描述：

• 求两个集合的并集

函数原型：

• set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

  // 求两个集合的并集

  // 注意:两个集合必须是有序序列

  // beg1 容器1开始迭代器 // end1 容器1结束迭代器 // beg2 容器2开始迭代器 // end2 容器2结束迭代器 // dest 目标容器开始迭代器

#include <vector>
#include <algorithm>

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(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;
}

int main() {

	test01();

	system("pause");

	return 0;
}

• 求并集的两个集合必须的有序序列

• 目标容器开辟空间需要两个容器相加

• set_union返回值既是并集中最后一个元素的位置

set_difference

功能描述：

• 求两个集合的差集

函数原型：

• set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

  // 求两个集合的差集

  // 注意:两个集合必须是有序序列

  // beg1 容器1开始迭代器 // end1 容器1结束迭代器 // beg2 容器2开始迭代器 // end2 容器2结束迭代器 // dest 目标容器开始迭代器

#include <vector>
#include <algorithm>

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( 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;
}

总结：

• 求差集的两个集合必须的有序序列

• 目标容器开辟空间需要从两个容器取较大值

• set_difference返回值既是差集中最后一个元素的位置