set和map的底层实现

set和map的底层都是红黑树，这里需要对set 和 map中封装一颗红黑树即可。

先模拟实现实现红黑树的迭代器
节点：

template < class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;

	Color _color;
	T _data;        //这里唯一需要差别的是_data, 对于set传过来是key，而map是键值对pair<>

	RBTreeNode(const T& x)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_color(RED)
		,_data(x)
	{}
};

对于树的迭代器

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

	Node* _node;

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

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

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

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

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

	//中序遍历 左  根 右
	Self& operator++()
	{
		if (_node->_right)
		{
			Node* left = _node->_right;
			while (left->_left)
			{
				left = left->_left;
			}
			_node = left;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;

			while (parent && parent->_right == cur)
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}

	//反着走  右 左 根
	Self& operator--()
	{
		if (_node->_left)
		{
			Node* right = _node->_left;
			while (right->_right)
			{
				right = right->_right;
			}
			_node = right;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && parent->_left == cur)
			{
				cur = cur->_parent;
				parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}
};

树是如何访问key的呢？（部分代码）

template <class K, class T,class keyofT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	RBTree()
		:_root(nullptr)
	{}

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

	iterator begin()  //  左  根  右
	{
		Node* left = _root;
		while (left && left->_left)
		{
			left = left->_left;
		}

		return iterator(left);
	}

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


	pair<Node*, bool> Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_color = BLACK;
			return pair<Node*, bool>(_root, true);
		}

		keyofT kot;

		Node* cur = _root, * parent = _root;
		while (cur)
		{
			if (kot(data) > kot(cur->_data))  //通过仿函数去获取各自的key
			

set的实现细节

#include"RBTree.h"

namespace chen
{
	template<class K>
	class set
	{
		struct SetofT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};

	public:
		typedef typename RBTree<K, K, SetofT>::iterator iterator;


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

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

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

	private:
		RBTree<K, K, SetofT> _t;
	};
}

map的实现细节

namespace chen
{
	template<class K, class T>
	class map
	{
		struct Mapofkey
		{
			const K& operator()(const pair<K, T>& kv)
			{
				return kv.first;
			}
		};

	public:
        typedef typename RBTree<K, pair<K, T>, Mapofkey>::iterator iterator;
		iterator begin()
		{
			return _t.begin();
		}

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

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


	private:
		RBTree<K, pair<K, T>, Mapofkey> _t;
	};

}