[C++知识库]【C++】STL之map和set的基本使用

关联式容器

以前学过的容器，如vector,list,deque等，都属于序列式容器，因为这些容器的底层都是线性结构，里面存储的是元素本身

而关联式容器和序列式容器一样，也是用来存储数据的，与序列式容器不同的是，关联式容器里面存的是<key,value>结构的键值对,相对于序列式容器，关联式容器在数据检索时有着更高的效率

树形结构的关联式容器

根据应用场景的不同，STL总共实现了两种不同的关联式容器：树形结构与哈希结构

树形结构的关联式容器主要有四种：

• set
• multiset
• map
• multimap

这四种容器的共同点是：

使用平衡搜索树(红黑树)作为底层结构

set

set文档介绍

• set是按照一定次序存储元素的容器
• 在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们
• 在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序
• set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭代
• set在底层是用二叉搜索树(红黑树)实现的

set特性

• 与map/multimap不同，map/multimap中存储的是真正的键值对<key, value>，set中只放key，但在底层实际存放的是由<key, value>构成的键值对
• set中插入元素时，只需要插入key即可，不需要构造键值对
• set中的元素不可以重复(因此可以使用set进行去重)
• 使用set的迭代器遍历set中的元素，可以得到有序序列(set迭代器默认使用中序遍历)
• set中的元素默认按照小于来比较(可以通过传入仿函数改变比较规则)
• set中查找某个元素，时间复杂度为：O(log₂N)

set的使用

set的模板参数

• 第一个参数T

set中存放元素的类型

• 第二个参数Compare

比较器的类型，默认情况下是less

• 第三个参数Alloc

set中元素空间的管理方式，使用STL提供的空间配置器管理

set的构造

• 空构造

set<int> st1;

• 拷贝构造

set<int> st2(st1);

• 迭代器区间构造

vector<int> v{ 1,2,3,4,5 };
set<int> st3(v.begin(), v.end());

• 指定使用大于来比较，遍历为降序

set<int, greater<int>> st4;

set的操作

set的迭代器

set使用实例

void TestSet() {
	
    //空构造
	set<int> st;

	st.insert(4);
	st.insert(2);
	//插入重复元素会失败
	st.insert(4);
	st.insert(5);
	st.insert(1);
	st.insert(6);

	//使用范围for遍历
	for (auto e : st) {
		cout << e << " ";
	}
	cout << endl;

	//删除指定key
	st.erase(4);

	//使用迭代器遍历
	set<int>::iterator sit = st.begin();
	while (sit != st.end()) {
		cout << *sit << " ";
		sit++;
	}
	cout << endl;


	//通过迭代器删除
	auto pos = st.find(1);
	st.erase(pos);


	//使用反向迭代器遍历
	set<int>::reverse_iterator rsit = st.rbegin();
	while (rsit != st.rend()) {
		cout << *rsit << " ";
		rsit++;
	}
	cout << endl;

}

multiset

multiset文档介绍

• multiset是按照特定顺序存储元素的容器，其中元素是可以重复的
• 在multiset中，元素的value也会识别它(因为multiset中本身存储的就是<value, value>组成的键值对，因此value本身就是key，key就是value，类型为T). multiset元素的值不能在容器中进行修改(因为元素总是const的)，但可以从容器中插入或删除
• 在内部，multiset中的元素总是按照其内部比较规则(类型比较)所指示的特定严格弱排序准则进行排序
• multiset容器通过key访问单个元素的速度通常比unordered_multiset容器慢，但当使用迭代器遍历时会得到一个有序序列
• multiset底层结构为二叉搜索树(红黑树)

multiset特性

multiset和set的区别，就是multiset允许键值冗余，也就是插入重复元素不会失败

其余特性和set基本相同

multiset使用示例

