【C++】map和set的使用_linux c+

set 的特点：

1. 与map/multimap不同，map/multimap中存储的是真正的键值对<key, value>，set中只放value，但在底层实际存放的是由<value, value>构成的键值对。
2. set中插入元素时，只需要插入value即可，不需要构造键值对。
3. set中的元素不可以重复(因此可以使用set进行去重)。
4. 使用set的迭代器遍历set中的元素，可以得到有序序列
5. set中的元素默认按照小于来比较
6. set中查找某个元素，时间复杂度为：log n
7. set中的元素不允许修改
8. set中的底层使用二叉搜索树(红黑树)来实现

2.2. set的使用

Compare：仿函数，set中元素的比较方式。

构造函数：

插入：

insert 重载了三种插入方法，值、迭代器位置、迭代器区间，这里演示最常用的值插入。

#include<iostream>
#include<set>
using namespace std;


void test_set()
{
	set<int> myset;
	myset.insert(10);
	myset.insert(3);
	myset.insert(7);
	myset.insert(1);
	myset.insert(5);
	myset.insert(5); // 插入重复元素，会插入失败

	set<int>::iterator it = myset.begin(); 
	while (it != myset.end()) // 迭代器遍历：中序
	{
		cout << *it << " ";
		++it;
	}

}

通过上面的结果，其实set的功能也就体现出来了，就是 排序+去重。后面刷题中回很常用。

删除：

erase 也重载了三种方法：

删除迭代器(必须要求迭代器有效,一般配合find使用)、

删除值(有这个值就删除，没有也不会报错，底层其实就是封装了迭代器删除的过程，返回值为删除元素个数)、

删除迭代器区间。

#include<iostream>
#include<set>
using namespace std;


