C++红黑树封装set和map（很详细）

前言

在前面，我们学习了红黑树。（没学过红黑树直接看会很吃力）set和map的底层就是红黑树，现在我们要用这棵树来封装STL里面的容器：set和map。

下面是之前讲过的红黑树，他只是普通的“Key”模型,适合封装set容器

RBTree.h代码如下（这是之前的，还没封装好，后续会给上总代码）

#pragma once
 
enum color
{
	RED,
	BLACK
};
 
template<class K>
struct RBTreeNode
{
	RBTreeNode<K>* _parent;
	RBTreeNode<K>* _left;
	RBTreeNode<K>* _right;
	K _key;
	color _col;
	RBTreeNode(const K& key)
		:_key(key)
		,_parent(nullptr)
		,_left(nullptr)
		,_right(nullptr)
		,_col(RED)
	{}
};
 
template<class K>
class RBTree
{
	typedef RBTreeNode<K> Node;
public:
	bool Insert(const K& key)
	{
		Node* cur = _root;
		Node* parent = _root;
		if (_root == nullptr)
		{
			_root = new Node(key);
			_root->_col = BLACK;
			return true;
		}
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		if (parent->_key > key)
		{
			parent->_left = new Node(key);
			cur = parent->_left;
		}
		else
		{
			parent->_right = new Node(key);
			cur = parent->_right;
		}
		cur->_parent = parent;
		while (parent && parent->_col == RED)
		{
			Node* grandparent = parent->_parent;
 
			if (grandparent->_left == parent)
			{
				//     g
				//   p   u
				// c
				Node* uncle = grandparent->_right;
				if (uncle && uncle->_col == RED)
				{
					//变颜色
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandparent->_col = RED;
					//往上更新
					cur = grandparent;
					parent = grandparent->_parent;
				}
				else
				{
					//     g
					//   p   u
					// c
					if(cur == parent->_left)
					{
						RotateR(grandparent);
						grandparent->_col = RED;
						parent->_col = BLACK;
						break;
					}
					//      g
					//   p     u
					//    c
					else
					{
						RotateL(parent);
						RotateR(grandparent);
						cur->_col = BLACK;
						grandparent->_col = RED;
						break;
					}
				}
			}
			else  //grandparent->_right == parent
			{
				//     g
				//   u   p
				//         c
				Node* uncle = grandparent->_left;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandparent->_col = RED;
					cur = grandparent;
					parent = grandparent->_parent;
				}
				else
				{
					//     g
					//   u   p
					//         c
					if (parent->_right == cur)
					{
						RotateL(grandparent);
						parent->_col = BLACK;
						grandparent->_col = RED;
						break;
					}
					else
					{
						//     g
						//   u   p
						//      c
						RotateR(parent);
						RotateL(grandparent);
 
						cur->_col = BLACK;
						grandparent->_col = RED;
						break;
					}
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
 
	bool Check(Node* root,int BlackNum,int valRef)
	{
		if (root == nullptr)
		{
			if(BlackNum == valRef)
			{
				return true;
			}
			else
			{
				cout << "每条路径黑色结点个数不等" << endl;
				return false;
			}
		}
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "有连续的红色节点" << endl;
			return false;
		}
		if (root->_col == BLACK)
		{
			BlackNum++;
		}
		return Check(root->_left,BlackNum,valRef) && Check(root->_right, BlackNum, valRef);
	}
 
	bool IsBalance()
	{
		if (_root == nullptr)
			return true;
		if (_root->_col == RED)
			return false;
		int valRef = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				valRef++;
			cur = cur->_left;
		}
		int BlackNum = 0;
		return Check(_root,BlackNum,valRef);
	}
 
private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
		subL->_right = parent;
		Node* grandparent = parent->_parent;
		parent->_parent = subL;
		if (grandparent == nullptr)
		{
			_root = subL;
			subL->_parent = nullptr;
			return;
		}
		if (grandparent->_left == parent)
		{
			grandparent->_left = subL;
		}
		else
		{
			grandparent->_right = subL;
		}
		subL->_parent = grandparent;
	}
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;
		subR->_left = parent;
		Node* grandparent = parent->_parent;
		parent->_parent = subR;
		if (grandparent == nullptr)
		{
			_root = subR;
			_root->_parent = nullptr;
			return;
		}
		if (grandparent->_left == parent)
		{
			grandparent->_left = subR;
		}
		else
		{
			grandparent->_right = subR;
		}
		subR->_parent = grandparent;
	}
	Node* _root = nullptr;
};

