1. 前言

我们都知道set是K模型的容器，而map是KV模型的容器，但是它俩的底层都是用红黑树实现的，上篇博文中模拟实现了一颗红黑树，接下来将对其进行改造，继而用一颗红黑树完美的封装map和set。说白了map和set就是一个光杆司令，其内部的主要功能都是套用了红黑树现成的，只是稍作改动即可。

2. 红黑树模板参数的控制

既然set是K模型，map是KV模型，正如stl库里的map和set，如图所示：

前面实现的红黑树是KV模型，那么为了适配set还需要重新写一个红黑树吗？实际上大可不必，只需要对模板参数进行修改即可，下面为库中红黑树正对模板参数进行修改解决的：

通过这里就能够很清晰的看出库里的节点的存储类型是根据set和map的第二个模板参数决定的，第二个参数存的是什么，节点存的就是什么类型，继而可以满足set和map的需求，而现在又可能引发一个新的问题：

既然数据类型看第二个模板参数，那第一个模板参数有何用处？

因为在红黑树中，无可避免会要求实现find等对K有需求的函数，因为find函数主要是通过Key进行查找的，如若省略第一个模板参数，那么map就无法进行find查找操作。

接下来，我们按照库里红黑树的样子对我们自己写的进行一个调整：
//节点类
template <class T>
struct RBTreeNode
{
	//三叉链结构
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
    //存储的数据
	T _data;
	//节点的颜色
	Colour _col;
	//构造函数
	RBTreeNode(const T& data)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(Red)
	{}
};
// 红黑树的类
// T决定红黑树中存储的什么数据
// set RBTree<K, K>
// map RBTree<K, pair<K, V>>
template <class K, class T>
class RBTree
{
	typedef RBTreeNode<T> Node;//T决定节点存储类型的数据
public:
    //……
private:
	Node* _root = nullptr;
};
对红黑树的模板参数修改好了，那么map（KV模型）和set（K模型）自然而然就能够适配了：

set：
namespace cpp
{
	template<class K>
	class set
	{
    public:
        //……
	private:
		RBTree<K, K> _t;
	};
}
map：
namespace cpp
{
	template<class K, class V>
	class map
	{
    public:
        //……
	private:
		RBTree<K, pair<K, V>> _t;
	};
}

3. 模板参数中仿函数的增加

由于现在红黑树的节点类型是T，当容器为set时，T就是键值Key，可以直接进行比较，当容器是map时，T就是pair<Key, Value>，此时不能直接比较，而需要从此键值对中取出Key，再拿Key进行大小比较。

为了解决这一点，我们可以在红黑树的模板参数上再加一层仿函数，此参数专门用于获得Key类型，而这个仿函数的实现是在map和set内部封装的，具体操作如下：

map：
template<class K, class V>
class map
{
    //仿函数
	struct MapKeyOfT
	{
		const K& operator()(const pair<K, V>& kv)
		{
			return kv.first;//返回键值key
		}
	};
public:
    //……
private:
	RBTree<K, pair<K, V>, MapKeyOfT> _t;
};
set：
template<class K>
class set
{
    //仿函数
	struct SetKeyOfT
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
public:
    //……
private:
	RBTree<K, K, SetKeyOfT> _t;
};
下面画图演示具体的调用情况：

4. 红黑树迭代器的实现

红黑树的正向迭代器实际上就是对结点指针进行了封装，因此在正向迭代器当中实际上就只有一个成员变量，那就是正向迭代器所封装结点的指针。
//迭代器的类
template<class T, class Ref, class Ptr>
struct __RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef __RBTreeIterator<T, Ref, Ptr> Self;//把迭代器typedef，简化后续使用
    //……
	Node* _node;
};
而在其内部，我们要完成如下操作：

1、构造函数
2、*和->运算符重载
3、!=和==运算符重载
4、++运算符重载
5、--运算符重载

接下来具体展开演示：

1、构造函数

构造函数我们直接通过一个节点的指针从而构造一个正向迭代器即可。
//构造函数
__RBTreeIterator(Node* node)
	:_node(node)
{}
2、*和->运算符重载

*运算符就是解引用，直接返回对应节点数据的引用即可。而->运算符返回的是对应节点数据的指针。
//*运算符重载
Ref operator*()
{
	return _node->_data;//返回_data数据本身
}
//->运算符重载
Ptr operator->()
{
	return &_node->_data;//返回_data数据的地址
}
3、!=和==运算符重载

!=运算符直接返回两个节点是否不同，而==运算符直接返回两个节点是否相同即可。
//!=
bool operator!=(const Self& s)
{
	return _node != s._node;
}
//==
bool operator==(const Self& s)
{
	return _node == s._node;
}
4、++运算符重载

