C++之关联式容器（map/multimap、set/multiset、AVLTree/RBTree）

最新推荐文章于 2024-03-13 18:34:47 发布

Sheena爽

最新推荐文章于 2024-03-13 18:34:47 发布

阅读量347

点赞数

分类专栏： C++ 文章标签： map/multimap set/multiset AVLTree及其旋转示图 RBTree及其旋转变色示图

本文链接：https://blog.csdn.net/sheena997/article/details/106139653

版权

C++ 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

STL六大组件中的容器分为序列式容器和关联式容器，在前面的C++之序列式容器（vector、list、deque、string）中我们了解了序列式容器，在本篇博客中，将介绍容器中的关联式容器。
树型结构的关联式容器主要有四种：map、set、multimap、multiset。
关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对（键值对：是用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值，value表示与key对应的信息。）在数据检索时比序列式容器效率更高。
文章目录

一、set和map的介绍及其使用

1.set的介绍

set是按照一定次序存储元素的容器。
在set中，元素的value也标识它（value就是key，类型为T），并且每个value必须是唯一的。set中的元素不能在容器中修改（元素总是const），但是可以从容器中插入或删除它们。
在内部，set中的元素总是按照其内部比较对象（类型比较）所指示的特定严格弱排序准则进行排序的。
set容器通过key访问单个元素的速度通常比unordered_set容器慢。但它们允许根据顺序对子集进行直接迭代。
set底层是用二叉搜索树（红黑树）实现的。
与map / multimap不同，map / multimap中存储的是真正的键值对<key, value>，set只放value，但在底层实际存放的是由<value, value>构成的键值对。
set中插入元素时，只需要插入value即可，不需要构造键值对。

2.set的使用（主要作用于查找）

部分函数声明	功能介绍
bool empty()	检测set是否为空，空返回true，否则返回false
size_t size()	返回set中有效元素的个数
pair<iterator, bool> insert(const value_type& x)	在set中插入元素x，实际插入的是<x, x>构成的键值对。若插入成功，返回<该元素在set中的位置, true>，若插入失败，说明x在set中已经存在，返回<x在set中的位置, false>
void erase(iterator pos)	删除set中pos位置上的元素
size_t 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_t count(const key_type& x) const	返回set中值为x的元素的个数。注意set中的元素是唯一的，因此该函数的返回值要么为0，要么为1，因此也可以用该函数来检测一个值为x的元素是否在set中。

#include <iostream>
#include <set>

using namespace std;

void Print1(set<int> s)
{
	set<int>::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}