一、修改模型

如果要封装map的“Key，Value” 容器，那么我们需要重新copy一份红黑树，改成“Key，Value” 模型去封装map，这样似乎也太笨了一点，我们看看写库函数的大佬是如何处理的。如何用一棵树封装map和set

这里提出了库里面的关键信息，其他内容看不懂没关系，只需要知道红黑树结点类型只有Value，通过类型Value来判断是“Key”还是“Key，Value”

1.set传递的第二个参数

我们再看一下set容器所传递的内容是什么，可以看到对Key typedef了一下，给到红黑树的第二个参数value_type就是Key。这个value_type会传递给上面的Value。（注意看这里的私有成员是rb_tree类型的 t，调用的是上面图片的rb_tree）

2.map传递的第二个参数

map容器 typedef 的value_type是pair<const Key,T>类型，因此map传递给红黑树的第二个参数为pair<const Key,T>类型。

如此一来，可以通过一颗红黑树来实现“Key”和“Key，Value”模型。那么他具体是怎么实现的，我们还需要进一步分析

3.修改RBTree.h与添加map.h和set.h

根据库里面的内容，我们也对自己的RBTree.h代码进行修改

RBTreeNode结点，根据库里面的，将模板类型K改成了T，K _key改成T _data更容易理解，_data是什么，我们不知道，要看你具体传什么内容，可能是单个key，可能是pair。

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

对于RBTree也要进行改造，模板参数添加上T类型，插入具体的我只改了一点点，防止文章过与冗余，后面都要弄成data。（后续会给上总代码，大家先理解就好）

template<class K,class T>  //添加了T
class RBTree
{
	typedef RBTreeNode<T> Node;
    bool Insert(const T& data)  //修改部分
	{
		Node* cur = _root;
		Node* parent = _root;
		if (_root == nullptr)
		{
			_root = new Node(data);  //修改部分
			_root->_col = BLACK;
			return true;
		}
    .........//后续还有很多内容，这里就不多改造了
    }
}

写出set.h （仿函数不添加，防止混乱）跟库里面的一样，传递的第二个参数为K类型

#pragma once
#include"RBTree.h"
namespace kky
{
	template<class K>
	class set
	{
	private:
        RBTree<K, K> _t;
	};
}

写出map.h 跟库里面的一样，传递的第二个参数为pair类型

#pragma once
#include"RBTree.h"
namespace kky
{
	template<class K,class V>
	class map
	{
	private:
		RBTree<K, pair<const K, V>> _t;
	};
}

这里有点绕，现在我们再来捋一捋。

你是map，那么你传递的第二个参数T是pair，通过T构建出来的结点也是pair类型，里面存放的_data自然是pair类型。

你是set，你传递的第二个参数T是K，通过T构建出来的结点也是K类型，里面存放的_data自然是K类型。

4.仿函数取出set中的key和map中的key

那么现在问题又来了，这样就可以构建出来了吗？我们代码逻辑部分会不会有点问题？

大家看下面的代码，这是一个插入时的比较代码，看存放的数据比当前结点大还是小，如果大，往右走，如果小往左走，后面就是找到合适的地方再进行插入。

对于set来说，这句代码没有问题，可以这样比较。

对于map呢？map中的pair支不支持比较呢？我们去C++文档里面查一下，如下发现pair支持比较大小，但是他是first小就小，first如果相等，那么second小就小（这里代码使用了复用，仔细分析一下就是这个意思）

但是我们需要的不是这样啊，map我们只比较key，不比较value，如果key相等，就不要处理了，返回false（set和map的key不能重复）。库函数的比较我们用不上，我们需要自己写仿函数去判断。

