【C++STL详解（十一）】map/set/multimap/multiset的介绍与使用

一、关联式容器

二、键值对

三、set

介绍

简单使用

1.构造

2.相关迭代器

3.容量

4.修改

四、multiset

五、map

介绍

使用

1.定义的方式

2.迭代器相关

3.容量与operator【】(重点)

4.修改

小总结：

六、multimap

一、关联式容器

在C++STL中实际上存在结构的容器，分别为序列式容器和关联式容器。

序列式容器：仅仅只是单纯的进行数据存储，数据与数据之间没有任何关联。如：vector、list、stack等等
关联式容器：不仅仅是存储数据，数据和数据之间的关联性很强，因为其底层实际上存的是<Key,Value>结构的键值对，所以数据检索的效率要比序列式容器要高。

而STL中关联式容器有两种结构：树形结构和哈希结构。

树形结构：底层就是红黑树结构，如set/map/multi_set/multi_map

哈希结构：底层就是哈希表，如unordered_set/unordered_map等(后续介绍)

二、键值对

实际上就是一种一一对应的关系的结构，一个关键字都有一个对应的值，该结构中有两个成员变量，即Key和Value，Key代表关键字(键值)，Value表示与Key对应的信息。

比如：英汉字典，英文和中文都有一一对应的关系。

结构可如下所示：

template<class T1,class T2>
struct pair
{
	typedef T1 first_type;
	typedef T2 second_type;

	//成员变量
	first_type first;
	second_type second;

	//构造
	pair()
		:first(first_type())
		,second(second_type())
	{}
};

三、set

介绍

set 是按照一定次序存储元素的容器，有序序列
在 set 中，元素的 value 也标识它 (value 就是 key ，类型为 T) ，并且每个 value 必须是唯一的set中的元素不能在容器中修改 (元素总是const) ，但是可以从容器中插入或删除它们。

为何不能修改呢?就是因为其底层是红黑树，二叉搜索树，这棵树的结构是通过Key建立起来的，如若修改，那这棵红黑树的结构就乱了！

set 容器通过 key 访问单个元素的速度通常比 unordered_set 容器慢，但它们允许根据顺序对

子集进行直接迭代。

注意：

set只放value，但底层实际是<value,value>的键值对，也就是个K模型的红黑树
set插入元素时，只需插入value即可，如insert(3)
set可以去重，也就是不允许数据冗余
中序遍历得到的结果就是一个有序序列，默认是升序序列，因为底层是二叉平衡搜索树(红黑树)
在使用set需要包含头文件set

简单使用

T：元素的类型。实际底层就是<value，value>的键值对

Compare：仿函数，默认升序

Alloc：空间配置器

1.构造

set<int> s;//无参构造

set<int> s1={3,6,1,2,2};//初始化列表

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

string st = "asdasdsad";
set<char> s3(st.begin(), st.end());//迭代器区间构造

set<int, greater<int>> s4;//自定义仿函数

2.相关迭代器

iterator begin()	返回起始位置元素的迭代器
iterator end()	返回最后元素下一个位置的迭代器
reverse_iterator rbegin()	返回起始位置的反向迭代器
reverse_iterator rend()	返回最后元素下一个位置的反向迭代器

举例

set<int> s = { 3,6,1,2,2 };
set<int>::iterator it = s.begin();
while (it != s.end())
{
	cout << *it << " ";
	it++;
}//1,2,3,6



set<int> s1 = { 3,6,1,2,2 };
set<int>::reverse_iterator it = s1.rbegin();
while (it != s1.rend())
{
	cout << *it << " ";
	it++;
}//6,3,2,1

3.容量

size()	返回有效元素个数
empty()	判空，空为true，不空为false

s.size();
s.empty();

4.修改

pair<iterator,bool> insert(const value _type& x)	插入数据x,实际上插入的是<x,x>键值对，返回的是pair对象，插入成功返回<该元素新插入位置，true>，若失败，说明已存在，返回<该元素的位置，false>
erase	删除数据
swap	交换两个set中的数据
clear	清空set的数据
find(x)	返回x在set中的位置，返回类型为迭代器
count(x)	返回set中值为x的数据个数