void Print2(set<int> s)
{
	for (auto e : s)
		cout << e << " ";
	cout << endl;
}
void RPrint(set<int> s)
{
	auto rit = s.rbegin();
	while (rit != s.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;
}
void testSet()
{
	set<int> s;
	s.insert(7);
	s.insert(1);
	s.insert(2);
	s.insert(6);
	s.insert(5);
	s.insert(3);
	s.insert(4);
	s.insert(0);

	cout << "insert元素构造set，遍历结果为：" << endl;
	Print1(s);
	cout << endl;
	
	cout << "set有去重的功能：" << endl;
	s.insert(6);
	s.insert(6);
	Print2(s);
	cout << endl;

	cout << "逆置遍历set：" << endl;
	RPrint(s);
	cout << endl;

	cout << "set中元素个数为：" << endl;
	cout << s.size() << endl;
	cout << endl;

	cout << "删除值为5元素：" << endl;
	s.erase(5);
	Print2(s);
	cout << endl;

	cout << "找到值为4的元素的位置并删除：" << endl;
	auto pos = s.find(4);
	cout << "按位置删除值为4的元素后：" << endl;
	s.erase(pos);
	Print2(s);
	cout << endl;

	cout << "set中值为6的元素出现了几次：" << endl;
	cout << s.count(6) << endl;
	cout << endl;

}
int main()
{
	testSet();

	return 0;
}

在这里插入图片描述

3.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底层是平衡为二叉搜索树（红黑树）。
temlpate <class Key, class T, class Compare = less< Key >, class Alloc = allocator<pair <const Key, T>>> class map; 中key：键值对中key的类型。T：键值对中value的类型。Compare：比较器的类型，map中的元素是按照key来比较的，缺省情况下按照小于来比较，一般情况下（内置类型）该参数不需要传递，如果无法比较时（自定义类型），需要用户自己显式传递比较规则。Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的空间配置器。

4.map的使用（主要作用于查找和统计次数）

部分函数声明	功能简介
bool empty()	检测map中的元素是否为空，如果是返回true，否则返回false。
size_t size() const	返回map中有效元素的个数。
mapped_type& operator[] (const key_type& k)	返回键值对中key对应的value。当key不存在时，operator[]用默认value与key构造键值对然后插入，返回该默认的value。
pair<iterator, bool>insert(const value_type& x)	在map中插入键值对x，注意x是一个键值对，返回值也是键值对：iterator代表新插入元素的位置，bool代表是否插入成功。
void erase(iterator pos)	删除pos位置上的元素。
size_t erase(const key_type& x)	删除键值为x的元素。
void erase(iterator first, iterator last)	删除区间(first, last)中的元素。
void swap(map<Key, T, Compare, Allioator>& mp)	交换两个map中的元素。
void clear()	将map中的元素清空。
iterator find(const key_type& x)	在map中插入key为x的元素，找到返回该元素的位置的迭代器，否则返回end。
const_iterator find(const key_type& x) const	在map中插入key为x的元素，找到返回该元素位置的const迭代器，否则返回const_end。
size_t count(const key_type& x) const	返回key为x的键值在map中的个数，注意map中的key是唯一的，因此该函数的返回值要么为0，要么为1，因此也可以用该函数来检测一个key是否在map中。

#include <iostream>
#include <map>
#include <string>

using namespace std;

void Print(map<string, int> mp)
{
	cout << "map的元素个数为：" << mp.size() << endl;
	
	for (auto e : mp)
	{
		cout  << e.first << " : " << e.second << endl;
	}
	cout << endl;
}
void Print2(map<string, int>mp)
{
	cout << "map的元素个数为：" << mp.size() << endl;
	auto it = mp.begin();
	while (it != mp.end())
	{
		cout << it->first << " : " << it->second << endl;
		++it;
	}
	cout << endl;
}

void testMap1()
{
	string str[] = { "苹果", "苹果","西瓜", "草莓","西瓜","西瓜","香蕉", "橘子" };
	map<string, int> countMap;
	//统计次数方法1：
	for (auto e : str)
	{
		map<string, int>::iterator ret = countMap.find(e);
		if (ret != countMap.end())
			//(*ret).second++;
			++(ret -> second); 
		else
			countMap.insert(make_pair(e, 1));
		/*
		//可以写成：
		countMap.insert(pair<string, int>(e, 1));
		/*
		make_pair是一个函数模板（这里创建了一个匿名对象）
		template <class K, class V>
		inline<K, V> make_pair(const K& k, const V& v)
		{
		return pair<K,V>(k, v);
		}
		//make_pair()一个匿名对象，生命周期只在该行，该行结束之后即调用析构函数进行销毁。
		*/
	}

	Print2(countMap);

}

void testMap2()
{
	string str[] = { "苹果", "苹果","西瓜", "草莓","西瓜","西瓜","香蕉", "橘子" };
	map<string, int> countMap;
	//统计次数方法2：
	for (auto& e : str)
	{
		auto ret = countMap.insert(make_pair(e, 1));
		if (ret.second == false)
			++(ret.first->second);
	}

	Print(countMap);
	
}

void testMap3()
{
	string str[] = { "苹果", "苹果","西瓜", "草莓","西瓜","西瓜","香蕉", "橘子" };
	map<string, int> countMap;

	//统计次数方法3：
	for (auto& e : str)
		++countMap[e];
	/*
	//operator[]的实现
	mapped_type& operator[](const key_type& k)
	{
		return (*((this->insert(make_pair(k, mapped_type))).first)).second;
	}
	*/

	Print2(countMap);
	countMap["车厘子"];//不会报错,此时的车厘子会以0次插入。
	Print2(countMap);
	countMap["桃子"] = 9;//不会报错，此时的桃子不仅插入了，而且次数会被修改为9
	Print2(countMap);
	countMap["苹果"] = 100;//修改苹果的次数为100
	Print(countMap);
}

int main()
{
	cout << "testMap1()：" << endl;
	testMap1();
	cout << endl;
	cout << "testMap2()：" << endl;
	testMap2();
	cout << endl;
	cout << "testMap3()：" << endl;
	testMap3();


	return 0;
}

在这里插入图片描述

注意（参考上述代码）：
1).insert的返回值：
① 若新插入了一个值，若成功，first返回该值新结点的迭代器，second返回true。
②若新插入的值里面已经有了，first返回在map中和该值相等的迭代器，second返回false。
2).operator []：
① 插入 + 修改：countMap[“车厘子”]; 和 countMap[“桃子”] = 9;
② 查找 + 修改：countMap[“苹果”] = 100;
③ countMap[e]++：若为第一次出现则是插入并修改value值从0变为1。若不是第一次出现，则返回value的引用并且进行+1操作。

二、multiset和multimap的介绍及其使用

1.multiset的介绍

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