现在的重点是将_data里面的key取出来比较。库里面是选择添加一个类型KeyOfValue。如下

那么具体是如何做到添加一个类模板对象，就做到可以如此比较的呢？（这里不懂没关系，下面我们还有图）

首先在set和map创建上KeyofValue类，目的是通过仿函数取出Key

set.h 添加上SetKeyofT，函数内部就是走个过场，直接取出key。并传递给RBTree，当做第三个参数。

public:
    struct SetKeyofT
    {
	    const K& operator()(const K& key)
	    {
	    	return key;
	    }
    };
private:
    RBTree<K, K,SetKeyofT> _t;

map.h 添加上MapKeyofT，目的是取出pair里面的first（也就是key），并将MapKeyofT传递给RBTree，当做第三个参数。

public:
	struct MapKeyofT
	{
		const K& operator()(const pair<const K, V>& kv)
		{
			return kv.first;
		}
	};
private:
	RBTree<K, pair<const K, V>,MapKeyofT> _t;

RBTree.h 修改，添加了第三个模板参数KeyofT，并使用KeyofT构建对象koft，对需要进行_data比较的地方，都是用koft仿函数处理。

template<class K,class T,class KeyOfT>
class RBTree
{
    KeyOfT koft;  //构建对象
	typedef RBTreeNode<T> Node;
public:
    pair<Node*,bool> Insert(const T& data)
    {
	    Node* cur = _root;
	    Node* parent = _root;
	    if (_root == nullptr)
	    {
		    _root = new Node(data);
		    _root->_col = BLACK;
		    return make_pair(_root,true) ;
	    }
	    while (cur)
	    {
		    if (koft(cur->_data) < koft(data))
		    {
			    parent = cur;
			    cur = cur->_right;
		    }
		    else if (koft(cur->_data) > koft(data))
		    {
			    parent = cur;
			    cur = cur->_left;
		    }
	        else
	        {
		        return make_pair(cur, false);
	        }
        }
        if (koft(parent->_data) > koft(data))
        {
	        parent->_left = new Node(data);
	        cur = parent->_left;
        }
        //后续内容没有比较，无需修改
    }
};

那么现在我们再画图捋一捋，

你是map，构建出的树第三个参数就是MapKeyofT，因此使用koft去调用_data数据，你获取的就是_data里面的first。

你是set，构建出的树第三个参数就是SetKeyofT，因此使用koft去调用_data数据，你获取的就是_data本身（这里的_data就是key）。

相当于set是陪太子读书，因为太子（map）需要使用koft去取出第一个数据，那么你set也得去这样取，就算你本身就是key，也这样跟这太子取，谁让他map是太子呢？

（这里逻辑其实并不复杂，只是有点点绕，大家不懂可以发评论问我）

注意：图片中的Insert函数返回类型大家看不懂可以忽略,当做bool就好，这是为了后续实现operator[]使用的（后面会讲）

到了现在，我们只需在set和map里面添加上insert函数就行，因为我们现在已经有了_t这颗树，因此调用_t树的Insert函数就好。

set.h 添加

bool Insert(const K& key)
{
	return _t.Insert(key);
}

map.h 添加

bool Insert(const pair<const K, V>& kv)
{
	return _t.Insert(kv);
}

现在就可以插入运行一下，看看我们封装得咋样了（iterator也不用管，后续会讲解，这里只做打印）

二、迭代器

1.迭代器基础

那么插入的基本逻辑，我们已经实现了，现在开搞迭代器，家人们，又是大坑来了，我们耐下性子慢慢来。

首先，map和set的迭代器只需要第二个参数------T 就可以了。他的成员函数只有红黑树结点_node，通过结点_node来进行构造迭代器，operator* 、 operator->、!=、==都很简单，这里我们不多赘述，代码如下

template<class T>
struct __TreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef __TreeIterator<T> Self;
	__TreeIterator(Node* node)
		:_node(node)
	{}
	T& operator*()
	{
		return _node->_data;
	}

	T* operator->()
	{
		return &_node->_data;
	}
    bool operator!=(const Self& s)
    {
	    return _node != s._node;
    }

    bool operator==(const Self& s)
    {
	    return _node == s._node;
    }
    Node* _node;
}