示例：

	set<int> s;
	s.insert(2);
	s.insert(1);
	s.insert(1);
	s.insert(3);
	s.insert(4);


	set<int>::iterator it=s.find(2);//查找一般配合插入删除操作
	s.insert(it, 6);//在指定位置前插入数据,但是打印出来的结果还是有序的。也看不出来，没啥意义

	cout << endl;

	s.erase(6);

	set<int> s1;
	s1.swap(s);//交换

	cout << s.count(1) << endl;//这个没什么意义，因为set去重的，存在的元素的个数都是1，不存在就是0            
            //1

四、multiset

这个在使用上和set没啥区别，和set的最大区别就是multiset不可以去重，允许数据冗余！仅此而已！这里就不重复给出常用接口了，详情请看set

注意：使用它时头文件也是set

使用实例：

	multiset<int> s;//无参构造

	multiset<int> s1 = { 3,6,1,2,2 };//初始化列表

	multiset<int> s2(s);//拷贝构造

	string st = "asdasdsad";
	multiset<char> s3(st.begin(), st.end());//迭代器区间构造

	multiset<int, greater<int>> s4;//自定义仿函数

	s.insert(2);
	s.insert(2);
	s.insert(1);
	s.insert(1);
	s.insert(3);
	s.insert(4);

	for (auto a : s)
	{
		cout << a << " ";//这里的结果为1 1 2 3 4
	}
	cout << endl;
	multiset<int>::iterator it = s.find(2);
	s.insert(it, 6);
	for (auto a : s)
	{
		cout << a << " ";
	}
	cout << endl;

	s.erase(6);
	cout << s.count(2) << endl;//这个函数在这里有意义，能够统计容器中值为value的个数，因为该容器不去重

值得一提的是：multiset中的find和set有点不一样，因为multiset不去重，所以可能会存在一个元素出现多次的情况，那么find返回的是中序遍历的第一个值的位置。

为什么插入在左边和右边都一样呢？因为它底层是红黑树，二叉搜索树，要保持平衡，所以需要旋转处理，旋转后都一样，原本插入在右边的，旋转过后可能又回到左边！

五、map

介绍

map是关联式容器，它的每一个元素都是一对键值对，也就是pair。底层是KV模型红黑树
map中，键值Key用于排序和唯一标识的元素，而值value中存储与对应的Key相关联的内容
键值Key和值Value类型可能不同，两者内部通过value_type绑定，别名为pair。

value_type原型：

typedef pair<const K,V> value_type

可以看出Key一定不能修改的，唯一标识！

map支持下标访问，即重载了operator[]，在【】中放入Key，就能找到相应的value。
默认升序，从小到大排，先比键值Key，Key一样比Value。

使用

1.定义的方式

	map<string, int> m1;//构造一个Key类型为string，value类型为int的空容器

	map<string, int> m2(m1);//拷贝构造

	map<string, int> m3(m2.begin(), m2.end());//迭代器区间构造

	map<string, int, greater<int>> m4;//指定比较方式的构造

2.迭代器相关

iterator begin()	返回起始位置元素的迭代器
iterator end()	返回最后元素下一个位置的迭代器
reverse_iterator rbegin()	返回起始位置的反向迭代器
reverse_iterator rend()	返回最后元素下一个位置的反向迭代器
const_iterator cbegin()+cend()	操作和begin，end一样，区别就是cbegin+cend指向元素不能修改，因为是const

	m4.begin();
	m4.end();

3.容量与operator【】(重点)

empty	判空
size	有效元素个数
operator【Key】	返回的是key对应的value的引用

值得一提的是operator【】，这个的原型如下：

调用这个函数等价于：

可以看到，它等价于调用insert函数，如何理解上面这段等价关系呢？先来解读一下insert函数

这段话的含义就是：

Key存在，插入失败，返回->pair<Key所在位置的迭代器,false>
Key不存在，插入成功,返回->pair<Key新插入位置的迭代器,true>

