STL——set容器、map容器

set容器/multiset容器

set容器——构造和赋值

set容器时关联式容器
所有的元素在插入时都会被排序
本质:
set/multiset属于关联式容器，底层结构是用二叉树实现。
set和multiset区别:
set不允许容器中有重复的元素. multiset允许容器中有重复的元素

在二叉搜索树中，通常不允许插入相同的数，因为二叉搜索树是一种有序的数据结构，相同的数会破坏它的有序性。如果插入相同的数，可能会导致搜索、删除等操作出现问题。但是在其他类型的二叉树中，比如普通的二叉树，是允许插入相同的数的。
C++ STL中的set容器是一种关联式容器，它的元素按照一定的排序规则自动排序。set容器的insert函数会将元素插入到容器中，并保持容器中元素的有序性。set容器的默认排序顺序是按照元素的升序进行排序，也就是从小到大的顺序

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;
#include 

//set容器构造和赋值

void printSet(set<int>&s1)
{
	for (set<int>::const_iterator it =s1.begin(); it != s1.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	set<int>s1;

	//插入数据 只有insert方式
	s1.insert(10);
	s1.insert(40);
	s1.insert(30);
	s1.insert(20);
	s1.insert(30);

	//遍历容器
	//set容器的特点:所有的元素插入的时候会自动被排序
	//set容器不允许插入重复的值
	printSet(s1);

	//拷贝构造
	set<int>s2(s1);
	printSet(s2);

	//赋值
	set<int>s3;
	s3 = s2;
	printSet(s3);;
}

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

set容器——大小和交换

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;
#include 

//set容器构造和赋值

void printSet(set<int>&s1)
{
	for (set<int>::const_iterator it = s1.begin(); it != s1.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	set<int>s1;

	//插入数据 只有insert方式
	s1.insert(10);
	s1.insert(40);
	s1.insert(30);
	s1.insert(20);
	s1.insert(30);

	printSet(s1);

	if (s1.empty())
	{
		cout << "s1为空" << endl;
	}
	else
	{
		cout << "s1不为空" << endl;
		cout << "s1的大小为:" << s1.size() << endl;
	}

	set<int>s2;

	//插入数据 只有insert方式
	s2.insert(66);
	s2.insert(11);
	s2.insert(33);
	s2.insert(22);

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

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

set容器——插入和删除

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;
#include 

//set容器插入和删除

void printSet(set<int>&s1)
{
	for (set<int>::const_iterator it = s1.begin(); it != s1.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	set<int>s1;

	//插入
	s1.insert(10);
	s1.insert(40);
	s1.insert(30);
	s1.insert(20);

	//遍历
	printSet(s1);
	
	//删除
	s1.erase(s1.begin());
	printSet(s1);//删除的是10

	//删除重载版本
	s1.erase(30);
	printSet(s1);

	//清空
	//s1.erase(s1.begin(), s1.end());
	s1.clear();
	printSet(s1);
}

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

set容器的查找和统计

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;
#include 

//set容器 查找和统计

void printSet(set<int>&s1)
{
	for (set<int>::const_iterator it = s1.begin(); it != s1.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	set<int>s1;

	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);

	set<int>::iterator pos = s1.find(30);
	if (pos!=s1.end())
	{
		cout << "找到元素: " << *pos << endl;
	}
	else
	{
		cout << "未找到元素" << endl;
	}

	printSet(s1);
}

void test02()
{
	set<int>s1;

	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	s1.insert(30);
	s1.insert(30);

	//统计30的个数
	int num = s1.count(30);
	//对于set而言  统计结果要么是1要么是0
	cout << "num= " << num << endl;
}

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

总结:
查找— find(返回的是迭代器)
统计— count(对于set，结果为0或者1)

set和multiset的区别

区别:
set不可以插入重复数据，而multiset可以
set插入数据的同时会返回插入结果，表示插入是否成功
multiset不会检测数据，因此可以插入重复数据
set和multiset都是STL中的关联容器，它们的主要区别在于元素的唯一性和插入操作的方式。
set中的元素是唯一的，即每个元素只能出现一次。当我们向set中插入一个已经存在的元素时，set会忽略这个插入操作。set中的元素按照一定的排序规则进行排序，这个排序规则可以通过自定义比较函数来指定。
multiset中的元素可以重复，即每个元素可以出现多次。当我们向multiset中插入一个已经存在的元素时，multiset会将这个元素插入到容器中。multiset中的元素同样按照一定的排序规则进行排序，这个排序规则也可以通过自定义比较函数来指定。
另外，set和multiset的插入操作方式也不同。set中的插入操作使用insert函数，而multiset中的插入操作使用insert或者emplace函数。insert函数会将元素插入到容器中，而emplace函数会在容器中直接构造元素。
综上所述，set适用于需要保证元素唯一性的场景，而multiset适用于需要允许元素重复的场景。

set的相关操作源码：

insert源码

insert源码的返回值：

multiset的相关操作源码

insert源码：

insert源码的返回值：是一个迭代器

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

void test01()
{
	set<int>s;

	pair<set<int>::iterator, bool>ret = s.insert(10);
	if (ret.second)
	{
		cout << "第一次插入成功" << endl;
	}
	else
	{
		cout << "第一次插入失败" << endl;
	}

	ret = s.insert(10);
	if (ret.second)
	{
		cout << "第一次插入成功" << endl;
	}
	else
	{
		cout << "第一次插入失败" << endl;
	}

	multiset<int>ms;
	//允许插入重复值
	ms.insert(10);
	ms.insert(10);
	
	for (multiset<int>::iterator it = ms.begin(); it != ms.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

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

multiset的insert函数会返回一个迭代器，指向插入的元素。如果插入成功，这个迭代器就是指向新插入的元素；如果插入失败，这个迭代器就是指向已经存在的元素。
因为multiset允许存储重复的元素，所以在插入元素时不需要检测是否已经存在相同的元素。如果已经存在相同的元素，插入操作会将新元素插入到已有元素的后面，因此不会影响multiset中已有元素的顺序。

pair使用——pair队组的创建

pair对组的作用：
pair对组通常用于将两个值组合在一起，以便更方便地进行处理。pair对组可以用于实现各种数据结构，例如哈希表、二叉搜索树等。在C++中，pair对组是一个标准库类型，可以用于将两个值组合在一起，并提供了一些方便的方法来访问这些值。例如，可以使用pair对组来表示一个坐标点，其中第一个值表示x坐标，第二个值表示y坐标。这样，可以将多个坐标点存储在一个vector或者其他容器中，并方便地进行访问和处理。

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//pair对组的创建
void test01()
{
	//第一种方式
	pair<string, int>p("Tom", 20);
	cout << "姓名: " << p.first << " 年龄: " << p.second << endl;

	//第二种方式
	pair<string, int>p2 = make_pair("Jerry", 30);
	cout << "姓名: " << p2.first << " 年龄: " << p2.second << endl;
}
int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

set容器——排序

set容器默认排序规则为从小到大，掌握如何改变排序规则
主要技术点:
用仿函数，可以改变排序规则

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;
#include 
//set容器排序

class MyCompare
{
public:
	bool operator()(int v1, int v2)const
	{
		return v1 > v2;
	}

};

void test01()
{
	//模板参数列表放的是数据类型
	//仿函数本质上是类型
	set<int,MyCompare>s1;

	s1.insert(10);
	s1.insert(40);
	s1.insert(20);
	s1.insert(50);
	s1.insert(30);

	for (set<int>::const_iterator it = s1.begin(); it != s1.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
	//指定排序规则  从大到小

	set<int>s2;

	s2.insert(10);
	s2.insert(40);
	s2.insert(20);
	s2.insert(50);
	s2.insert(30);
}

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

set容器——自定义数据类型

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;
#include 
#include 
//set容器排序
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	string m_Name;
	int m_Age;
};

class comparePerson
{
public:
	bool operator()(const Person&p1, const Person&p2)
	{
		//按照年龄 降序
		return p1.m_Age > p2.m_Age;
	}
};

void test01()
{
	//自定义数据类型 都会指定排序规则
	set<Person,comparePerson>s;

	Person p1("刘备", 24);
	Person p2("关羽", 28);
	Person p3("张飞", 25);
	Person p4("赵云", 21);

	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	s.insert(p4);

	for (set<Person,comparePerson>::iterator it =s.begin(); it != s.end(); it++)
	{
		cout << "姓名: " << it->m_Name << " 年龄: " << it->m_Age << endl;
	}
	cout << endl;
}

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

map容器

map容器——基本概念

简介:
map中所有元素都是pair
pair中第一个元素为key(键值)，起到索引作用，第二个元素为value(实值)
所有元素都会根据元素的键值自动排序
本质:
map/multimap属于关联式容器，底层结构是用二叉树实现。
优点:
可以根据key值快速找到value值
map和multimap区别：
map不允许容器中有重复key值元素. multimap允许容器中有重复key值元素
在C++ STL中，map容器的底层实现通常是红黑树。红黑树是一种自平衡的二叉搜索树，它能够保证在最坏情况下，插入、删除、查找操作的时间复杂度都是O(log n)。由于map容器需要支持快速的查找、插入、删除等操作，因此使用红黑树作为底层实现可以保证其高效性能。但是，具体实现可能因不同的编译器和操作系统而有所不同。

map容器——构造和赋值

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;
#include 

void printMap(map<int, int>&m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key= " << (*it).first << " value= " << it->second << endl;
	}
	cout << endl;
}

void test01()
{
	//模板写两个参数类型
	//第一个参数是key值起到了所有的作用
	//第二个参数value值起到了实值的作用

	//创建map容器
	map<int, int>m;

	//匿名的队组
	//默认的排序是按照key排序的
	//map容器插入重复的key插不进去
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(3, 20));
	m.insert(pair<int, int>(2, 30));
	m.insert(pair<int, int>(4, 40));

	printMap(m);

	//拷贝构造
	map<int, int>m2(m);
	printMap(m2);

	//赋值
	map<int, int>m3;
	m3 = m2;
	printMap(m3);
}

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

总结: map中所有元素都是成对出现，插入数据时候要使用对组

map容器——大小和交换

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;
#include 

void printMap(map<int, int>&m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key= " << (*it).first << " value= " << it->second << endl;
	}
	cout << endl;
}

void test01()
{
	map<int, int>m;

	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));
	printMap(m);

	if (m.empty())
	{
		cout << "m为空" << endl;
	}
	else
	{
		cout << "m不为空" << endl;
		cout << "m的大下" << m.size() << endl;
	}
}

void test02()
{
	map<int, int>m1;
	m1.insert(pair<int, int>(1, 10));
	m1.insert(pair<int, int>(2, 20));
	m1.insert(pair<int, int>(3, 30));

	map<int, int>m2;
	m2.insert(pair<int, int>(4, 100));
	m2.insert(pair<int, int>(5, 200));
	m2.insert(pair<int, int>(6, 300));

	cout << "交换前: " << endl;
	printMap(m1);
	printMap(m2);

	m1.swap(m2);
	cout << "交换后: " << endl;
	printMap(m1);
	printMap(m2);
}

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

map容器——插入和删除

map容器插入 m[4] = 40的缺点主要有以下几点：
1.可能会覆盖原有的键值对：如果map中已经存在键为4的键值对，那么插入m[4] = 40会覆盖原有的值，导致数据丢失。
2.可能会导致迭代器失效：插入新的键值对可能会导致原有的迭代器失效，因为插入操作可能会导致内存重新分配，从而使原有的迭代器指向的内存地址失效。
3.可能会导致性能下降：插入新的键值对可能会导致map内部的红黑树结构发生变化，从而导致性能下降。特别是如果插入的键值对数量较多，可能会导致树的高度增加，从而使查找、插入、删除等操作的时间复杂度增加。
因此，在插入新的键值对时，应该先判断map中是否已经存在相同的键，如果存在，则可以选择更新原有的值，或者放弃插入操作；如果不存在，则可以使用insert()函数插入新的键值对，这样可以避免上述问题。

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

//map容器  插入和删除
void printMap(map<int, int>&m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key= " << (*it).first << " value= " << it->second << endl;
	}
	cout << endl;
}