2.迭代器++

那么迭代器中很重要的++呢？

大家知道，在之前我们学习string、vector、list的时候，他们都是线性表，++往后面走就可以了，现在学到的set和map是树形结构，他的++应该如何走？

如图，it 在1的位置，那么it++，应该到6的地方去，那么我们可以知道，当前节点的右子树不为空，我们++需要到右子树的最左结点去。那么如果我们现在在6的地方，再++应该去到8的地方，那么我们又可以知道，当parent->right==cur时，我们需要再往上面走，一直走到parent->left == cur的时候才停止，再去遍历parent节点。不理解没关系，我们后面画图分析

为什么会这样？因为中序是左根右，当前结点已经遍历完了，证明左和根已经遍历完毕，需要遍历右边，当右边遍历完毕，证明该树遍历完毕，也就是遍历完了父亲的左子树（该树就是左子树），应该去遍历父亲节点

关键点是如果当前节点右为空，看当前节点是父亲的左还是右，是左就遍历父亲，是右就往上面走，知道当前节点是父亲的左。

根据我们的分析，++代码如下 _node为迭代器成员变量

Self& operator++()
{
	if (_node->_right)  //右树存在  找右树最左节点
	{
		Node* cur = _node->_right;
		while (cur->_left)
		{
			cur = cur->_left;
		}
		_node = cur;
	}
	else    //右树不存在  往上迭代
	{
		Node* cur = _node;
		Node* parent = _node->_parent;
		while (parent && parent->_right == cur)
		{
			cur = parent;
			parent = parent->_parent;
		}
		_node = parent;
	}
	return *this;
}

3.迭代器--

迭代器--跟++不能说一模一样，只能说毫无差距，他们是相反的，直接上代码

Self& operator--()
{
	if (_node->_left)
	{
		Node* cur = _node->_left;
		while (cur->_right)
		{
			cur = cur->_right;
		}
		_node = cur;
	}
	else
	{
		Node* cur = _node;
		Node* parent = _node->_parent;
		while (parent && parent->_left == cur)
		{
			cur = parent;
			parent = parent->_parent;
		}
		_node = parent;
	}
	return *this;
}

4.添加begin()、end()

RBTree.h添加迭代器和begin()、end()

typedef __TreeIterator<T> iterator;
iterator begin()
{
	Node* cur = _root;
	while (cur && cur->_left)
	{
		cur = cur->_left;
	}
	return iterator(cur);
}

iterator end()
{
	return iterator(nullptr);
}

set.h

typedef RBTree<T>::iterator iterator;
iterator begin()
{
	return _t.begin();
}

iterator end()
{
	return _t.end();
}

map.h

typedef RBTree<pair<const K, V>>::iterator iterator;
iterator begin()
{
	return _t.begin();
}

iterator end()
{
	return _t.end();
}

但是当我们编译时却报错了这是为什么呢？

首先，这个iterator是RBTree里面的，而RBTree里面的iterator也是typedef过的，是__TreeIterator里面的。

因此在set里面的RBTree<K, K, SetKeyofT>::iterator是内嵌类型，还没有实例化，编译器在编译时不知道他是什么类型，根本就不认识他，我们需要给set里面的RBTree<K, K, SetKeyofT>::iterator给添加上typename，告诉编译器这里是类型，你现在先不急着去找他，等到对象实例化的时候，你再去取出他的类型。如下
typedef typename RBTree<K,K,SetKeyofT>::iterator iterator;

现在迭代器才算构建好，set和map可以运行了。

三、map的operator[]

再把operator[]给实现一下，C++文档里面的operator[]如下

这里有点绕，看不懂很正常，我们拆分一下，如下

根据我们的分析，operator[]首先会执行插入，无论成功还是失败会取到该树的迭代器的Value。还有一点就是insert的返回类型为pair<iterator,bool>，之前为了代码简单，我们写的insert返回类型是bool。