也就是说不管插入是否成功，最终都会返回Key所在位置的迭代器。即pair中的iterator始终都指向Key所在的位置。插入成功与否主要看false和true，即pair中的bool

所以等价拆分就是：

V& operator[](const Key& k)
{
	pair<iterator, bool> ret = insert(make_pair(K, V()));
	iterator it = ret.first;
	return it->second;
}

所以实际上operator[]功能十分强大，不仅能查找，当Key不存在时，还能插入，同时因为它返回的是value的引用，还能够修改value的值。

	map<string, int> m;
	m.insert({ "string",1 });
	//Key不存在就插入
	m["好的"];

	//修改
	m["好的"]++;

	//插入+修改
	m["你好"]++;

	//查找
	cout << m["string"] << endl;

实际上，map中的operator【】实际中用得十分的普遍，比如最常见的统计次数等等

注意区分这里operator[]和vector等序列式容器的区别，vector是下标访问，这里是键值Key！

4.修改

pair<iterator,bool> insert(const value _type& x)	插入数据
erase	删除数据
swap	交换两个map的数据
clear	清空的数据
find(x)	返回x在map中位置的迭代器，找到则返回迭代器，否则返回end()。x为key
count(x)	返回Key为x的键值在map中的个数，注意map中Key是唯一的，返回值要么是0，要么是1。

使用举例：

一定要注意insert插入数据的写法，map中每一个元素都是一个pair，即键值对。

	map<string, string> m;

	//插入写法一：有名对象
	pair<string, string> kv("string", "字符串");
	m.insert(kv);

	//写法二：匿名对象
	m.insert(pair<string, string>("left", "左边"));

	//写法三：使用make_pair函数来构造键值对
	m.insert(make_pair("right", "右边"));

	//写法四：隐式类型转化，常用写法
	m.insert({ "love","爱" });//注意是大括号括起来

	//遍历写法一:迭代器
	//map<string, string>::iterator it = m.begin();
	auto it = m.begin();
	while (it != m.end())
	{
		//cout << (*it).first << " :" << (*it).second << endl;
		cout << it->first<< " :" << it->second << endl;
		it++;
	}

	//遍历写法二：范围for
	for (auto a : m)
	{
		cout << a.first << " :" << a.second << endl;//可以理解为从结构体中取出变量，a就是一个pair
	}
	cout << endl;
	map<string, string> m1;
	m1.swap(m);
	auto it1 = m1.find("love");
	if (it1 != m1.end())
	{
		m1.erase(it);
	}

	m1.count("love");
	m1.clear();

小总结：

map的元素是键值对，kv模型的红黑树
key唯一不能修改
默认升序，按键值key比较大小，key同再比value
支持operator【】，实际用得多

六、multimap

同样和map操作上也没区别，唯一的区别就是：map的key是唯一的，multimap的key可以是重复的。允许数据冗余。

实例：

	multimap<string, string> m;

	//插入写法一：有名对象
	pair<string, string> kv("string", "字符串");
	m.insert(kv);

	//写法二：匿名对象
	m.insert(pair<string, string>("left", "左边"));

	//写法三：使用make_pair函数来构造键值对
	m.insert(make_pair("right", "右边"));

	//写法四：隐式类型转化，常用写法
	m.insert({ "love","爱" });//注意是大括号括起来

	//遍历写法一:迭代器
	//multimap<string, string>::iterator it = m.begin();
	auto it = m.begin();
	while (it != m.end())
	{
		//cout << (*it).first << " :" << (*it).second << endl;
		cout << it->first << " :" << it->second << endl;
		it++;
	}

	//遍历写法二：范围for
	for (auto a : m)
	{
		cout << a.first << " :" << a.second << endl;//可以理解为从结构体中取出变量，a就是一个pair
	}
	cout << endl;
	multimap<string, string> m1;
	m1.swap(m);
	//auto it1 = m1.find("love");
	//if (it1 != m1.end())
	//{
	//	m1.erase(it);
	//}

	m1.count("love");
	m1.clear();
}

注意：

①multimap的insert是这样的：