2.multiset的使用（主要作用于排序）

部分函数声明	功能介绍
bool empty()	检测multiset是否为空，空返回true，否则返回false
size_t size()	返回multiset中有效元素的个数
void erase(iterator pos)	删除set中pos位置上的元素
size_t 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_t count(const key_type& x) const	返回set中值为x的元素的个数。

multiset底层实际是<int, int>键值对。

#include <iostream>
#include <set>

using namespace std;

void Print1(multiset<int> s)
{
	multiset<int>::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}
void Print2(multiset<int> s)
{
	for (auto e : s)
		cout << e << " ";
	cout << endl;
}
void RPrint(multiset<int> s)
{
	auto rit = s.rbegin();
	while (rit != s.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;
}
void testMultiset()
{
	multiset<int> ms;
	ms.insert(7);
	ms.insert(1);
	ms.insert(2);
	ms.insert(6);
	ms.insert(5);
	ms.insert(3);
	ms.insert(4);
	ms.insert(0);

	cout << "insert元素构造multiset，遍历结果为：" << endl;
	Print1(ms);
	cout << endl;

	cout << "multiset没有去重的功能，只能排序：" << endl;
	ms.insert(6);
	ms.insert(6);
	Print2(ms);
	cout << endl;

	cout << "逆置遍历multiset：" << endl;
	RPrint(ms);
	cout << endl;

	cout << "multiset中元素个数为：" << endl;
	cout << ms.size() << endl;
	cout << endl;

	cout << "删除值为5元素：" << endl;
	ms.erase(5);
	Print2(ms);
	cout << endl;

	cout << "找到值为4的元素的位置并删除：" << endl;
	auto pos = ms.find(4);
	cout << "按位置删除值为4的元素后：" << endl;
	ms.erase(pos);
	Print2(ms);
	cout << endl;

	cout << "multiset中值为6的元素出现了几次：" << endl;
	cout << ms.count(6) << endl;
	cout << endl;

}
int main()
{
	testMultiset();

	return 0;
}

在这里插入图片描述

4.multimap的介绍

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

5.multimap的使用

multimap中的接口可以参考map，功能是类似的。不同的是multimap中的key是可以重复的。multimap中没有重载opertor[]操作。
multimap中元素默认将key按照小于来比较。

#include <iostream>
#include <map>
#include <string>

using namespace std;

void Print(multimap<string, int> mp)
{
	cout << "multimap的元素个数为：" << mp.size() << endl;

	for (auto e : mp)
	{
		cout << e.first << " : " << e.second << endl;
	}
	cout << endl;
}
void Print2(multimap<string, int>mp)
{
	cout << "multimap的元素个数为：" << mp.size() << endl;
	auto it = mp.begin();
	while (it != mp.end())
	{
		cout << it->first << " : " << it->second << endl;
		++it;
	}
	cout << endl;
}


void testMultimap()
{
	string str[] = { "苹果", "苹果","西瓜", "草莓","西瓜","西瓜","香蕉", "橘子" };
	multimap<string, int> mp;
	//统计次数方法2：
	for (auto& e : str)
	{
		auto ret = mp.find(e);
		if (ret != mp.end())
			ret->second++;
		else
			mp.insert(make_pair(e, 1));
	}
	Print(mp);
	mp.insert(pair<string, int>("火龙果", 10));
	mp.insert(pair<string, int>("火龙果", 5));
	mp.insert(pair<string, int>("车厘子", 20));
	Print2(mp);
}



int main()
{
	testMultimap();

	return 0;
}

在这里插入图片描述

6.multiset和set区别

multiset中的元素是可以重复的，而set中的元素是不可以重复的（自带去重功能，保证了记录的唯一性）。
set由于需要查重处理，会降低元素插入的速度，而multiset会提高元素插入的速度。

7.mulimap和map区别

multimap和map的排序默认都是按照键值对中key小于来排序的。
multimap中的key是可以重复的，而map中的key是不可以重复的（自带去重功能）。
multimap中没有重载operator[]操作，而map中重载了operator[]操作。

三、AVLTree和RBTree

1.AVLTree（含旋转示图）

map/set/multimap/multiset这几个容器的共同点是其底层都是按照二叉搜索树来实现的。但二叉搜索树的效率比较低下，比如按照有序方式插入就一定会导致效率低下。因此AVL树的出现就是为了解决二叉搜索树效率低下的问题。
（1）概念：一棵AVL树要么是空树，要么是具有以下性质的二叉搜索树（它的左右子树都是AVL树，左右子树高度之差即平衡因子的绝对值不超过1即为-1，1，0。），即可降低树的高度，从而减少平均搜索长度。

（2）AVL树的定义

template <class T>
struct AVLTreeNode
{
	AVLTreeNode(const T& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		,_bf(0)
	{}

	AVLTreeNode<K, V>* _left; // 该节点的左孩子
	AVLTreeNode<K, V>* _right; // 该节点的右孩子
	AVLTreeNode<K, V>* _parent; //该节点的父节点
	pair<K, V> _kv;
	int _bf = 0; // 该节点的平衡因子
};

（3）AVL树的插入

新增节点的平衡因子是0，新增节点的祖先的平衡因子可能会受影响：
① 高度变化在parent的右子树===》parent->_bf += 1。
② 高度变化在parent的左子树===》 parent->_bf -= 1。
通过新增节点的位置更新parent的平衡因子，更新完成之后：
① parent->_bf == 1 / -1，说明parent为根的子树的高度也变了，继续往上更新。
② 如果parent->_bf == 2 / -2，说明parent为根的子树已经不平衡了，需要旋转。
③ 如果parent->_bf == 0，说明parent为根的子树原来的高度为1 / -1，现在把矮的那边给填上了，parent所在的子树高度不变，停止更新。

（4）AVL树的旋转

右单旋
左单旋
左右双旋
右左双旋

（5）AVL树的删除

找到需要删除的节点，按照搜索树的规则进行删除。
更新平衡因子。
如果更新过程中某个节点平衡因子是2 / -2，则就要进行旋转。

（6）AVL树的性能

AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即log N。但如果要对AVL树做一些结构修改的操作，性能会非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的在删除时，有可能一直要让旋转持续到根的位置。

2.RBTree（含旋转变色示图）

AVL树的要求太严格，若要求不那么严格，性能还得到一定程度的保障----------红黑树的产生。

（1）红黑树（RBTree）的概念

红黑树，是一种二叉搜索树，但在每个节点上增加一个存储位表示节点的颜色，可以是Red或者Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路回避其他路径长出两倍，因而接近平衡。

（2）红黑树（RBTree）的性质

① 每个节点不是红色就是黑色。② 根节点是黑色的。③ 如果一个节点是红色的，则它的两个孩子节点是黑色的。④ 对于每个节点，从该节点到其所有后代节点的简单路径上，均包含相同数目的黑色节点。⑤ 每个叶子节点都是黑色的。（此处的叶子节点指的是空节点。）
满足以上性质，红黑树就能保证：其最长路径中节点的个数不会超过最短路径中节点个数的两倍。
为什么满足以上性质就能保证最长路径中节点的个数不会超过最短路径中节点的个数的两倍 --------- 因为如果一棵树要满足是红黑树的性质，则它的最短路径肯定是全黑，最长路径就是一红一黑，所以说红黑树的最长路径不超过最短路径的2倍。

（3）红黑树节点的定义

enum Colour
{
	BLACK;
	RED;
};
template <class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	T _data;
	Color _col;

	RBTreeNode(const T& data = T(), Colour col = RED)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_data(data)
		,_col(col)
    {}
};

（4）红黑树的插入

插入的节点设置为红色而不是黑色。因为插入红色，只可能破坏规则3，而且插入破坏规则3也只是破坏了一条路径；如果插入的是黑色，一定破坏规则4，导致最长路径可能超过最短路径的两倍，破坏了所有路径。
① 如果父亲节点是黑色，则没有破坏规则，结束。

② 如果父亲节点是红色，破坏了规则3，祖父一定是黑色的，则关键看叔叔节点。
（①）情况1：叔叔节点存在且为红色，则将叔叔节点和父亲节点变为黑色，祖父节点变为红色。继续往上更新。直到根为止，如果根变成了红色，则需要把根变回黑色即可。

（②）情况2：叔叔节点不存在或者叔叔节点存在且为黑色，先进行单旋处理，父亲节点变为黑色，祖父节点变为红色。

（③）情况3：与情况2一样，情况2是进行单旋处理，而情况3是先进行双旋处理。

3.AVLTree和RBTree的比较

红黑树和AVL树都是高效的平衡二叉树，增删查改的时间复杂度都是O(log N)，红黑树不追求绝对平衡，其只需要保证最长路径不超过最短路径的两倍，相对而言。降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVLTree更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。
AVLTree是严格平衡的。旋转次数较多。

Sheena爽

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C++之关联式容器（map/multimap、set/multiset、AVLTree/RBTree）

STL六大组件中的容器分为序列式容器和关联式容器，在前面的C++之序列式容器（vector、list、deque、string）中我们了解了序列式容器，在本篇博客中，将介绍容器中的关联式容器。树型结构的关联式容器主要有四种：map、set、multimap、multiset。关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, vallue>结构的键值对（键值对：是用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值，.
复制链接

扫一扫