因此我们需要修改insert的返回类型，同时修改函数内部return 后接上的内容，如下，下面还有的return也需要修改，这里不过多展开，不多赘述。

set.h也修改 map.h也修改

并在map.h里面添加上，我们写绕一点，更容易理解，库里面的大佬写法学不会。
V& operator[](const K& key)
{
	pair<iterator, bool> ret = Insert(make_pair(key, V()));
	return ret.first->second;
}

测试一下结果，nice完成啦！！！！

四、const迭代器

1.set的const迭代器

我们的代码还有一点点问题，如下，set的key竟然可以修改，这并不是我们想要的。

库里面set是如下处理的，首先在RBTree里添加了const迭代器，然后set里面的普通迭代器和const迭代器都是调用的RBTree里的const迭代器，目的就是不要修改key值。

至于为什么需要const迭代器，这是STL的规定，因为之前的容器都有const迭代器。

map是的处理如下，普通的就是普通的，const就是const的，普通的key不可以修改，value可以修改，const迭代器key和value都不可以修改

那么现在我们的目的是要把const迭代器搞出来。

在红黑树的迭代器中，我们只有T& 和T*要去取出节点里面的值，那么为了防止修改，只需要给这两个地方添加上const就可以了。但是如果仅仅给T传参的时候传const T，那么肯定是不符合要求的，因为这样我们创建的结点Node的类型也是const T，那岂不是会让Node里面的_data或者其他内容无法修改，这肯定不行我们想要的。

因此我们可以借鉴库里的方法，类模板传递三个参数，修改方法如下，普通的就传递<T,T*,T&>，const的就传递<T,const T*,const T&>，这样就符合我们的要求了，是普通迭代器里面的内容就可以修改，const的无法修改

同时还得在RBTree里添加const版本的begin()和end()。如下

const_iterator begin() const 
{
	Node* cur = _root;
	while (cur && cur->_left)
	{
		cur = cur->_left;
	}
	return const_iterator(cur);
}

const_iterator end() const
{
	return const_iterator(nullptr);
}

同时在set里面修改一下，将iterator和const_iterator都typedef为RBTree里的const_iterator，这样就都没办法修改了，还有一点，我们并不需要再重写const_iterator的const版本的begin()和const版本的end()，因为虽然看着返回值是iterator，实际上被我们typedef成了const_iterator。只需要在结尾添加上const即可

现在我们就不能修改了。

但是现在我们取消了修改，代码还是报错了

报错内容为insert的时候类型匹配不上（注意，这里返回类型K写出了，应该为bool）

为什么会报这种错误呢？

看下面分析，set里的iterator被我们typedef了，他的本质是const_iterator 模板类型为<T,const T*,const T&>，而RBTree里面的iterator就是iterator模板类型为<T, T*,T&>，他们类型不一样。（这里并不是权限缩小的问题，是类模板参数不一样）

有点难理解没关系，我们再看下面，这样看是不是就更清楚了他们类型不一样

2.解决方案1（解决了set）（建议直接看解决方案2）

那么对于这个报错我们可以如何修改呢？

其实很简单，只需要将RBTree里面的返回类型和返回结果修改一下就好，如下

虽然看起来有那么一点点非主流，但是这确实是一个可行方案，并且很容易理解。

那么为什么这样修改就可以运行了呢？

这就要提到pair的构造了，下面我们将pair的构造展开

现在分析一下，为什么pair<Node*,bool>能够初始化pair<const_iterator,bool>（第一个参数表面上是iterator，本质是const_iterator）？

因为const_iterator也是可以通过Node*来构造。这是我们迭代器的构造函数啊,如下

下面我们再捋一捋流程图，看看是怎么构造的，首先，set调用了插入，会调用RBTree的插入，返回回来类型，发现pair的类型不同，不能拷贝构造，于是他会尝试看能不能进行构造，发现__TreeIterator有这么一个类，并且可以构造，于是就完成了iterator的构造了。

3.map的const迭代器

map的普通迭代器是key不能修改，而value可以修改，const迭代器是key和value都不可以修改，因此他不能像set一样，普通是const，const也是const。

