用同一个树的类模板封装map(key/value)和set(key)

红黑树的Node

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(BLACK)
	{}
};

用只有一个data变量来代替map的pair<key,value> 和set的key

template<class key,class T,class KeyOfT>
struct RBTree

看红黑树的模板的我们依然保留key模板，对于Set来说key和T都是value的，对于map来说key 是 key,T是pair<key,value>。

RBTree<K, pair<K, V>,MapKeyOfT> _t;
RBTree<K, K,SetKeyOfT> _t;

由此相当于适配器模式，对于set来说第二个模板参数不是必要的。

由此我们可以思考，我们对两个对象的封装可以先统一起来某种形式，比如都提供两个模板参数。

红黑树的insert返回值由原来的bool变成了pair<iterator,bool>

pair<iterator,bool> Insert(const T& data)
//......
return make_pair(iterator(newnode), true);
//

注意实际上map和set的迭代器属性不一样，但我们返回权限大的普通迭代器，后面再分别进行const限制来适配

typedef __TreeIterator<T,T*,T&> iterator;

写红黑树的迭代器

template<class T, class Ptr, class Ref>
struct __TreeIterator
{
	typedef RBTreeNode Node;
	typedef __TreeIterator< T, Ptr, Ref> Self;
	// Iterator只可能是普通迭代器
	typedef __TreeIterator< T, T*, T&> Iterator;
	Node* _node;
	__TreeIterator(const Iterator& It)
		:_node(It._node)
	{}
	__TreeIterator(Node* node)
		:_node(node)
	{}
	 Ref operator*()
	{
		return _node->_data;
	}
	 Ptr operator->()
	 {
		 return &_node->_data;
	 }
	 Self& operator++()
	 {
		 //右边不为空
		 if (_node->right)
		 {
			 Node* leftmin = _node->_right;
			 while (leftmin->_left)
			 {
				 leftmin = leftmin->_left;
			 }
			 _node = leftmin;
			 return *this;
		 }
		 else
		 {// 右树为空
			 Node* parent = _node->_parent;
			 while (parent&&_node == parent->right)
			 {
				 _node = parent;
				 parent = _node->_parent;
			 }
			 _node = parent;
			 return *this;
		 }
	 }
	 bool operator!=(const Iterator it)const
	 {
		 return _node != it._node;
	 }
	 bool operator==(const Iterator)const
	 {
		 return _node == it._node;
	 }
	 Self& operator--()
	 {
		 //左不为空
		 if (_node->_left)
		 {
			 Node* rightmax = _node->_left;
			 while (rightmax->_right)
			 {
				 rightmax = rightmax->_right;
			 }
			 _node = rightmax;
			 return *this;
		 }
		 else
		 {
			 Node* parent = _node->_parent;
			 while (parent && parent->_right == _node)
			 {
				 _node = parent;
				 parent = _node->_parent;
			 }
			 _node = parent;
			 return *this;
		 }
	 }

};

比较重要的点是拷贝构造函数

__TreeIterator(const Iterator& It)
		:_node(It._node)
	{}

对于普通迭代器，是拷贝构造，同时它也可以接收普通迭代器来构造const 修饰的迭代器。

operate()++的分析

当右树存在时，再右子树的最大值，当右树不存在，找到parent节点向上处理，当cur是parentd1左节点时，parent就是下一个节点。

红黑树的begin()，end()方法 

typedef __TreeIterator<T,T*,T&> iterator;
	typedef __TreeIterator<T, const T*, const T&> const_iterator;
	iterator begin()
	{
		Node* leftMin = _root;
		while (leftMin && leftMin->_left)
		{
			leftMin=leftMin->_left;
		}
		return iterator(leftMin);
	}
	iterator end()
	{
		return iterator(nullptr);
	}
	const_iterator begin()const
	{
		Node* leftMin = _root;
		while (leftMin && leftMin->_left)
		{
			leftMin = leftMin->_left;
		}
		return const_iterator(leftMin);
	}
	const_iterator end()const
	{
		return const_iterator(nullptr);
	}

这里用了没有直接返回Node*指针而是返回迭代器对象，调用拷贝构造函数。

map和set的迭代器有不同的需求，对于set而言，iterator就是const_iterator。

typedef typename RBTree<K, K, SetKeyOfT>::const_iterator iterator;
typedef typename RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;

set的begin() 

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

当begin()调用时 _t.begin()返回的是iterator这是就是可以通过__TreeIterator的拷贝构造实现转换成Iterator，（其实可以直接调用const的begin()修饰的函数）

insert封装

pair<iterator, bool> insert(const K& key)
		{
			pair<typename RBTree<K, K, SetKeyOfT>::iterator, bool>ret = _t.Insert(key);
			return pair<iterator, bool>(ret.first, ret.second);
		}

注意此时的问题，insert规定返回值必须是pair<iterator, bool>，RBTree返回的值实际是iterator,myset返回的iterator实际是const_iterator。不能直接返回会导致权限的缩小，所以要再构造。

而map的迭代器要确保pair<key,value>的key不会改变。方法是给模板参数上const

typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator;
typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::const_iterator const_iterator;