一：set容器

1.1: set容器的构造和赋值

简介：所有元素都会在插入时自动被排序

本质：set/multiset 属于关联式容器，底层结构是二叉树实现

set与multiset区别：

set: 不允许容器中有重复元素

multiset ：允许容器中有重复元素

构造函数：

功能：创建set容器以及赋值

构造：set<T> set // 默然构造函数

set(const set& set) // 拷贝构造函数

赋值：

set& operator=(const set& set) // 重载等号操作符

1.2：set大小和交换

功能描述：统计set容器大小以及交换set容器，不允许resize

函数原型：

size() //返回容器中元素的数目

empty() // 判断容器是否为空

swap(set) // 交换两个集合容器

void fun1(){
	set<int> s1;
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);
	s1.insert(40);

	cout << "s1 的大小为：" << s1.size() << endl;

	set<int> s2;
	s2.insert(100);
	s2.insert(200);
	s2.insert(300);
	s2.insert(400);
	cout << "交换前：" << endl;
	printSet(s1);
	printSet(s2);

	cout << "交换后：" << endl;
	s1.swap(s2);
	printSet(s1);
	printSet(s2);
}

1.3：set插入和删除

功能描述：set容器进行插入数据和删除数据

函数原型

insert(elem) // 在容器中插入元素

clear() // 清除所有元素

erase(pos) // 删除pos迭代器所知的元素，并返回下一个元素的迭代器

erase(beg,end) // 删除区间【beg，end】的所有元素，返回一个元素的迭代器

erase(elem) // 删除容器中elem的元素

// 插入和删除
void fun2() {
	set<int> s1;
	// 插入
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);
	s1.insert(40);
	s1.insert(50);
	printSet(s1);

	// 删除
	s1.erase(s1.begin());
	printSet(s1);
	
	s1.erase(50);
	printSet(s1);

	s1.clear();
}

1.4：set查找和统计

功能描述：对set容器进行查找数据以及统计数据

函数原型：

find(key) // 查找key是否存在，若存在，返回该键的元素迭代器，

若不存在，返回set.end() 迭代器

count(key) // 统计key元素个数。

void fun3() {
	set<int> s1;
	// 插入
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);
	s1.insert(30);
	s1.insert(50);
	
	// 查找
	set<int>::iterator pos = s1.find(30);
	if (pos != s1.end())
	{
		cout << "找到了元素：" << *pos << endl;
	}
	else
	{
		cout << "未找到元素" << endl;
	}

	// 统计
	int num = s1.count(30);
	cout << "num = " << num << endl;
}

1.5 ：set和multiset区别

学习目标：掌握 set 和 multiset区别

区别：

1：set不可以插入重复数据，而 multiset 可以

2：set插入数据的同时会返回插入结果，表示是否插入成功

3：multiset不会检查数据，因此可以插入重复数据

void fun4() {
	set<int> s1;
	// pair 可以看成是一个对组，里面包含两个元素，第一个是迭代器，返回元素插入的位置，第二个是 bool类型变量，代表是否插入成功
	pair<set<int>::iterator, bool> ret = s1.insert(10);
	if (ret.second)
	{
		cout << "第一次 插入成功" << endl;
	}
	else
	{
		cout << "第二次插入失败" << endl;
	}
	ret = s1.insert(10);
	if (ret.second) {
		cout << "第二次插入成功" << endl;
	}
	else
	{
		cout << "第二次插入失败" << endl;
	}
}