我们在map里面添加上如下方框框起来的代码。

4.解决方案2（解决map和set）

再去看一看能不能运行map的const迭代器，并且查看map的second是否可以修改

那我们再仔细看看为何报错？

他们的区别是多了两个const

也就是这一句

我们翻译一下，他的意思就是不能从普通迭代器变成const迭代器，所针对的就是如下代码，从iterator到const_iterator这条路行不通

那么我们应该如何修改呢？

首先我们应该要想到构造函数，我们写出一个从iterator到const_iterator的构造函数就好了。具体如何写，我们还是可以参考一下库里面的内容。

库里面是如何操作的？

首先用类模板的第一个参数构造typedef一个iterator。这代表着无论你传递的Ref和Ptr是普通的还是const版本的，经过我只取第一个参数typedef的操作，我都能保证他是普通的，那么我用普通迭代器来进行构造。

1.如果你传递的Ref和Ptr是普通的，我就相当于拷贝构造。

2.如果你传递的Ref和Ptr是const的，我就相当于从普通版本，构造成了const版本。

这样就符合我们的条件了。

那我们跟着库里面进行编写代码，写出如下代码。

再查看就不报错了，只有不能修改的错误，我们代码删除就好了

测试运行，大功告成！！！

五、总结

回到之前的问题，为什么map和set的封装第一个参数需要K，能不能不要K？

先说答案，不能。虽然我们在insert插入函数里面并没有用到K类型，但如果是Find函数呢，你肯定是德通过Key类型去传递参数查找吧，我们所传递的第三个参数KeyOfT，他仅仅能取出第二参数T里面的内容，他不能推断T里面的参数类型，因此第一个参数K不能省略

map和set的封装并不比红黑树简单，需要肚兜理解，并且我们实现的还仅仅是简单版本，还有反向迭代器和除插入之外的函数都没有完成，但这一部分，也是足够我们学习红黑树和map、set的性质了。希望与大家共勉！！！

最后附上总代码

RBTree.h

#pragma once

enum color
{
	RED,
	BLACK
};

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