void test01()
{
	map<int, int>m;

	//插入
	//第一种
	m.insert(pair<int, int>(1, 10));

	//第二种
	m.insert(make_pair(2, 20));

	//第三种
	//map容器下面的值类型
	m.insert(map<int, int>::value_type(3, 30));

	//第四种
	m[4] = 40;

	printMap(m);
	//第四种插入的缺点:
	//[]不建议插入，用途：可以利用key访问到value
	//cout << m[5] << endl;

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

	//重载版本的删除
	m.erase(3);//按照key删除 不是按照value来删除的
	printMap(m);

	//按照区间来删除
	m.erase(m.begin(),m.end());
	printMap(m);

	//清空
	m.clear();
	printMap(m);
}

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

map容器——查找和统计

#define _CRT_SECURE_NO_WARNINGS
#include 
using namespace std;
#include 

void printMap(map<int, int>&m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key= " << (*it).first << " value= " << it->second << endl;
	}
	cout << endl;
}

void test01()
{
	map<int, int>m;

	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));
	printMap(m);

	if (m.empty())
	{
		cout << "m为空" << endl;
	}
	else
	{
		cout << "m不为空" << endl;
		cout << "m的大下" << m.size() << endl;
	}
}

void test02()
{
	map<int, int>m1;
	m1.insert(pair<int, int>(1, 10));
	m1.insert(pair<int, int>(2, 20));
	m1.insert(pair<int, int>(3, 30));

	map<int, int>m2;
	m2.insert(pair<int, int>(4, 100));
	m2.insert(pair<int, int>(5, 200));
	m2.insert(pair<int, int>(6, 300));

	cout << "交换前: " << endl;
	printMap(m1);
	printMap(m2);

	m1.swap(m2);
	cout << "交换后: " << endl;
	printMap(m1);
	printMap(m2);
}

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