void fun4() {
	set<int> s1;
	// pair 可以看成是一个对组，里面包含两个元素，第一个是迭代器，返回元素插入的位置，第二个是 bool类型变量，代表是否插入成功
	pair<set<int>::iterator, bool> ret = s1.insert(10);
	if (ret.second)
	{
		cout << "第一次 插入成功" << endl;
	}
	else
	{
		cout << "第二次插入失败" << endl;
	}
	ret = s1.insert(10);
	if (ret.second) {
		cout << "第二次插入成功" << endl;
	}
	else
	{
		cout << "第二次插入失败" << endl;
	}

	multiset<int> ms;
	ms.insert(10);
	ms.insert(10);
	cout << endl;
	for (multiset<int>::iterator it = ms.begin(); it != ms.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

1.6：set容器排序

学习目标：set容器默认的排序规则为从小到大（升序排序），我们需要掌握如何改变排序规则

主要技术点：利用仿函数，可以改变排序规则

class MyCompare {
public:
	// C++要求'='、'[]'、'()'、'->'操作符必须被定义为类的成员操作符
	// 利用仿函数实现 排序，这是 C++  STL中一个非常重要的技术
	bool operator()(int v1, int v2) {
		// 降序排序
		return v1 > v2;
	}
};

void fun5() {
	set<int> s1;
	// 插入
	s1.insert(10);
	s1.insert(90);
	s1.insert(30);
	s1.insert(70);
	s1.insert(50);
	// 从小到大排序
	printSet(s1);

	set<int, MyCompare> s2;
	s2.insert(10);
	s2.insert(90);
	s2.insert(30);
	s2.insert(70);
	s2.insert(50);

	for (set<int,MyCompare>::iterator it = s2.begin(); it != s2.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
	
}

可以看到是可以通过 myCompare 的仿函数实现，降序排列的

二：map/multimap 容器

2.1：map构造函数和赋值

简介：

1：map中所有元素都是 pair

2: pair中第一个元素为 key(健值)，起到索引作用，第二个元素为value（实值）

3：所有元素都会根据元素的健值自动排序（从小到大）

本质上：

map/ multimap 属于关联式容器，底层结构是用二叉树实现

优点：

可以根据key值快速找到 value值

map和multimap的区别：

1：map不允许容器中有重复key值元素

2：multimap允许容器中有重复key值元素

void func6() {
	map<int, int> mp;
	mp.insert(pair<int, int>(1,10));
	mp.insert(pair<int, int>(3,10));
	mp.insert(pair<int, int>(1,10));
	mp.insert(pair<int, int>(1,10));
	printMap(mp);

	// 拷贝构造函数
	map<int, int>mp2(mp);
	printMap(mp2);

	// 重载等号操作符
	map<int, int>mp3 = mp;
}

2.2：map大小和交换

功能描述：统计 map容器大小以及交换 map容器

函数原型：

size() // 返回容器中元素的数目

empty() // 判断容器是否为空

swap(st) // 交换两个集合容器

void func6() {
	map<int, int> mp;
	mp.insert(pair<int, int>(1,10));
	mp.insert(pair<int, int>(3,10));
	mp.insert(pair<int, int>(1,10));
	mp.insert(pair<int, int>(1,10));
	printMap(mp);

	// 拷贝构造函数
	map<int, int>mp2(mp);
	printMap(mp2);

	// 重载等号操作符
	map<int, int>mp3 = mp;
	printMap(mp3);

	cout << "mp的大小为： " << mp.size() << endl;
	map<int, int> mp4;
	mp4.insert(pair<int, int>(1, 23));
	mp4.insert(pair<int, int>(3, 56));
	mp4.insert(pair<int, int>(1, 4));
	mp4.insert(pair<int, int>(1, 78));

	cout << "交换前： " << endl;
	printMap(mp);
	printMap(mp4);
	mp.swap(mp4);
	cout << "交换后： " << endl;
	printMap(mp);
	printMap(mp4);
}

2.3：map插入和删除

功能描述：map容器进行插入数据和删除数据

函数原型：

insert(elem) // 在容器中插入元素

clear() // 清楚所有元素

erase(pos) // 删除pos迭代器所指的元素，返回下一个元素的迭代器

erase(beg，end) // 删除区间【beg，end】的所有元素，返回下一个圆的迭代器

erase(key) // 删除容器中值为key 的元素

void func7() {
	map<int, int> mp;
	// 插入
	mp.insert(pair<int, int>(1, 10));
	mp.insert(make_pair(2, 3));
	mp.insert(map<int, int>::value_type(3, 30));
	printMap(mp);

	// 删除
	mp.erase(mp.begin());
	printMap(mp);

	// 删除健值为2的 pair
	mp.erase(2);
	printMap(mp);
}

2.4：map查找和统计

功能描述：对map容器进行查找数据以及统计数据

函数原型：

find(key) // 查找key是否存在，若存在，返回该键的元素迭代器，若不存在返回 map.end()

count(key) // 统计key的元素个数。

void func8() {
	map<int, int> mp;
	// 插入
	mp.insert(pair<int, int>(1, 10));
	mp.insert(make_pair(2, 3));
	mp.insert(map<int, int>::value_type(3, 30));
	
	map<int, int>::iterator pos = mp.find(3);
	if (pos != mp.end())
	{
		cout << "找到元素 key = " << pos->first << "  value = " << pos->second << endl;
	}
	else
	{
		cout << "未找到元素" << endl;
	}

	int num = mp.count(2);
	cout << "num =" << num << endl;
}

2.5 ：map容器排序

学习目标

map容器默认排序规则按照 key 值进行从小到大排序，需要掌握如何改变排序规则。

主要技术点：利用仿函数，可以改变排序规则。

class myCompartor {
public:
	bool operator()(int a,int b){
		// 降序排序
		return a > b;
	}
};

void func9() {
	map<int, int> mp;
	mp.insert(pair<int, int>(1, 10));
	mp.insert(pair<int, int>(2, 45));
	mp.insert(pair<int, int>(89, 4));
	mp.insert(pair<int, int>(4, 67));
	mp.insert(pair<int, int>(56, 10));
	mp.insert(pair<int, int>(34, 10));
	for (map<int,int,myCompartor>::iterator it= mp.begin(); it != mp.end(); it++)
	{
		cout << "key = " << (*it).first << " value = " << it->second << endl;
	}
}

2.6：STL案例：员工分组

案例描述：

1：公司今天招聘10个员工（ABCDEFGHIJ），这10名员工进入公司之后，需要指派员工在哪个部门工作

2：员工信息有：姓名，工资组成，部门分为：策划，美术，研发

3：随机给10名员工分配部门和工资

4：通过 multimap 进行信息的插入（key 部门，value员工）

5：分部门显示员工新信息

实现步骤：

1：创建10名员工，放到vector中

2：变量vector容器，取出每个员工，进行随机分组

3：分组后将员工部门编号作为key , 具体员工作为 value 放到 multimap容器中

4：分部门显示员工信息

class Worker
{
public:
	string m_Name;
	int s_Salary;
};

void createWorker(vector<Worker>& v) {
	string nameSeed = "ABCDEFGHIJ";
	for (int i = 0; i < 10; i++)
	{
		Worker worker;
		worker.m_Name = "员工";
		worker.m_Name += nameSeed[i];
		worker.s_Salary = rand() % 10000 + 10000;
		v.push_back(worker);
	}
}

void setGroup(vector<Worker>& v, multimap<int, Worker>& m) {
	for (vector<Worker>::iterator it = v.begin(); it != v.end(); it++)
	{
		int deepId = rand() % 3;
		m.insert(make_pair(deepId, *it));
	}
}

void showWorkerByGroup(multimap<int, Worker>& m) {
	cout << "策划部门：" << endl;
	multimap<int, Worker>::iterator pos = m.find(CEHUA);
	// multimap 可以存储重复的 key值，所以 count 表示：部门的员工数
	int count = m.count(CEHUA);
	int index = 0;

	for (; pos != m.end() && index < count ; pos++,index++)
	{
		cout << "姓名：" << pos->second.m_Name << " 工资：" << pos->second.s_Salary << endl;
	}

	cout << "========================" << endl;
	cout << "美术部门：" << endl;
	pos = m.find(MEISHU);
	count = m.count(MEISHU);
	index = 0;
	for (; pos!=m.end() && index<count ; pos++,index ++)
	{
		cout << "姓名：" << pos->second.m_Name << " 工资：" << pos->second.s_Salary << endl;
	}


	cout << "========================" << endl;
	cout << "研发部门：" << endl;
	pos = m.find(YANFA);
	count = m.count(YANFA);
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++)
	{
		cout << "姓名：" << pos->second.m_Name << " 工资：" << pos->second.s_Salary << endl;
	}
}

void func10(){
	vector<Worker> vWorker;
	createWorker(vWorker);
	multimap<int, Worker> mWorker;
	setGroup(vWorker, mWorker);
	showWorkerByGroup(mWorker);
}

int main() {
	func10();
}