template<class T,class Ptr,class Ref>
struct __TreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef __TreeIterator<T, T*, T&> iterator;
	typedef __TreeIterator<T,Ptr,Ref> Self;

	__TreeIterator(Node* node)
		:_node(node)
	{}

	//iterator为普通迭代器，如果传入的Ptr和Ref是const版本
	//那么我们现在就是在用普通迭代器去构造const迭代器
	__TreeIterator(const iterator& it) 
		:_node(it._node)
	{}

	Ref operator*()
	{
		return _node->_data;
	}

	Ptr operator->()
	{
		return &_node->_data;
	}

	Self& operator++()
	{
		if (_node->_right)
		{
			Node* cur = _node->_right;
			while (cur->_left)
			{
				cur = cur->_left;
			}
			_node = cur;
		}
		else
		{
			Node* cur = _node;
			Node* parent = _node->_parent;
			while (parent && parent->_right == cur)
			{
				cur = parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}

	Self& operator--()
	{
		if (_node->_left)
		{
			Node* cur = _node->_left;
			while (cur->_right)
			{
				cur = cur->_right;
			}
			_node = cur;
		}
		else
		{
			Node* cur = _node;
			Node* parent = _node->_parent;
			while (parent && parent->_left == cur)
			{
				cur = parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}

	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}

	bool operator==(const Self& s)
	{
		return _node == s._node;
	}

	Node* _node;
};


// set->RBTree<K,K,SetKeyOfT> _t;
// map->RBTree<K.pair<K,T>,MapKeyOfT> _t;
template<class K,class T,class KeyOfT>
class RBTree
{
	KeyOfT koft;
	typedef RBTreeNode<T> Node;
public:
	typedef __TreeIterator <T,const T*,const T&> const_iterator;
	typedef __TreeIterator<T,T*,T&> iterator;
	iterator begin()
	{
		Node* cur = _root;
		while (cur && cur->_left)
		{
			cur = cur->_left;
		}
		return iterator(cur);
	}

	iterator end()
	{
		return iterator(nullptr);
	}

	const_iterator begin() const 
	{
		Node* cur = _root;
		while (cur && cur->_left)
		{
			cur = cur->_left;
		}
		return const_iterator(cur);
	}

	const_iterator end() const
	{
		return const_iterator(nullptr);
	}

	pair<iterator,bool> Insert(const T& data)
	{
		Node* cur = _root;
		Node* parent = _root;
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return make_pair(_root,true) ;
		}
		while (cur)
		{
			if (koft(cur->_data) < koft(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (koft(cur->_data) > koft(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return make_pair(cur, false);
			}
		}
		if (koft(parent->_data) > koft(data))
		{
			parent->_left = new Node(data);
			cur = parent->_left;
		}
		else
		{
			parent->_right = new Node(data);
			cur = parent->_right;
		}
		cur->_parent = parent;
		while (parent && parent->_col == RED)
		{
			Node* grandparent = parent->_parent;

			if (grandparent->_left == parent)
			{
				//     g
				//   p   u
				// c
				Node* uncle = grandparent->_right;
				if (uncle && uncle->_col == RED)
				{
					//变颜色
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandparent->_col = RED;
					//往上更新
					cur = grandparent;
					parent = grandparent->_parent;
				}
				else
				{
					//     g
					//   p   u
					// c
					if(cur == parent->_left)
					{
						RotateR(grandparent);
						grandparent->_col = RED;
						parent->_col = BLACK;
						break;
					}
					//      g
					//   p     u
					//    c
					else
					{
						RotateL(parent);
						RotateR(grandparent);
						cur->_col = BLACK;
						grandparent->_col = RED;
						break;
					}
				}
			}
			else  //grandparent->_right == parent
			{
				//     g
				//   u   p
				//         c
				Node* uncle = grandparent->_left;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandparent->_col = RED;
					cur = grandparent;
					parent = grandparent->_parent;
				}
				else
				{
					//     g
					//   u   p
					//         c
					if (parent->_right == cur)
					{
						RotateL(grandparent);
						parent->_col = BLACK;
						grandparent->_col = RED;
						break;
					}
					else
					{
						//     g
						//   u   p
						//      c
						RotateR(parent);
						RotateL(grandparent);

						cur->_col = BLACK;
						grandparent->_col = RED;
						break;
					}
				}
			}
		}
		_root->_col = BLACK;
		return make_pair(cur, false);
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	bool Check(Node* root,int BlackNum,int valRef)
	{
		if (root == nullptr)
		{
			if(BlackNum == valRef)
			{
				return true;
			}
			else
			{
				cout << "每条路径黑色结点个数不等" << endl;
				return false;
			}
		}
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "有连续的红色节点" << endl;
			return false;
		}
		if (root->_col == BLACK)
		{
			BlackNum++;
		}
		return Check(root->_left,BlackNum,valRef) && Check(root->_right, BlackNum, valRef);
	}

	bool IsBalance()
	{
		if (_root == nullptr)
			return true;
		if (_root->_col == RED)
			return false;
		int valRef = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				valRef++;
			cur = cur->_left;
		}
		int BlackNum = 0;
		return Check(_root,BlackNum,valRef);
	}

private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_data << " ";
		_InOrder(root->_right);
	}
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
		subL->_right = parent;
		Node* grandparent = parent->_parent;
		parent->_parent = subL;
		if (grandparent == nullptr)
		{
			_root = subL;
			subL->_parent = nullptr;
			return;
		}
		if (grandparent->_left == parent)
		{
			grandparent->_left = subL;
		}
		else
		{
			grandparent->_right = subL;
		}
		subL->_parent = grandparent;
	}
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;
		subR->_left = parent;
		Node* grandparent = parent->_parent;
		parent->_parent = subR;
		if (grandparent == nullptr)
		{
			_root = subR;
			_root->_parent = nullptr;
			return;
		}
		if (grandparent->_left == parent)
		{
			grandparent->_left = subR;
		}
		else
		{
			grandparent->_right = subR;
		}
		subR->_parent = grandparent;
	}
	Node* _root = nullptr;
};