++运算符又分前置++和后置++。

前置++：

首先，这里红黑树迭代器里的++后的值应该是按此位置开始往后中序遍历的下一个。而这个下一个节点的值理应比原先的大，想要找到这个位置，结合二叉搜索树的性质，理应在右子树当中去寻找，而这又要看右子树是否为空，具体操作如下：

1、右子树非空：直接遍历找到右子树的最左节点即可；
2、右子树为空：找祖先里面，孩子是父亲左的那个祖先节点；
3、当parent遍历到空时，++结束；
4、注意前置++返回的是++后的值。
//前置++
Self& operator++()
{
	if (_node->_right == nullptr)//右子树为空
	{
		//找祖先里面，孩子是父亲左的那个
		Node* cur = _node;
		Node* parent = cur->_parent;
		while (parent && parent->_right == cur)
		{
			cur = cur->_parent;
			parent = parent->_parent;
		}
		_node = parent;
	}
	else//右子树不为空
	{
		//右子树的最左节点
		Node* subLeft = _node->_right;
		while (subLeft->_left)
		{
			subLeft = subLeft->_left;
		}
		_node = subLeft;
	}
	return *this;
}
后置++：

后置++和前置++的唯一区别就在于后置++是返回++前的值，这里只需要在前置++的基础上在一开始把当前节点保存起来，直接调用前置++，最后返回保存的那个节点值即可。
//后置++
Self& operator++(int)
{
	Self tmp(*this);
	++(*this);//复用前置++
	return tmp;
}
5、--运算符重载

--运算符又分为前置--和后置--，下面分别讨论：

前置--：

--运算符和++运算符相反，--运算符是找比当前位置次小的节点而这个节点，而这又要优先去左子树里寻找，而左子树又分为如下两种情况：

左子树为空，找祖先里面孩子是父亲右的那个节点；
左子树非空，找左子树里最右的节点。
//前置--
Self& operator--()
{
	if (_node->_left == nullptr)//左子树为空
	{
		//找孩子是父亲右的那个
		Node* cur = _node;
		Node* parent = cur->_parent;
		while (parent && parent->_left == cur)
		{
			cur = cur->_parent;
			parent = parent->_parent;
		}
		_node = parent;
	}
	else//左子树不为空
	{
		//找左子树的最右节点
		Node* subRight = _node->_left;
		while (subRight->_right)
		{
			subRight = subRight->_right;
		}
		_node = subRight;
	}
	return *this;
}
后置--：

注意后置--返回的是--前的值，所以先定义tmp把*this保存起来，再套用前置--函数进行自减，最后返回tmp。
//后置--
Self& operator--(int)
{
	Self tmp(*this);
	--(*this);
	return tmp;
}

5. 红黑树的begin()和end()

迭代器实现后，我们需要在红黑树的实现当中进行迭代器类型的typedef。需要注意的是，为了让外部能够使用typedef后的正向迭代器类型iterator，我们需要在红黑树的public区域进行typedef。
template <class K, class T, class KeyOfT>
class RBTree
{
    //……
public:
	typedef __RBTreeIterator<T, T&, T*> iterator;//普通迭代器
	typedef __RBTreeIterator<T, const T&, const T*> const_iterator;//const迭代器
    //……
}
其实，STL中的红黑树的底层是有一个哨兵位头结点的，如下所示：

STL明确规定，begin()与end()代表的是一段前闭后开的区间，而对红黑树进行中序遍历后，可以得到一个有序的序列，因此：begin()可以放在红黑树中最小节点(即最左侧节点)的位置，end()放在最大节点(最右侧节点)的下一个位置，关键是最大节点的下一个位置在哪块？能否给成nullptr呢？答案是行不通的，因为对end()位置的迭代器进行--操作，必须要能找最后一个元素，此处就不行，因此最好的方式是将end()放在头结点的位置。

虽说库里的红黑树实现的是带哨兵位头节点的，但毕竟咱这是模拟（但求大概），综上begin()和end()的指向如下总结：