void TestMultiSet() {
	multiset<int> mst;


	//插入重复值不会失败
	mst.insert(1);
	mst.insert(1);
	mst.insert(1);
	mst.insert(1);
	mst.insert(3);
	mst.insert(2);
	mst.insert(5);


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

map

map文档介绍

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

map特性

• map中的的元素是键值对
• map中的key是唯一的，并且不能修改
• 默认按照小于的方式对key进行比较
• map中的元素如果用迭代器去遍历，可以得到一个有序的序列
• map的底层为平衡搜索树(红黑树)，查找效率比较高，O(log₂N)
• 支持[]操作符，operator[]中实际进行插入查找

键值对pair

用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值，value表示与key对应的信息

SGI-STL中关于键值对的定义：

template <class T1, class T2>
struct pair
{
	typedef T1 first_type;
	typedef T2 second_type;
	T1 first;
	T2 second;
	pair() : first(T1()), second(T2())
	{}
	pair(const T1& a, const T2& b) : first(a), second(b)
	{}
};

map的插入需要使用键值对

map的使用

map的模板参数

• 第一个参数Key

键值对中key的类型

• 第二个参数T

键值对中value的类型

• 第三个参数Compare

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

• 第四个参数Alloc

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

map的构造

• 空构造

map<int, string> m1;

• 拷贝构造

map<int, string> m2(m1);

• 迭代器区间构造

map<int, string> m3(m2.begin(), m2.end());

• 指定使用大于来比较，遍历为降序

map<int, string, greater<int>> m4;

map的迭代器和遍历

map的遍历

void TestMapIterator() {
	map<string, string> m1;
	m1.insert(make_pair("cat", "猫猫"));
	m1.insert(make_pair("dog", "狗狗"));
	m1.insert(make_pair("star", "星星"));
	m1.insert(make_pair("moon", "月亮"));


	//使用正向迭代器进行遍历
	//遍历顺序是把key值按照字典比较，顺序输出
	map<string, string>::iterator mit = m1.begin();
	
	while (mit != m1.end()) {
		cout << mit->first << ":" << mit->second << endl;
		//cout << (*mit).first << ":" << (*mit).second << endl;
		mit++;
	}

	cout << "///" << endl;


	//使用反向迭代器进行遍历
	map<string, string>::reverse_iterator rmit = m1.rbegin();
	while (rmit != m1.rend()) {
		//cout << rmit->first << ":" << rmit->second << endl;
		cout << (*rmit).first << ":" << (*rmit).second << endl;
		rmit++;
	}

	cout << "///" << endl;

	//使用范围for进行遍历
	for (auto e : m1) {
		cout << e.first << ":" << e.second << endl;
	}

}

map的插入

insert函数

pair<iterator,bool> insert (const value_type& val);

• 参数

const value_type&：value_type其实就是pair类型的别名

typedef pair<const Key, T> value_type;

• 返回值

返回值是一个pair对象，pair对象的第一个成员是map的迭代器，第二个是一个布尔值

若插入元素的键值key在map中不存在，则插入成功，返回值pair的第一个元素是插入成功元素的迭代器，第二个是true

若插入元素的键值key在map中存在，则插入失败，返回值pair的第一个元素是map中已经存在元素的迭代器，第二个是false

• 构造匿名对象插入

map<string, string> m1;
m1.insert(pair<string, string>("test", "测试"));

• make_pair函数模板插入

标准库中的make_pair函数模板可以帮我们调用pair的构造，并且自动完成类型推导

template <class T1, class T2>
pair<T1, T2> make_pair(T1 x, T2 y){
	return (pair<T1, T2>(x, y));
}

把要构造的键值对传入make_pair函数，该函数模板会根据传入参数类型进行自动隐式推导，最终构造并返回一个对应的pair对象

map<string, string> m1;
m1.insert(make_pair("cat", "猫猫"));

map的查找

find函数

iterator find (const key_type& k);

参数：

const key_type&:map的key类型的值

返回值：

map的迭代器类型

若find成功，返回对应元素的迭代器

若find失败，返回容器最后一个元素下一个元素的迭代器

void TestMapFind() {
	map<string, string> m1;
	m1.insert(make_pair("cat", "猫猫"));
	m1.insert(make_pair("dog", "狗狗"));
	m1.insert(make_pair("star", "星星"));
	m1.insert(make_pair("moon", "月亮"));

	auto pos = m1.find("cat");

	if (pos != m1.end()) {
		cout << pos->first << ":" << pos->second << endl;
	}
	else {
		cout << "not find " << endl;
	}
}

map的删除

erase函数

//迭代器位置删除
iterator  erase (const_iterator position);
//通过key值删除
size_type erase (const key_type& k);

使用示例

void TestMapErase() {
	map<string, string> m1;
	m1.insert(make_pair("cat", "猫猫"));
	m1.insert(make_pair("dog", "狗狗"));
	m1.insert(make_pair("star", "星星"));
	m1.insert(make_pair("moon", "月亮"));

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

	cout << "///" << endl;

	auto pos = m1.find("cat");

	//通过迭代器删除
	m1.erase(pos);

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

	cout << "///" << endl;

	//通过key删除
	m1.erase("dog");

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

	cout << "///" << endl;
}

map的[]运算符重载

可以用来插入键值对，也可以对键值对的value值进行修改

mapped_type& operator[] (const key_type& k);
mapped_type& operator[] (key_type&& k);

• 参数

key_type:要插入的键值对的key

• 返回值

要理解返回值，首先得了解operator[]的实现

(*((this->insert(make_pair(k,mapped_type()))).first)).second

上面就是这个函数的返回值，可以将次拆分开来

分为三个步骤：

1. 调用insert函数插入一个键值为k，value值为mapped_type()默认值的pair键值对
2. 从insert返回值，也就是一个键值为迭代器，value值为bool值的pair键值对中获取到迭代器
3. 对这个迭代器进行解引用，访问迭代器对应对象的second元素，也就是value值

mapped_type& operator[] (const key_type& k){
    pair<iterator, bool> ret = insert(make_pair(k, mapped_type()));
    iterator it = ret.first;
    return (*it).second;
}

也就是说：

使用operator[]

如果传入的k值已经存在于map中，则返回这个k值对应value值的引用

如果传入的k值没有在map中，则插入键值对<k, mapped_type()>，并返回mapped_type()的引用

使用示例：

void TestMapSq() {
	map<string, string> m1;

	//使用operator[]插入monkey键值，对应的value值为类型缺省值
	m1["monkey"];
	//也可以插入完整键值对
	m1["cat"] = "猫猫";
	m1["dog"] = "狗狗";

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

	//使用operator[]修改monkey键值对应的value
	m1["monkey"] = "猴子";
	m1["cat"] = "小猫";

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

map的其他使用

使用方式和其他容器基本类似

map的计数应用

可以通过map来统计元素出现的次数

• 统计方式一

void TestMapCount1() {
	string arr[] = { "猫猫","猫猫", "狗狗", "猫猫", "猫猫", "兔子", "猫猫", "老鼠", "老鼠", "猫猫", "猴子", "猫猫", "猫猫" };

	map<string, int> countMap;

	for (const auto& str : arr) {
		map<string, int>::iterator ret = countMap.find(str);
		if (ret != countMap.end()) {
			ret->second++;
		}
		else {
			countMap.insert(make_pair(str, 1));
		}
	}

	//遍历
	for (auto e : countMap) {
		cout << e.first << ":" << e.second << endl;
	}
}

• 统计方式二

void TestMapCount2() {
	string arr[] = { "猫猫","猫猫", "狗狗", "猫猫", "猫猫", "兔子", "猫猫", "老鼠", "老鼠", "猫猫", "猴子", "猫猫", "猫猫" };

	map<string, int> countMap;

	for (const auto& str : arr) {
		//根据insert的返回值pair<iterator,bool> 特性进行统计
		auto ret = countMap.insert(make_pair(str, 1));
		if (ret.second == false) {
			ret.first->second++;
		}
	}

	//遍历
	for (const auto& e : countMap) {
		cout << e.first << ":" << e.second << endl;
	}
}

• 统计方式三

void TestMapCount3() {
	string arr[] = { "猫猫","猫猫", "狗狗", "猫猫", "猫猫", "兔子", "猫猫", "老鼠", "老鼠", "猫猫", "猴子", "猫猫", "猫猫" };

	map<string, int> countMap;
	//用operator[]的特性统计
	for (const auto& str : arr) {
		countMap[str]++;
	}

	//遍历
	for (const auto& e : countMap) {
		cout << e.first << ":" << e.second << endl;
	}
}

第三种是最常用的方法

multimap

multimap文档介绍

• Multimaps是关联式容器，它按照特定的顺序，存储由key和value映射成的键值对<key, value>，其中多个键值对之间的key是可以重复的
• 在multimap中，通常按照key排序和惟一地标识元素，而映射的value存储与key关联的内容。key和value的类型可能不同，通过multimap内部的成员类型value_type组合在一起，value_type是组合key和value的键值对:typedef pair<const Key, T> value_type
• 在内部，multimap中的元素总是通过其内部比较对象，按照指定的特定严格弱排序标准对key进行排序的
• multimap通过key访问单个元素的速度通常比unordered_multimap容器慢，但是使用迭代器直接遍历multimap中的元素可以得到关于key有序的序列
• multimap在底层用二叉搜索树(红黑树)来实现

multimap特性

multimap和map的区别，就是multimap允许键值冗余，也就是插入重复元素不会失败

multimap不支持operator[]的操作，因为key可以冗余，使用operator[]访问会引发歧义

其余特性和map基本相同

multiset使用示例

void TestMiltiMap() {
	multimap<string, string> mm1;

	mm1.insert(make_pair("cat", "猫猫"));
	//允许键值冗余
	mm1.insert(make_pair("cat", "小猫"));


	//遍历
	for (const auto& e : mm1) {
		cout << e.first << ":" << e.second << endl;
	}
}

不能用operator[]访问

multimap在OJ中的使用

前K个高频单词