STL的常见算法（黑马视频）

会用到的三个头文件：
#include  
#include
#include

遍历算法：
1、 for_each()             头文件：#include
功能：遍历整个容器
形式：for_each(v.begin(), v.end(), printinfo)

 printinfo可以是普通函数也可以是函数对象  例如：

//普通函数
void print01(int val)
{
	cout << val << " ";
}
//函数对象
class print02
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

2、transform           头文件：#include
功能：搬运一个容器到另一个容器中
形式：  transform(v.begin(), v.end(), vTarget.begin(), TransForm());
transform(源容器起始迭代器, 源容器结束迭代器,目标容器起始迭代器, 函数对象);

注意：一个容器的内容往另一个容器中搬，目标容器得开辟一块地来存放
vTarget.resize(v.size());
目标容器名.resize(原容器名.size()); // 目标容器开辟一块和源容器一样大小的地

查找算法：
1、find           头文件：#include
功能：查找指定元素  注意返回的是找到的地址，没找到则是end（）
形式：vector::iterator it = find(v.begin(), v.end(), p2);
vector::iterator it = find(容器起始迭代器, 容器结束迭代器, 找的具体内容);

2、find_if           头文件：#include
功能：按照条件去查找
形式： vector::iterator it = find_if(v.begin(), v.end(), 仿函数形式的条件);

注意：返回的依旧是一个迭代器

3、adjacent_find           头文件：#include
功能：查找相邻重复的元素
形式：vector::iterator it = adjacent_find(v.begin(), v.end());

注意：找到返回的相当于是元素的地址，没找到就返回一个v.end()

4、binary_search           头文件：#include
功能：二分法方式去查找元素是否存在
形式：bool ret = binary_search(v.begin(), v.end(), 要找的具体内容);
注意：返回的是一个bool值哦，并且二分法不是不断的取中间判别嘛，所以，只能是有序序列才能用哦

5、count           头文件：#include
功能：统计元素的个数
格式：int num = count(v.begin(), v.end(), 要统计的内容);
注意：自定义类型的数据，要配合重载"operator=="
    (理解：统计个数，是不是就是判别当前内容和指定内容相同与否再计数的过程，自定义类型数据，你得告诉它，什么情况是相同的的吧)
例如：

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

6、count_if           头文件：#include
功能：按照条件查找   
形式：int num = count_if(v.begin(), v.end(), Greater4());
注：按照条件查找就count_if 按照值查找就count，其他都一样

排序算法：
1、sort           头文件：#include
功能：对容器中的元素进行排序
形式：sort(v.begin(), v.end());//由小到大
sort(v.begin(), v.end(), greater());  //由大到小

注意：将数据排序拍好以后，还是在那个容器里哦，

2、random_shuffle      头文件：#include
功能：将容器中的元素顺序打乱（洗个牌）
形式：random_shuffle(v.begin(), v.end());
注意：为了更加随机可以运用时间做随机数种子
#include   //要用时间别忘了头文件哦
srand((unsigned int)time(NULL));//种子

3、merge           头文件：#include
功能：两个容器的元素合并在一起，存到另一个容器
形式：merge(v1.begin(), v1.end(), v2.begin(), v2.end(), 目标容器的起始迭代器);

注意：在合并以前，先创建一个容器，并给它赋予空间
        要合并的两个容器必须同为升序或者同为降序的有序序列

4、reverse           头文件：#include
功能：将容器中的元素进行反转
形式：reverse(v.begin(), v.end())

拷贝和替换算法：
1、copy           头文件：#include
功能：将指定范围中的元素拷贝到另一个容器中
形式：copy(v1.begin(), v1.end(), v2.begin());
注意：记得给新容器开块地

2、replace           头文件：#include
功能：将指定范围中的旧元素改为新元素
形式：replace(其实迭代器,结束迭代器, 原元素, 新元素);
        replace(v.begin(), v.end(), 20, 2000);
注意：会替换所有满足条件的数据哦

3、replace_if           头文件：#include
功能：按照条件替换，将满足条件的替换为指定元素
形式：replace_if(v.begin(), v.end(), 条件(一个仿函数),新元素);

4、swap           头文件：#include
功能：互换两个容器的元素
形式：swap(v1, v2)
注意：要交换的两个容器中的内容数据类型得相同

算术生成算法：头文件：#include

***** 1、accumulate    头文件：#include
功能：计算容器中的元素累加和
形式：int total = accumulate(v.begin(), v.end(), 0);  //第三个是起始累加值
注意：返回的是一个值，
    如果只是想知道容器中本来的和，最后一个项就是0，
    如果是在x的基础上累加上当前容器的总和，那最后一项就是x

2、fill             头文件：#include
功能：向容器中填充指定的元素
形式：fill(v.begin(), v.end(), 想填充的指定内容);

常用集合算法
1、set_intersection      头文件：#include
功能：交集（两个集合重合部分）v1&v2
形式：vector::iterator itEnd =set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
注意：它返回的是新容器的最后一个元素的迭代器地址
        求交集的两个集合必须是有序的序列
        要建立一个新容器并且给容器开块合适的地（两个几个的重叠部分，最大不超过原两个容器小的那个容器吧）
        这样建立的容器，容量会大于等于这个交集的大小，所以对于没赋值的位置默认放的是0，
        在查询新容器中的内容的时候，注意结束的地方要是得到的最后一个元素的迭代器地址
结合例子理解：

vector vTarget;//建立一个新的空间
vTarget.resize(min(v1.size(), v2.size())); //取两个里面较小的值给目标容器开辟空间
vector::iterator itEnd =
set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());//返回目标容器的最后一个元素的迭代器地址
//查询新容器中的内容
for_each(vTarget.begin(), itEnd, myPrint()); //只查询交集内容，所以结束使用的是：返回的最后一个元素的迭代器地址

2、set_union      头文件：#include
功能：并集（两个集合的和）  v1|v2
形式：vector::iterator itEnd =
set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

注意：返回的结果是新容器最后一个元素的迭代器
      求并集的两个集合要是有序序列
      两个集合的并集，并集空间需要最大的情况就是两个完全不重叠，所以size是两个之和

3、set_difference      头文件：#include
功能：差集  （自己独一无二的内容）  v1-(v1&v2)   v2-(v1&v2)
形式：vector::iterator itEnd =set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
注意：它返回的是新容器的最后一个元素的迭代器地址
      求差集的两个集合必须是有序的序列
      只保留自己独一无二的，所以大小不会超过自己本身，所以新容器开辟的空间应该是两个中最大的容器的大小