void test_set()
{
	set<int> myset;
	myset.insert(10);
	myset.insert(3);
	myset.insert(7);
	myset.insert(1);
	myset.insert(5);
	myset.insert(5);

	set<int>::iterator it = myset.begin();
	while (it != myset.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	// 通过迭代器删除3
	set<int>::iterator pos = myset.find(3);
	if (pos != myset.end())
	{
		myset.erase(pos);
	}
	for (auto e : myset)
	{
		cout << e << " ";
	}
	cout << endl;

	// 通过值删除10
	myset.erase(10);
	for (auto e : myset)
	{
		cout << e << " ";
	}
	cout << endl;
}

2.3. multiset的介绍

multiset 的特点：

1. multiset中在底层中存储的是<value, value>的键值对
2. mtltiset的插入接口中只需要插入即可
3. 与set的区别是，multiset中的元素可以重复，set是中value是唯一的
4. 使用迭代器对multiset中的元素进行遍历，可以得到有序的序列
5. multiset中的元素不能修改
6. 在multiset中找某个元素，时间复杂度为: log n
7. multiset的作用：可以对元素进行排序

2.4. multiset的使用

multiset的使用与set几乎一摸一样，唯一不同就是multiset中允许插入重复值。

void test_multiset()
{
	multiset<int> myset;
	myset.insert(1);
	myset.insert(1);
	myset.insert(5);
	myset.insert(5);
	myset.insert(5);
	myset.insert(5);
	myset.insert(3);
	myset.insert(2);

	for (auto e : myset)
	{
		cout << e << " ";
	}
	cout << endl;

	multiset<int>::iterator pos = myset.find(1); // 当find的val有多个值时，返回中序第一个val值所在节点的迭代器
	if (pos != myset.end())
	{
		myset.erase(pos);
	}

	int n = myset.erase(5); // 删除所有的5,并返回删除个数
	cout << n << endl;
	for (auto e : myset)
	{
		cout << e << " ";
	}
	cout << endl;
}

3.map的使用

3.1. map的介绍

map的特点：

1. map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
2. 在map中，键值key通常用于排序和惟一地标识元素，而值value中存储与此键值key关联的内容。键值 key和值value的类型可能不同，并且在map的内部，key与value通过成员类型value_type绑定在一起， 为其取别名称为pair: typedef pair value_type;
3. 在内部，map中的元素总是按照键值key进行比较排序的。
4. map中通过键值访问单个元素的速度通常比unordered_map容器(后面讲)慢，但map允许根据顺序对元素进行直接迭代(即对map中的元素进行迭代时，可以得到一个有序的序列)。
5. map支持下标访问符，即在[]中放入key，就可以找到与key对应的value。
6. map通常被实现为二叉搜索树(更准确的说：平衡二叉搜索树(红黑树))
7. map不支持修改Key，支持修改Value。

3.2. map的使用

key: 键值对中key的类型

T： 键值对中value的类型

Compare: 比较器的类型，map中的元素是按照key来比较的，缺省情况下按照小于来比较，一般情况下(内置类型元素)该参数不需要传递，如果无法比较时(自定义类型)，需要用户自己显式传递比较规则(一般情况下按照函数指针或者仿函数来传递)

Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的空间配置器

map 在使用使用上的最大区别就是多了一个模板参数V(文档中给的是T)，且使用时是将KV两个模板参数封装在了pair里面。

pair的第一个参数(first)是K，第二个参数(second)是V。

插入：

value_type：键值对，可以通过pair本身提供的构造函数初始化。

pair键值对也可以通过make_pair函数构造，一般常用这种方法。(make_pair：其实是对pair匿名构造的封装，并且可以自动推导类型)

void test_map()
{
	map<string, string> m;
	pair<string, string>kv1("left", "左");
	m.insert(kv1);
	m.insert(pair<string, string>("right", "右")); // 匿名对象构造
	m.insert(make_pair("one", "1"));
	m.insert(make_pair("two", "2"));
	m.insert(make_pair("three", "3"));
	for (auto& e : m)
	{
		cout << e.first << ":" << e.second << endl; // 不能直接打印pair键值对，分开打印
	}
}

删除：

可以通过某个位置的迭代器删除，也可以通过pair中first删除，也可以通过迭代器区间删除。

void test_map()
{
	map<string, string> m;
	pair<string, string>kv1("left", "左");
	m.insert(kv1);
	m.insert(pair<string, string>("right", "右")); // 匿名对象构造
	m.insert(make_pair("one", "1"));
	m.insert(make_pair("two", "2"));
	m.insert(make_pair("three", "3"));
	map<string, string>::iterator it = m.find("one");
	if (it != m.end())
	{
		m.erase(it);
	}
	m.erase("two");
	for (auto& e : m)
	{
		cout << e.first << ":" << e.second << endl; // 不能直接打印pair键值对 
	}
}

(★)operator[ ]:

map的pair不仅可以实现字典，也可以实现对Key的计数：

void test_map()
{
	map<string, int> CountMap;
	string str[] = { "left","left","right","right","test","up","down","right" };
	for (auto& s : str)
	{
		auto pos = CountMap.find(s); // 在map中查找是否存在当前字符串
		if (pos == CountMap.end()) // 不存在则插入，个数为1
		{
			CountMap.insert(make_pair(s, 1));
		}
		else
		{
			pos->second++; // 存在则将个数+1即可，不需要再插入
		}
	}

	for (auto& e : CountMap)
	{
		cout << e.first << ":" << e.second << endl;
	}

}

但是，通过上面这种方式插入会对map中不存在的字符串查找两次，第一次是find查找时会查找是否存在，第二次insert插入时对字符串插入的位置查找。

所以就有了对key插入的优化：insert对key的插入时返回值是pair，不是单纯的true或者false。

如果插入成功pair的first会被设置为插入位置的迭代器，second为true；如果插入失败pair的first是已经存在key位置的迭代器，second为false。

谷歌翻译(doge):

优化版本：

void test_map()
{
	map<string, int> CountMap;
	string str[] = { "left","left","right","right","test","up","down","right" };
	for (auto& s : str)
	{
		auto kv = CountMap.insert(make_pair(s, 1)); // 不管map中存不存在该key，直接插入
		if (kv.second == false)
		{
			kv.first->second++; // 如果插入失败，说明map中已经存在key，将value++即可
		}						// kv的first是iterator，而iterator中也是pair
	}

	for (auto& e : CountMap)
	{
		cout << e.first << ":" << e.second << endl; // 不能直接打印pair键值对 
	}

}

你以为这就是最简单的方式？其实不是，map中还提供了更简单的计数方式，原理还是上面这种方式，只是进行了封装。

operator[ ]: 支持对key位置的value直接访问

这个实现看着确实有点打脑壳，其实他这个写的有点麻烦，可以简化一下：

mapped_type& operator[] (const key_type& k) // 注意：返回value的引用，可以直接改变节点的value
{
    // return (*((this->insert(make_pair(k, mapped_type()))).first)).second;
    pair<map<K, V>::iterator, bool> kv = insert(make_pair(k, mapped_type())); // 调用insert，make_pair内部value使用的是该类型的匿名对象
    map<K,V>::iterator it = kv.first; // 取到迭代器
    return it->second; // 返回value
}

所以operator[ ]具有以下功能：

1. 插入
2. 查找
3. 修改

代码为：

void test_map()
{
	map<string, int> CountMap;
	string str[] = { "left","left","right","right","test","up","down","right" };