【C++】—— STL关联式容器map/set

一、关联式容器

首先我们先介绍一下什么是关联式容器

• 序列式容器vector、list、deque、forward_list(C++11)因为其底层为线性序列的数据结构，里面存储的是元素本身。
• 关联式容器也是用来存储数据的，与序列式容器不同的是，map其里面存储的是<key, value>结构的键值对，set里面存储的是value，在数据检索时比序列式容器效率更高。

由于set和之前学的容器更为相似，所以先介绍一下set，并测试set的功能

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

set接口介绍

• T: set中存放元素的类型，实际在底层存储<value, value>的键值对。
• Compare：set中元素默认按照小于来比较(若想排降序，可传greater)
• Alloc：set中元素空间的管理方式，使用STL提供的空间配置器管理

1、set的构造函数

构造函数声明	功能介绍
explicit set (const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type());	构造一个空的set
set (InputIterator first, InputIterator last，const key_compare& comp = key_compare(),const allocator_type& alloc = allocator_type());	用first和last区间内的元素构造一个set
set (const set& x);	用一个set对象拷贝构造另一个set

2、set的迭代器

函数声明	功能介绍
iterator begin()	返回set中起始位置元素的迭代器
iterator end()	返回set中最后一个元素后面的迭代器
const_iterator cbegin() const	返回set中起始位置元素的const迭代器
const_iterator cend() const	返回set中最后一个元素后面的const迭代器
reverse_iterator rbegin()	返回set第一个元素的反向迭代器，即end最后一个元素
reverse_iterator rend()	返回set最后一个元素下一个位置的反向迭代器，即begin起始元素
const_reverse_iterator crbegin() const	返回set第一个元素的反向const迭代器，即cend
const_reverse_iterator crend() const	返回set最后一个元素下一个位置的反向const迭代器， 即crbegin

3、set的修改操作

函数声明	功能介绍
pair<iterator,bool> insert (const value_type& x )	在set中插入元素x，实际插入的是<x, x>构成的键值对，如果插入成功，返回<该元素在set中的位置，true>,如果插入失败，说明x在set中已经存在，返回<x在set中的位置，false>
iterator insert ( iterator position, const value_type& x)	在set的position位置插入x，实际插入的是<x, x>构成的键值对，注意：position位置只是参考，x最终不一定在该位置
template void insert ( InputIterator first, InputIterator last );	在set中插入[first, last)区间中的元素
void erase ( iterator position )	删除set中position位置上的元素
size_type erase ( const key_type& x )	删除set中值为x的元素，返回删除的元素的个数
void erase ( iterator first,iterator last )	删除set中[first, last)区间中的元素
void swap (set<Key,Compare,Allocator>& st );	交换set中的元素
void clear ( )	将set中的元素清空
iterator find ( const key_type& x ) const	返回set中值为x的元素的位置
size_type count ( const key_type& x ) const	返回set中值为x的元素的个数

举几个例子测试set的功能

void Testset()//测试构造函数、拷贝构造、插入、删除、查找
{
	set<int> s;
	s.insert(4);
	s.insert(5);
	s.insert(3);
	s.insert(4);
	s.insert(2);
	s.insert(8);
	s.insert(4);
	s.insert(5);
	s.insert(3);
	s.insert(6);

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

	auto t1 = s.find(5);//set自己的find函数,时间复杂度O(logN)
	auto t2 = std::find(s.begin(), s.end(), 5);//算法中的find函数，时间复杂度为O(N)
	if (t2 != s.end())
	{
		s.erase(t2);
	}

	s.erase(5);
	s.erase(3);
	//s.clear();
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;
}

multiset

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

举几个例子测试multiset的功能

//测试multiset，基本接口个set一样，唯一区别是multiset允许序列中有重复元素
void Test_multiset()
{
	multiset<int> ms;
	ms.insert(2);
	ms.insert(3);
	ms.insert(5);
	ms.insert(4);
	ms.insert(5);
	ms.insert(1);
	ms.insert(5);
	ms.insert(2);
	ms.insert(7);
	ms.insert(6);

	multiset<int>::iterator mit = ms.begin();
	while (mit != ms.end())
	{
		cout << *mit << " ";
		++mit;
	}
	cout << endl;
}

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通常被实现为二叉搜索树(更准确的说：平衡二叉搜索树(红黑树))。