总结:
查找— find(返回的是迭代器)
统计— count(对于map，结果为0或者1)

map容器——排序

map容器默认排序规则为按照key值进行从小到大排序
接下来利用仿函数，可以改变排序规则

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
using namespace std;

class MyCompare
{
public:
	bool operator()(int v1,int v2)const
	{
		//降序
		return v1 > v2;
	}
};

//map容器 排序
void test01()
{
	//统计
	map<int, int,MyCompare>m;
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));
	m.insert(pair<int, int>(4, 40));
	m.insert(pair<int, int>(5, 50));

	for (map<int, int,MyCompare>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key= " << (*it).first << " value= " << it->second << endl;
	}
}

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

STL——案例

员工分组

公司今天招聘了10个员工(ABCDEFGHI)，10名员工进入公司之后，需要指派员工在那个部门工作
员工信息有:姓名工资组成;部门分为:策划、美术、研发
随机给10名员工分配部门和工资
通过multimap进行信息的插入key(部门编号) value(员工)
分部门显示员工信息
1.创建10名员工，放到vector中
2.遍历vector容器，取出每个员工，进行随机分组
3.分组后，将员工部门编号作为key，具体员工作为value，放入到multimap容器中
4.分部门显示员工信息

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 
#include 
using namespace std;
#define CEHUA 0
#define MEISHU 1
#define YANFA 2

