【手撕STL】map和set

vector、list、deque……称为序列式容器 ——push系列 pop系列
map、set称为关联式容器 ——insert系列 erase系列

set

set文档介绍

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

1. T: set中存放元素的类型，实际在底层存储的键值对。
2. Compare：set中元素默认按照小于来比较
3. Alloc：set中元素空间的管理方式，使用STL提供的空间配置器管理

set的使用举例

#include 
void TestSet()
{
	// 用数组array中的元素构造set
	int array[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0, 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	set<int> s(array, array + sizeof(array) / sizeof(array));
	cout << s.size() << endl;
	// 正向打印set中的元素，从打印结果中可以看出：set可去重
	for (auto& e : s)
		cout << e << " ";
	cout << endl;
	// 使用迭代器逆向打印set中的元素
	for (auto it = s.rbegin(); it != s.rend(); ++it)
		cout << *it << " ";
	cout << endl;
	// set中值为3的元素出现了几次
	cout << s.count(3) << endl;
}

void test_set()
{
	//排序+去重
	set<int> s;
	s.insert(1);
	s.insert(5);
	s.insert(4);
	s.insert(6);
	s.insert(8);
	s.insert(0);
	s.insert(15);
	set<int>::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;

	auto ret = s.find(10);  //O(logN)
	// auto ret = find(s.begin(), s.end(), 10);  //O(N)
	if (ret != s.end())
	{
		s.erase(ret); //erase如果ret没在s中，那么用迭代器erase会出现报错（assert暴力检查），而用key_value  erase就不会有那样的情况
	}
	for (const auto& e : s)
	{
		cout << e << " ";
	}
	cout << endl;
}

补充：

• set中可以存储键值对，实例化set时，将set中元素类型设置为pair即可

• set中的key是不能重复的

• set中任意类型元素都可以存储，存储对象时，需要用户提供比较规则

• set默认是升序，但是其内部默认不是按照大于比较，而是按照小于比较

multiset

multiset文档介绍

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

注意：

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

补充：

• multiset在底层实际存储的是的键值对
• multiset大部分接口与set的接口用法相同

multiset的使用

void test_multiset()
{
	//排序+去重
	multiset<int> s;
	s.insert(1);
	s.insert(5);
	s.insert(4);
	s.insert(6);
	s.insert(8);
	s.insert(8);
	s.insert(0);
	s.insert(15);
	s.insert(6);
	s.insert(6);
	s.insert(6);
	s.insert(6);

	for (const auto& e : s)
	{
		cout << e << " ";
	}
	cout << endl;
	auto pos = s.find(8);
	while (pos != s.end() && *pos == 8)
	{
		cout << *pos << " ";
		pos++;
	}
	cout << endl;
	cout << s.count(1) << endl;
	cout << s.count(6) << endl;
	cout << s.count(8) << endl;
}

注：

• multiset中的find接口查找的是中序中第一个索要查找的值
• multiset中的count接口用于查看set中key出现的次数

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通常被实现为二叉搜索树(平衡二叉搜索树(红黑树))

key: 键值对中key的类型
T： 键值对中value的类型
Compare:比较器的类型，map中的元素是按照key来比较的，缺省情况下按照小于来比较，一般情况下(内置类型元素)该参数不需要传递，如果无法比较时(自定义类型)，需要用户自己显式传递比较规则(一般情况下按照函数指针或者仿函数来传递)
Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的空间配置器
注意：在使用map时，需要包含头文件。

void test_map1()
{
	map<string, string> dict;
	dict.insert(pair<string, string>("sort", "排序"));
	dict.insert(make_pair("left", "左边"));
	dict.insert(make_pair("right", "右边"));
	map<string, string>::iterator it = dict.begin();
	while (dict.end() != it)
	{
		cout << it->first << " " << it->second << endl;
		it++;
	}
	cout << endl;
	for (const auto& e : dict)
	{
		cout << e.first << " " << e.second << endl;
	}
	cout << endl;
}


void test_map2()
{
	string str[] = { "sort","test", "insert", "sort", "sort", "sort", "test", "sort" };
	map<string, int> countmap;
	方法一：
	//for (const auto& e : str)
	//{
	//	auto ret = countmap.find(e);
	//	if (ret == countmap.end())
	//		countmap.insert(make_pair(e, 1));
	//	else
	//	{
	//		ret->second++;
	//	}
	//}

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

	//方法二：
	for (const auto& e : str)
	{
		countmap[e]++;
	}
	for (const auto& e : countmap)
	{
		cout << e.first << " " << e.second << endl;
	}

}

应用统计单词次数

void test_map()
{
	//统计单词次数
	方法一
	//string str[] = { "sort","test", "insert", "sort", "sort", "sort", "test", "sort" };
	//map countmap;
	//for (const auto& e : str)
	//{
	//	auto ret = countmap.find(e);
	//	if (ret == countmap.end())
	//		countmap.insert(make_pair(e, 1));
	//	else
	//	{
	//		ret->second++;   //ret->->second++;
	//	}
	//}

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


	方法二：
	//string str[] = { "sort","test", "insert", "sort", "sort", "sort", "test", "sort" };
	//map countmap;
	//for (const auto& e : str)
	//{
	//	//pair::iterator, int> ret = countmap.insert(make_pair(e, 1));
	//	auto ret = countmap.insert(make_pair(e, 1));

	//	//插入失败，表示e对应字符串已经在countmap中了，++次数
	//	if (ret.second == false)
	//	{
	//		ret.first->second++;
	//	}
	//	
	//}

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


	//方法三：
	string str[] = { "sort","test", "insert", "sort", "sort", "sort", "test", "sort" };
	map<string, int> countmap;
	for (const auto& e : str)
	{
		countmap[e]++;
	}

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

operator[]的应用：

void test_map2()
{
	map<string, string> dict;
	dict.insert(make_pair("sort", "排序"));
	dict["string"] = "字符串";  //先插入（"string"，""），再修改value
	dict["map"];  //先插入（"map"，""）
	dict["map"] = "地图";  //查找+修改
	cout << dict["map"] << endl;  //查找
}

注意：

• map中的operator[]：
• 1. k在map中，insert插入失败，因为k已经有了，insert返回的pair会带出k在map中存储节点的迭代器，通过这个迭代器，可以拿到k对应的value的值进行返回
• 2. k不在map中，insert插入成功，插入的值是pair，insert返回值会带出刚插入的k所在节点迭代器，通过这个迭代器，可以拿到k对应的value值进行返回

总结map的operator[]的特征：

• k不存在，插入默认的构造函数生成缺省值的value的pair
• k存在，返回k对应的value的值
• operator[]用于插入、查找、修改

补充：

• map和set底层结构都是红黑树，而其底层红黑树在实现时并没有区分是存k模型还是KV 模型

multimap

multimap的介绍

1. Multimaps是关联式容器，它按照特定的顺序，存储由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是可以重复的。

multimap的使用

multimap中的接口可以参考map，功能都是类似的。

注意：

1. multimap中的key是可以重复的。
2. multimap中的元素默认将key按照小于来比较
3. multimap中没有重载operator[]操作(找到key之后，但是无法确定用哪个key对应的value值（因为multimap中key是可以重复的）)。
4. 使用时与map包含的头文件相同：

void test_multimap()
{
	multimap<string, string> dict;
	dict.insert(make_pair("sort", "排序1"));
	dict.insert(make_pair("sort", "排序2"));
	dict.insert(make_pair("sort", "排序3"));
	for (const auto& e : dict)
	{
		cout << e.first << " " << e.second << endl;
	}
}

补充：multiamp中的find接口查找的是中序中第一个索要查找的k值

红黑树模拟实现STL中的map与set

【手撕STL】红黑树

红黑树的迭代器

begin()与end()：
STL明确规定，begin()与end()代表的是一段前闭后开的区间，而对红黑树进行中序遍历后，可以得到一个有序的序列，因此：begin()可以放在红黑树中最小节点(即最左侧节点)的位置，end()放在最大节点(最右侧节点)的下一个位置即nullptr

注：在STL库中红黑树的迭代器实现：begin()可以放在红黑树中最小节点(即最左侧节点)的位置，end()放在最大节点(最右侧节点)的下一个位置，对end()位置的迭代器能找最后一个元素，将end()放在头结点的位置

operator++()（对于迭代器it）

1. 如果it指向节点的右子树不为空，下一个就++到右子树中序第一个节点，也就是右子树的左节点
2. 如果it指向节点的右子树为空，下一个++要访问的节点是，沿着it指向节点到根节点的路径中，孩子是父亲做的那个父亲节点

operator–()（对于迭代器it）

1. 如果it指向节点的左子树不为空，下一个就–到左子树中序第最后个节点，也就是左子树的右节点
2. 如果it指向节点的左子树为空，下一个–要访问的节点是，沿着it指向节点到根节点的路径中，孩子是父亲做的那个父亲节点

改造红黑树

注意（在红黑树中）：

• KeyOfT: 通过value来获取key的一个仿函数类
• T: 如果是map，则为pair; 如果是set，则为k
• K：k为key的类型，

红黑树的代码（改装后）

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include
#include
#include
using namespace std;


enum Color
{
	RED,
	BLACK
};

template<class T>
struct RBTreeNode
{
	RBTreeNode(const T& data)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_data(data)
		,_col(RED)
	{}

	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	T _data;
	Color _col;
};
template<class T, class Ref, class Ptr>
struct RBTreeIterator
{
	typedef RBTreeIterator<T, Ref, Ptr> Self;
	typedef RBTreeNode<T> Node;
	RBTreeIterator(Node* node = nullptr)
		:_node(node)
	{}
	Node* _node=nullptr;
	Ref operator*()
	{
		return _node->_data;
	}
	Ptr operator->()
	{
		return &_node->_data;
	}
	bool operator==(const Self& it)const
	{
		return _node == it._node;
	}

	bool operator!=(const Self& it)const
	{
		return _node != it._node;
	}
	Self& operator++()
	{
		Node* cur = _node;
		if (cur && cur->_right)
		{
			Node* n = cur->_right;
			while (n->_left)
			{
				n = n->_left;
			}
			//*this = Self(n);
			_node = n;
		}
		else
		{
			cur = _node;
			Node* parent =cur ->_parent;
			Node* n = nullptr;
			if (parent->_left == cur)
			{
				n = parent;
			}
			else
			{
				while (parent&&parent->_right == cur)
				{
					cur = parent;
					parent = cur->_parent;
				}
				n = parent;
			}
			_node = n;
		}
		return *this;
	}
	Self operator++(int)
	{
		Self it(_node);
		if (_node->_right)
		{
			// 右子树中序第一个节点，也就是右子树的最左节点
			Node* subLeft = _node->_right;
			while (subLeft->_left)
			{
				subLeft = subLeft->_left;
			}

			_node = subLeft;
		}
		else
		{
			// 当前子树已经访问完了，要去找祖先访问，沿着到根节点的路径往上走，
			// 找孩子是父亲左的那个父亲节点
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && parent->_right == cur)
			{
				cur = parent;
				parent = parent->_parent;
			}

			_node = parent;
		}

		return it;
	}
	Self& operator--()
	{
		if (_node->_left)
		{
			
			Node* subLeft = _node->_left;
			while (subLeft->_right)
			{
				subLeft = subLeft->_right;
			}

			_node = subLeft;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && parent->_left == cur)
			{
				cur = parent;
				parent = parent->_parent;
			}

			_node = parent;
		}

		return *this;
	}

	Self operator--(int)
	{
		Self it(_node);
		if (_node->_left)
		{

			Node* subLeft = _node->_left;
			while (subLeft->_right)
			{
				subLeft = subLeft->_right;
			}

			_node = subLeft;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && parent->_left == cur)
			{
				cur = parent;
				parent = parent->_parent;
			}

			_node = parent;
		}

		return it;
	}
};
template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef RBTreeIterator<T, T&, T*> iterator;
	typedef RBTreeIterator<T, T&, T*> reverse_iterator;
	typedef RBTreeIterator<T, const T&, const T*> const_iterator;
	typedef RBTreeIterator<T, const T&, const T*> const_reverse_iterator;
	iterator begin()
	{
		Node* n = _root;
		while (n && n->_left)
		{
			n = n->_left;
		}
		return n;
	}
	iterator end()
	{
		return nullptr;
	}
	const_iterator begin()const
	{
		Node* n = _root;
		while (n && n->_left)
		{
			n = n->_left;
		}
		return n;
	}
	const_iterator end()const
	{
		return nullptr;
	}
	reverse_iterator rbegin()
	{
		Node* n = _root;
		while (n && n->_right)
		{
			n = n->_right;
		}
		return n;
	}
	reverse_iterator rend()
	{
		return nullptr;
	}

	const_reverse_iterator rbegin()const
	{
		Node* n = _root;
		while (n && n->_right)
		{
			n = n->_right;
		}
		return n;
	}
	const_reverse_iterator rend()const
	{
		return nullptr;
	}

	pair<iterator,bool> Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return make_pair(_root, true);
		}
		Node* cur = _root;
		Node* parent = cur;
		KeyOfT kot;
		while (cur)
		{
			if (kot(cur->_data)>kot(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (kot(cur->_data) < kot(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return make_pair(cur, false);
			}
		}
		// 新增节点，颜色是红色，可能破坏规则3，产生连续红色节点
		cur = new Node(data);
		Node* newnode = cur;
		if (kot(parent->_data) > kot(data))
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		// 控制近似平衡
		while (parent && parent->_col == RED)
		{
			Node* grandparent = parent->_parent;
			if (grandparent->_left == parent)
			{
				Node* uncle = grandparent->_right;
				// 情况一：uncle存在且为红，进行变色处理，并继续往上更新处理
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandparent->_col = RED;
					cur = grandparent;
					parent = cur->_parent;
				}
				// 情况二+三：uncle不存在，或者存在且为黑，需要旋转+变色处理
				else
				{
					// 情况二：单旋+变色
					if (cur == parent->_left)
					{
						RotateR(grandparent);
						grandparent->_col = RED;
						parent->_col = BLACK;
					}
					// 情况三：双旋 + 变色
					else
					{
						RotateL(parent);
						RotateR(grandparent);
						cur->_col = BLACK;
						grandparent->_col = RED;
					}
					break;
				}
			}
			else// (parent == grandfather->_right)
			{
				Node* uncle = grandparent->_left;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandparent->_col = RED;
					cur = grandparent;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_right)
					{
						RotateL(grandparent);
						grandparent->_col = RED;
						parent->_col = BLACK;
					}
					else
					{
						RotateR(parent);
						RotateL(grandparent);
						cur->_col = BLACK;
						grandparent->_col = RED;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return make_pair(newnode, true);
	}

	void RotateR(Node* parent)
	{
		if (parent == nullptr)
			return;
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
		
		Node* cur = parent->_parent;
		subL->_right = parent;
		if (parent == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
			parent->_parent = subL;
		}
		else
		{
			if (cur->_left == parent)
			{
				cur->_left = subL;
				subL->_parent = cur;
				parent->_parent = subL;
			}
			else
			{
				cur->_right = subL;
				subL->_parent = cur;
				parent->_parent = subL;
			}
		}

	}

	void RotateL(Node* parent)
	{
		if (parent == nullptr)
			return;
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		Node* cur = parent->_parent;
		subR->_left = parent;
		if (parent == _root)
		{
			_root = subR;
			subR->_parent = nullptr;
			parent->_parent = subR;
		}
		else
		{
			if (cur->_left == parent)
			{
				cur->_left = subR;
				subR->_parent = cur;
				parent->_parent = subR;
			}
			else
			{
				cur->_right = subR;
				subR->_parent = cur;
				parent->_parent = subR;
			}
		}

	}


	bool CheckRedRed(Node* root)
	{
		if (root == nullptr)
			return true;

		if (root->_col == RED && root->_parent->_col == RED)
			return false;
		
		return CheckRedRed(root->_left) && CheckRedRed(root->_right);
	}
	bool CheckBlackNum(Node* root, int blacknum, int benchmark)
	{
		if (root == nullptr)
		{
			if (blacknum != benchmark)
				return false;
			return true;
		}

		if (root->_col == BLACK)
			blacknum++;
		return CheckBlackNum(root->_left, blacknum, benchmark) && CheckBlackNum(root->_right, blacknum, benchmark);

	}

	bool IsBalance()
	{
		if (_root == nullptr)
			return true;
		if (_root->_col == RED)
			return false;

		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				benchmark++;
			cur = cur->_left;
		}
		int blacknum = 0;
		return CheckRedRed(_root->_left) && CheckRedRed(_root->_right) && CheckBlackNum(_root, blacknum, benchmark);
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}


	void _InOrder(Node* root)
	{
		KeyOfT kot;
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << kot(root->_data) << " ";
		_InOrder(root->_right);
	}
private:
	Node* _root=nullptr;
};

set的代码

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include"RBTree.h"
namespace lc
{
	
	template<class K>
	class set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:

		typedef  RBTree<K, K, SetKeyOfT> RBT;
		typedef  typename RBT::iterator iterator;
		typedef  typename RBT::reverse_iterator reverse_iterator;
		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}
		reverse_iterator rbegin()
		{
			return _t.rbegin();
		}
		reverse_iterator rend()
		{
			return _t.rend();
		}
		pair<iterator, bool> insert(const K& key)
		{
			return _t.Insert(key);
		}
	private:
		RBT _t;
	};
}

map的代码

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include"RBTree.h"
namespace lc
{
	template<class K,class V>
	class map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<const K,V>& kv)
			{
				return kv.first;
			}
		};
	public:

		typedef  RBTree<K, pair<const K,V>, MapKeyOfT> RBT;
		typedef  typename RBT::iterator iterator;
		typedef  typename RBT::reverse_iterator reverse_iterator;
		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}
		reverse_iterator rbegin()
		{
			return _t.rbegin();
		}
		reverse_iterator rend()
		{
			return _t.rend();
		}

		pair<iterator, bool> insert(const pair<const K,V>& kv)
		{
			return _t.Insert(kv);
		}
		V& operator[](const K& key)
		{
			pair<iterator, bool> it = insert(make_pair(key, V()));
			return (it.first)->second;
		}
	private:
		RBT _t;
	};
}

补充：
拷贝构造、赋值拷贝、析构函数、查找接口（可见以下文章）
【手撕STL】红黑树
【手撕STL】AVL树
【手撕STL】二叉搜索树