map接口介绍

1、map的构造

函数声明	功能介绍
map (const key_compare& comp = key_compare(), const allocator_type& alloc = allocator_type())	构造一个空的map
template map (InputIterator first, InputIterator last, const key_compare& comp = key_compare(), const allocator_type& alloc =allocator_type())	用[first,last)区间中的元素构造map
map (const map& x)	map的拷贝构造

举个栗子测试一下map的构造函数

void Testmap()
{
	map<int, int> m;
	m.insert(pair<int, int>(1, 2));
	m.insert(pair<int, int>(2, 3));
	m.insert(pair<int, int>(5, 1));
	m.insert(std::make_pair(1, 5));
	m.insert(std::make_pair(7, 5));
	m.insert(std::make_pair(9, 5));

	map<int, int> copy(m);

	map<int, int>::iterator mit = m.begin();
	while (mit != m.end())
	{
		cout << mit->first << ":" << mit->second << " ";
		++mit;
	}
	cout << endl;

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

2、map迭代器

3、容量及元素访问

• 注意：在元素访问时，有一个与operator[]类似的操作at()(该函数不常用)函数，都是通过key找到与key对应的value然后返回其引用，不同的是：当key不存在时，operator[]用默认value与key构造键值对然后插入，返回该默认value，at()函数直接抛异常。

举个栗子具体来看看

//find  insert
void Testmap2()
{
	string strs[] = { "苹果", "苹果", "西瓜", "苹果", "西瓜", "草莓", "草莓", "香蕉", "苹果", "苹果", "香蕉", "香蕉", "苹果", "苹果" };
	map<std::string, int> countmap;
	for (const auto& e : strs)
	{
		//std::map<std::string, int>::iterator it = countmap.find(e);
		auto it = countmap.find(e);
		if (it != countmap.end())
		{
			it->second++;
		}
		else
		{
			countmap.insert(make_pair(e, 1));
		}
	}

	//map<std::string, int>::iterator cit = countmap.begin();
	auto cit = countmap.begin();
	while (cit != countmap.end())
	{
		cout << cit->first << ":" << cit->second << endl;
		++cit;
	}
	cout << endl;
}

//insert
void Testmap3()
{
	string strs[] = { "苹果", "苹果", "西瓜", "苹果", "西瓜", "草莓", "草莓", "香蕉", "苹果", "苹果", "香蕉", "香蕉", "苹果", "苹果" };
	map<std::string, int> countmap;
	for (const auto& e : strs)
	{
		//pair<map<string, int>::iterator, bool> ret = countmap.insert(make_pair(e, 1));
		auto ret = countmap.insert(make_pair(e, 1));
		if (ret.second == false)
		{
			ret.first->second++;
		}
	}

	//map<string, int>::iterator cit = countmap.begin();
	auto cit = countmap.begin();
	while (cit != countmap.end())
	{
		cout << cit->first << ":" << cit->second << endl;
		++cit;
	}
	cout << endl;
}

//operator[]
void Testmap4()
{
	string strs[] = { "苹果", "苹果", "西瓜", "苹果", "西瓜", "草莓", "草莓", "香蕉", "苹果", "苹果", "香蕉", "香蕉", "苹果", "苹果" };
	map<string, int> countmap;
	for (const auto& e : strs)
	{
		countmap[e]++;
	}

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

• 三个测试函数实现的是同一个功能，统计出现水果的个数，若是不存在则插入
• 第一个很好理解，在map中找看有没有该类水果，没有就插入
• 第二个借助insert的返回值来判断是否有该类水果，插入成功表示没有，不成功表示有
• 第三个就是operator[]，访问该类水果，若存在计数加一，不存在就插入

4、map中元素的修改

multimap

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

注意：multimap和map的唯一不同就是：map中的key是唯一的，而multimap中key是可以重复的。