class Worker
{
public:
	string m_Name;
	int m_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.m_Salary = rand() % 10001 + 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 deptId = rand() % 3;//0 1 2
		//将员工插入到分组中
		//key部门编号，value具体员工
		m.insert(make_pair(deptId, *it));
	}
}

void showWorkerByGroup(multimap<int,Worker>&m)
{
	//0  A  B  C  1  D  E  2  F  G
	cout << "策划部门: " << endl;
	multimap<int, Worker>::iterator pos = m.find(CEHUA);
	int count = m.count(CEHUA);//统计策划部门具体人数
	int index = 0;
	for (; pos != m.end() && index < count; pos++, index++)
	{
		cout << "姓名: " << pos->second.m_Name << " 工资 " << pos->second.m_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.m_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.m_Salary << endl;
	}
}

int main()
{
	srand((unsigned int)time(NULL));
	//1、创建员工
	vector<Worker>vWorker;
	createWorker(vWorker);

	//2、员工分组
	multimap<int, Worker>mWorker;
	setGroup(vWorker, mWorker);
	
	测试
	//for (vector::iterator it = vWorker.begin(); it != vWorker.end(); it++)
	//{
	//	cout << "姓名: " << it->m_Name << " 工资: " << it->m_Salary << endl;
	//}

	//3、分组显示员工
	showWorkerByGroup(mWorker);
	system("pause");
	return EXIT_SUCCESS;
}