begin()：指向红黑树中最小节点(即最左侧节点)的位置.
end()：指向红黑树中最大节点(最右侧节点)的下一个位置，即nullptr.
//begin()
iterator Begin()//找最左节点
{
	Node* subLeft = _root;
	while (subLeft && subLeft->_left)
	{
		subLeft = subLeft->_left;
	}
	return iterator(subLeft);//调用迭代器的构造函数
}
//end()
iterator End()//返回最右节点的下一个
{
	return iterator(nullptr);
}
当然这里最好再实现一个const版本的begin()和end()，为的是普通迭代器和const迭代器都能够使用，其实主要还是set的迭代器不能被修改，无论是普通迭代器还是const迭代器，其内部都是用const迭代器封装的，因此必须实现一个const版本的begin()和end()。
//const版本
//begin() 
const_iterator Begin() const//找最左节点
{
	Node* subLeft = _root;
	while (subLeft && subLeft->_left)
	{
		subLeft = subLeft->_left;
	}
	return const_iterator(subLeft);//调用迭代器的构造函数
}
//end()
const_iterator End() const//返回最右节点的下一个
{
	return const_iterator(nullptr);
}

6. 红黑树的Find查找函数

查找的规则很简单，只需要遍历节点即可，具体规则如下：

如果查询的值 > 当前节点值，遍历到右子树查询
如果查询的值 < 当前节点值，遍历到左子树查询
如果查询的值 = 当前节点值，返回当前位置的迭代器
如果循环结束，说明未查询到，返回End()
//Find查找函数
iterator Find(const K& key)
{
	Node* cur = _root;
	KeyOfT kot;
	while (cur)
	{
		if (kot(cur->_data) < key)
		{
			cur = cur->_right;//查询的值 > 节点值，-》右子树
		}
		else if (kot(cur->_data) > key)
		{
			cur = cur->_left;//查询的值 < 节点值，-》左子树
		}
		else
		{
			return iterator(cur);
		}
	}
	return End();
}

7. 红黑树封装map和set源码

7.1 map.h

#pragma once
#include"RBTree.h"
namespace cpp
{
	template<class K, class V>
	class map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename RBTree<K, pair<K, V>, MapKeyOfT>::iterator iterator;
		typedef typename RBTree<K, pair<K, V>, MapKeyOfT>::const_iterator const_iterator;
		//begin()
		iterator begin() 
		{
			return _t.Begin();
		}
		//end()
		iterator end() 
		{
			return _t.End();
		}
		//insert
		pair<iterator, bool> insert(const pair<K, V>& kv)
		{
			return _t.Insert(kv);
		}
		//Find
		iterator find(const K& key)
		{
			return _t.Find();
		}
		//operator[]
		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = insert(make_pair(key, V()));
			return ret.first->second;
		}
	private:
		RBTree<K, pair<K, V>, MapKeyOfT> _t;
	};
}

7.2 set.h

#pragma once
#include"RBTree.h"
namespace cpp
{
	template<class K>
	class set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;
		typedef typename RBTree<K, K, SetKeyOfT>::const_iterator iterator;
		//begin()
		iterator begin() const
		{
			return _t.Begin();
		}
		//end()
		iterator end() const
		{
			return _t.End();
		}
		//insert
		pair<iterator, bool> insert(const K& key)
		{
			//pair<typename RBTree<K, K, SetKeyOfT>::iterator, bool> ret = _t.Insert(key);
			auto ret = _t.Insert(key);
			return pair<iterator, bool>(iterator(ret.first._node), ret.second);
		}
		//Find
		iterator find(const K& key)
		{
			return _t.Find();
		}
	private:
		RBTree<K, K, SetKeyOfT> _t;
	};
}

7.3 test.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include<string>
#include"map.h"
#include"set.h"
void test_set1()
{
	cpp::set<int> s;
	s.insert(8);
	s.insert(6);
	s.insert(11);
	s.insert(5);
	s.insert(6);
	s.insert(7);
	s.insert(10);
	s.insert(13);
	s.insert(12);
	s.insert(15);
	cpp::set<int>::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;
}
void test_map1()
{
	cpp::map<string, int> m;
	m.insert(make_pair("111", 1));
	m.insert(make_pair("555", 5));
	m.insert(make_pair("333", 3));
	m.insert(make_pair("222", 2));
	cpp::map<string, int>::iterator it = m.begin();
	while (it != m.end())
	{
		cout << it->first << ":" << it->second << endl;
		it++;
	}
	cout << endl;
	for (auto& kv : m)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
	cout << endl;
}
void test_map2()
{
	string arr[] = { "ƻ", "", "ƻ", "", "ƻ", "ƻ", "", "ƻ", "㽶", "ƻ", "㽶" };
	cpp::map<string, int> countMap;
	for (auto& str : arr)
	{
		countMap[str]++;
	}

	for (const auto& kv : countMap)
		cout << kv.first << ":" << kv.second << endl;
}
void test_map3()
{
	cpp::map<string, string> dict;
	dict["insert"];
	dict["insert"] = "";
	dict["left"] = "";
}
int main()
{
	//test_set1();
	//test_map1();
	//test_map2();
	test_map3();
	return 0;
}