set.h

#pragma once
#include"RBTree.h"
namespace kky
{
	template<class K>
	class set
	{
	public:
		struct SetKeyofT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
		//对类模板取内嵌类型，需要加typename告诉编译器这是类型,等对象实例化
		typedef typename RBTree<K,K,SetKeyofT>::const_iterator iterator;
		typedef typename RBTree<K,K,SetKeyofT>::const_iterator const_iterator;
		iterator begin() const
		{
			return _t.begin();
		}

		iterator end() const
		{
			return _t.end();
		}

		pair<iterator, bool> Insert(const K& key)
		{
			return _t.Insert(key);
		}
		bool IsBalance()
		{
			return _t.IsBalance();
		}
		void InOrder()
		{
			_t.InOrder();
		}
	private:RBTree<K, K,SetKeyofT> _t;
	};
}

map.h

#pragma once
#include"RBTree.h"
namespace kky
{
	template<class K,class V>
	class map
	{
	public:
		struct MapKeyofT
		{
			const K& operator()(const pair<const K, V>& kv)
			{
				return kv.first;
			}
		};
		typedef typename RBTree<K, pair<const K, V>, MapKeyofT>::iterator iterator;
		typedef typename RBTree<K, pair<const K, V>, MapKeyofT>::const_iterator const_iterator;
		iterator begin()
		{
			return _t.begin();
		}

		iterator end()
		{
			return _t.end();
		}

		const_iterator begin() const
		{
			return _t.begin();
		}

		const_iterator end() const
		{
			return _t.end();
		}

		pair<iterator, bool> Insert(const pair<K, V>& kv)
		{
			return _t.Insert(kv);
		}
		bool IsBalance()
		{
			return _t.IsBalance();
		}
		void InOrder()
		{
			_t.InOrder();
		}
		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = Insert(make_pair(key, V()));
			return ret.first->second;
		}
	private:
		RBTree<K, pair<const K, V>,MapKeyofT> _t;
	};
}

Test.cpp

#include<iostream>
#include<vector>
#include<ctime>
using namespace std;
#include"RBTree.h"
#include"map.h"
#include"set.h"

void set_test()
{
	//const int N = 10;
	//vector<int> v;
	//v.reserve(N);
	//srand(time(0));
	//for (size_t i = 0; i < N; i++)
	//{
	//	v.push_back(rand() + i);
	//}
	//kky::set<int> rbt;
	//for (auto e : v)
	//{
	//	if (e == 24473)
	//	{
	//		int i = 0;
	//	}
	//	rbt.Insert(e);
	//	rbt.IsBalance();
	//}
	//rbt.InOrder();
	//cout << rbt.IsBalance() << endl;

	kky::set<int> rbt;
	rbt.Insert(4);
	rbt.Insert(6);
	rbt.Insert(5);
	rbt.Insert(3);
	kky::set<int>::const_iterator it = rbt.begin();
	while (it != rbt.end())
	{
		cout << *it << endl;
		++it;
	}
}

void map_test()
{
	string arr[] = {"香蕉","苹果","橘子","香蕉","苹果" ,"香蕉","苹果" ,"香蕉" };
	kky::map<string,int> rbt;
	for (auto e : arr)
	{
		rbt[e]++;
	}
	kky::map<string,int>::const_iterator it = rbt.begin();
	while (it != rbt.end())
	{
		cout << it->first<<" "<<it->second << endl;
		++it;
	}
	//kky::map<string, string> dict;
	//dict.Insert(make_pair("sort", "排序"));
	//dict.Insert(make_pair("sort", "xx"));
	//dict.Insert(make_pair("left", "左"));
	//dict.Insert(make_pair("right", "右"));
	//kky::map<string,string>::iterator it = dict.begin();
	//while (it != dict.end())
	//{
	//	cout << it->first<<" "<<it->second << endl;
	//	++it;
	//}
}

int main()
{
	set_test();
	map_test();
}

最后感谢大家的观看！！！！