template<class K, class T>
class RBTree

template<class K>
class set
{
public:
	//...
private:
	RBTree<K, K> _t;
};

template<class K, class V>
class map
{
public:
	//...
private:
	RBTree<K, pair<K, V>> _t;
};

//紅黑樹(shù)結(jié)點(diǎn)的定義
template<class T>
struct RBTreeNode
{
	//三叉鏈
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
 
	//存儲(chǔ)的數(shù)據(jù)
	T _data;
 
	//結(jié)點(diǎn)的顏色
	int _col;
 
	//構(gòu)造函數(shù)
	RBTreeNode(const T& data)
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(RED)
	{}
};

template<class K>
class set
{
	//仿函數(shù)
	struct SetKeyOfT
	{
		const K& operator()(const K& key) //返回鍵值Key
		{
			return key;
		}
	};
public:
	//...
private:
	RBTree<K, K, SetKeyOfT> _t;
};

template<class K, class V>
class map
{
	//仿函數(shù)
	struct MapKeyOfT
	{
		const K& operator()(const pair<K, V>& kv) //返回鍵值對(duì)當(dāng)中的鍵值Key
		{
			return kv.first;
		}
	};
public:
	//...
private:
	RBTree<K, pair<K, V>, MapKeyOfT> _t;
};

template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node; //結(jié)點(diǎn)的類型
public:
    //...
private:
    Node* _root;
}

//查找函數(shù)
iterator Find(const K& key)
{
	KeyOfT kot;
	Node* cur = _root;
	while (cur)
	{
		if (key < kot(cur->_data)) //key值小于該結(jié)點(diǎn)的值
		{
			cur = cur->_left; //在該結(jié)點(diǎn)的左子樹(shù)當(dāng)中查找
		}
		else if (key > kot(cur->_data)) //key值大于該結(jié)點(diǎn)的值
		{
			cur = cur->_right; //在該結(jié)點(diǎn)的右子樹(shù)當(dāng)中查找
		}
		else //找到了目標(biāo)結(jié)點(diǎn)
		{
			return iterator(cur); //返回該結(jié)點(diǎn)
		}
	}
	return end(); //查找失敗
}

//正向迭代器
template<class T, class Ref, class Ptr>
struct __TreeIterator
{
    typedef RBTreeNode<T> Node; //結(jié)點(diǎn)的類型
    typedef __TreeIterator<T, Ref, Ptr> Self; //正向迭代器的類型
 
    Node* _node; //正向迭代器所封裝結(jié)點(diǎn)的指針
};

//構(gòu)造函數(shù)
__TreeIterator(Node* node)
    :_node(node) //根據(jù)所給結(jié)點(diǎn)指針構(gòu)造一個(gè)正向迭代器
{}

Ref operator*()
{
    return _node->_data; //返回結(jié)點(diǎn)數(shù)據(jù)的引用
}

Ptr operator->()
{
    return &_node->_data; //返回結(jié)點(diǎn)數(shù)據(jù)的指針
}

//判斷兩個(gè)正向迭代器是否不同
bool operator!=(const Self& s) const
{
    return _node != s._node; //判斷兩個(gè)正向迭代器所封裝的結(jié)點(diǎn)是否是同一個(gè)
}
//判斷兩個(gè)正向迭代器是否相同
bool operator==(const Self& s) const
{
    return _node == s._node; //判斷兩個(gè)正向迭代器所封裝的結(jié)點(diǎn)是否是同一個(gè)
}

//前置++
Self operator++()
{
	if (_node->_right) //結(jié)點(diǎn)的右子樹(shù)不為空
	{
		//尋找該結(jié)點(diǎn)右子樹(shù)當(dāng)中的最左結(jié)點(diǎn)
		Node* left = _node->_right;
		while (left->_left)
		{
			left = left->_left;
		}
		_node = left; //++后變?yōu)樵摻Y(jié)點(diǎn)
	}
	else //結(jié)點(diǎn)的右子樹(shù)為空
	{
		//尋找孩子不在父親右的祖先
		Node* cur = _node;
		Node* parent = cur->_parent;
		while (parent&&cur == parent->_right)
		{
			cur = parent;
			parent = parent->_parent;
		}
		_node = parent; //++后變?yōu)樵摻Y(jié)點(diǎn)
	}
	return *this;
}

//前置--
Self operator--()
{
	if (_node->_left) //結(jié)點(diǎn)的左子樹(shù)不為空
	{
		//尋找該結(jié)點(diǎn)左子樹(shù)當(dāng)中的最右結(jié)點(diǎn)
		Node* right = _node->_left;
		while (right->_right)
		{
			right = right->_right;
		}
		_node = right; //--后變?yōu)樵摻Y(jié)點(diǎn)
	}
	else //結(jié)點(diǎn)的左子樹(shù)為空
	{
		//尋找孩子不在父親左的祖先
		Node* cur = _node;
		Node* parent = cur->_parent;
		while (parent&&cur == parent->_left)
		{
			cur = parent;
			parent = parent->_parent;
		}
		_node = parent; //--后變?yōu)樵摻Y(jié)點(diǎn)
	}
	return *this;
}

template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node; //結(jié)點(diǎn)的類型
public:
	typedef __TreeIterator<T, T&, T*> iterator; //正向迭代器
	
	iterator begin()
	{
		//尋找最左結(jié)點(diǎn)
		Node* left = _root;
		while (left&&left->_left)
		{
			left = left->_left;
		}
		//返回最左結(jié)點(diǎn)的正向迭代器
		return iterator(left);
	}
	iterator end()
	{
		//返回由nullptr構(gòu)造得到的正向迭代器（不嚴(yán)謹(jǐn)）
		return iterator(nullptr);
	}
private:
	Node* _root; //紅黑樹(shù)的根結(jié)點(diǎn)
};

//反向迭代器---迭代器適配器
template<class Iterator>
struct ReverseIterator
{
	typedef ReverseIterator<Iterator> Self; //反向迭代器的類型
    
    //限定符不能區(qū)分靜態(tài)變量和類型，所以前面可以加上typename標(biāo)識(shí)為類型
	typedef typename Iterator::reference Ref; //結(jié)點(diǎn)指針的引用
	typedef typename Iterator::pointer Ptr; //結(jié)點(diǎn)指針
 
	Iterator _it; //反向迭代器所封裝的正向迭代器
 
	//構(gòu)造函數(shù)
	ReverseIterator(Iterator it)
		:_it(it) //根據(jù)所給正向迭代器構(gòu)造一個(gè)反向迭代器
	{}
 
	Ref operator*()
	{
		return *_it; //通過(guò)調(diào)用正向迭代器的operator*返回結(jié)點(diǎn)數(shù)據(jù)的引用
	}
	Ptr operator->()
	{
		return _it.operator->(); //通過(guò)調(diào)用正向迭代器的operator->返回結(jié)點(diǎn)數(shù)據(jù)的指針
	}
 
	//前置++
	Self& operator++()
	{
		--_it; //調(diào)用正向迭代器的前置--
		return *this;
	}
	//前置--
	Self& operator--()
	{
		++_it; //調(diào)用正向迭代器的前置++
		return *this;
	}
 
	bool operator!=(const Self& s) const
	{
		return _it != s._it; //調(diào)用正向迭代器的operator!=
	}
	bool operator==(const Self& s) const
	{
		return _it == s._it; //調(diào)用正向迭代器的operator==
	}
};

//正向迭代器
template<class T, class Ref, class Ptr>
struct __TreeIterator
{
	typedef Ref reference; //結(jié)點(diǎn)指針的引用
	typedef Ptr pointer; //結(jié)點(diǎn)指針
};

template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node; //結(jié)點(diǎn)的類型
public:
	typedef ReverseIterator<iterator> reverse_iterator; //反向迭代器
	
	reverse_iterator rbegin()
	{
		//尋找最右結(jié)點(diǎn)
		Node* right = _root;
		while (right&&right->_right)
		{
			right = right->_right;
		}
		//返回最右結(jié)點(diǎn)的反向迭代器
		return reverse_iterator(iterator(right));
	}
	reverse_iterator rend()
	{
		//返回由nullptr構(gòu)造得到的反向迭代器（不嚴(yán)謹(jǐn)）
		return reverse_iterator(iterator(nullptr));
	}
private:
	Node* _root; //紅黑樹(shù)的根結(jié)點(diǎn)
};

#pragma once
 
//枚舉定義結(jié)點(diǎn)的顏色
enum Colour
{
	RED,
	BLACK
};
 
//紅黑樹(shù)結(jié)點(diǎn)的定義
template<class T>
struct RBTreeNode
{
	//三叉鏈
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
 
	//存儲(chǔ)的數(shù)據(jù)
	T _data;
 
	//結(jié)點(diǎn)的顏色
	int _col; //紅/黑
 
	//構(gòu)造函數(shù)
	RBTreeNode(const T& data)
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(RED)
	{}
};
 
//正向迭代器
template<class T, class Ref, class Ptr>
struct __TreeIterator
{
	typedef Ref reference; //結(jié)點(diǎn)指針的引用
	typedef Ptr pointer; //結(jié)點(diǎn)指針
 
	typedef RBTreeNode<T> Node; //結(jié)點(diǎn)的類型
	typedef __TreeIterator<T, Ref, Ptr> Self; //正向迭代器的類型
 
	Node* _node; //正向迭代器所封裝結(jié)點(diǎn)的指針
 
	//構(gòu)造函數(shù)
	__TreeIterator(Node* node)
		:_node(node) //根據(jù)所給結(jié)點(diǎn)指針構(gòu)造一個(gè)正向迭代器
	{}
 
	Ref operator*()
	{
		return _node->_data; //返回結(jié)點(diǎn)數(shù)據(jù)的引用
	}
	Ptr operator->()
	{
		return &_node->_data; //返回結(jié)點(diǎn)數(shù)據(jù)的指針
	}
	//判斷兩個(gè)正向迭代器是否不同
	bool operator!=(const Self& s) const
	{
		return _node != s._node; //判斷兩個(gè)正向迭代器所封裝的結(jié)點(diǎn)是否是同一個(gè)
	}
	//判斷兩個(gè)正向迭代器是否相同
	bool operator==(const Self& s) const
	{
		return _node == s._node; //判斷兩個(gè)正向迭代器所封裝的結(jié)點(diǎn)是否是同一個(gè)
	}
 
	//前置++
	Self operator++()
	{
		if (_node->_right) //結(jié)點(diǎn)的右子樹(shù)不為空
		{
			//尋找該結(jié)點(diǎn)右子樹(shù)當(dāng)中的最左結(jié)點(diǎn)
			Node* left = _node->_right;
			while (left->_left)
			{
				left = left->_left;
			}
			_node = left; //++后變?yōu)樵摻Y(jié)點(diǎn)
		}
		else //結(jié)點(diǎn)的右子樹(shù)為空
		{
			//尋找孩子不在父親右的祖先
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_right)
			{
				cur = parent;
				parent = parent->_parent;
			}
			_node = parent; //++后變?yōu)樵摻Y(jié)點(diǎn)
		}
		return *this;
	}
 
	//前置--
	Self operator--()
	{
		if (_node->_left) //結(jié)點(diǎn)的左子樹(shù)不為空
		{
			//尋找該結(jié)點(diǎn)左子樹(shù)當(dāng)中的最右結(jié)點(diǎn)
			Node* right = _node->_left;
			while (right->_right)
			{
				right = right->_right;
			}
			_node = right; //--后變?yōu)樵摻Y(jié)點(diǎn)
		}
		else //結(jié)點(diǎn)的左子樹(shù)為空
		{
			//尋找孩子不在父親左的祖先
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_left)
			{
				cur = parent;
				parent = parent->_parent;
			}
			_node = parent; //--后變?yōu)樵摻Y(jié)點(diǎn)
		}
		return *this;
	}
};
 
//反向迭代器---迭代器適配器
template<class Iterator>
struct ReverseIterator
{
	typedef ReverseIterator<Iterator> Self; //反向迭代器的類型
	typedef typename Iterator::reference Ref; //結(jié)點(diǎn)指針的引用
	typedef typename Iterator::pointer Ptr; //結(jié)點(diǎn)指針
 
	Iterator _it; //反向迭代器所封裝的正向迭代器
 
	//構(gòu)造函數(shù)
	ReverseIterator(Iterator it)
		:_it(it) //根據(jù)所給正向迭代器構(gòu)造一個(gè)反向迭代器
	{}
 
	Ref operator*()
	{
		return *_it; //通過(guò)調(diào)用正向迭代器的operator*返回結(jié)點(diǎn)數(shù)據(jù)的引用
	}
	Ptr operator->()
	{
		return _it.operator->(); //通過(guò)調(diào)用正向迭代器的operator->返回結(jié)點(diǎn)數(shù)據(jù)的指針
	}
 
	//前置++
	Self& operator++()
	{
		--_it; //調(diào)用正向迭代器的前置--
		return *this;
	}
	//前置--
	Self& operator--()
	{
		++_it; //調(diào)用正向迭代器的前置++
		return *this;
	}
 
	bool operator!=(const Self& s) const
	{
		return _it != s._it; //調(diào)用正向迭代器的operator!=
	}
	bool operator==(const Self& s) const
	{
		return _it == s._it; //調(diào)用正向迭代器的operator==
	}
};
 
//紅黑樹(shù)的實(shí)現(xiàn)
template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node; //結(jié)點(diǎn)的類型
public:
	typedef __TreeIterator<T, T&, T*> iterator; //正向迭代器
	typedef ReverseIterator<iterator> reverse_iterator; //反向迭代器
 
	reverse_iterator rbegin()
	{
		//尋找最右結(jié)點(diǎn)
		Node* right = _root;
		while (right && right->_right)
		{
			right = right->_right;
		}
		//返回最右結(jié)點(diǎn)的反向迭代器
		return reverse_iterator(iterator(right));
	}
	reverse_iterator rend()
	{
		//返回由nullptr構(gòu)造得到的反向迭代器（不嚴(yán)謹(jǐn)）
		return reverse_iterator(iterator(nullptr));
	}
 
	iterator begin()
	{
		//尋找最左結(jié)點(diǎn)
		Node* left = _root;
		while (left && left->_left)
		{
			left = left->_left;
		}
		//返回最左結(jié)點(diǎn)的正向迭代器
		return iterator(left);
	}
	iterator end()
	{
		//返回由nullptr構(gòu)造得到的正向迭代器（不嚴(yán)謹(jǐn)）
		return iterator(nullptr);
	}
	//構(gòu)造函數(shù)
	RBTree()
		:_root(nullptr)
	{}
 
	//拷貝構(gòu)造
	RBTree(const RBTree<K, T, KeyOfT>& t)
	{
		_root = _Copy(t._root, nullptr);
	}
 
	//賦值運(yùn)算符重載（現(xiàn)代寫法）
	RBTree<K, T, KeyOfT>& operator=(RBTree<K, T, KeyOfT> t)
	{
		swap(_root, t._root);
		return *this; //支持連續(xù)賦值
	}
 
	//析構(gòu)函數(shù)
	~RBTree()
	{
		_Destroy(_root);
		_root = nullptr;
	}
 
	//查找函數(shù)
	iterator Find(const K& key)
	{
		KeyOfT kot;
		Node* cur = _root;
		while (cur)
		{
			if (key < kot(cur->_data)) //key值小于該結(jié)點(diǎn)的值
			{
				cur = cur->_left; //在該結(jié)點(diǎn)的左子樹(shù)當(dāng)中查找
			}
			else if (key > kot(cur->_data)) //key值大于該結(jié)點(diǎn)的值
			{
				cur = cur->_right; //在該結(jié)點(diǎn)的右子樹(shù)當(dāng)中查找
			}
			else //找到了目標(biāo)結(jié)點(diǎn)
			{
				return iterator(cur); //返回該結(jié)點(diǎn)
			}
		}
		return end(); //查找失敗
	}
 
	//插入函數(shù)
	pair<iterator, bool> Insert(const T& data)
	{
		if (_root == nullptr) //若紅黑樹(shù)為空樹(shù)，則插入結(jié)點(diǎn)直接作為根結(jié)點(diǎn)
		{
			_root = new Node(data);
			_root->_col = BLACK; //根結(jié)點(diǎn)必須是黑色
			return make_pair(iterator(_root), true); //插入成功
		}
		//1、按二叉搜索樹(shù)的插入方法，找到待插入位置
		KeyOfT kot;
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (kot(data) < kot(cur->_data)) //待插入結(jié)點(diǎn)的key值小于當(dāng)前結(jié)點(diǎn)的key值
			{
				//往該結(jié)點(diǎn)的左子樹(shù)走
				parent = cur;
				cur = cur->_left;
			}
			else if (kot(data) > kot(cur->_data)) //待插入結(jié)點(diǎn)的key值大于當(dāng)前結(jié)點(diǎn)的key值
			{
				//往該結(jié)點(diǎn)的右子樹(shù)走
				parent = cur;
				cur = cur->_right;
			}
			else //待插入結(jié)點(diǎn)的key值等于當(dāng)前結(jié)點(diǎn)的key值
			{
				return make_pair(iterator(cur), false); //插入失敗
			}
		}
 
		//2、將待插入結(jié)點(diǎn)插入到樹(shù)中
		cur = new Node(data); //根據(jù)所給值構(gòu)造一個(gè)結(jié)點(diǎn)
		Node* newnode = cur; //記錄新插入的結(jié)點(diǎn)（便于后序返回）
		if (kot(data) < kot(parent->_data)) //新結(jié)點(diǎn)的key值小于parent的key值
		{
			//插入到parent的左邊
			parent->_left = cur;
			cur->_parent = parent;
		}
		else //新結(jié)點(diǎn)的key值大于parent的key值
		{
			//插入到parent的右邊
			parent->_right = cur;
			cur->_parent = parent;
		}
 
		//3、若插入結(jié)點(diǎn)的父結(jié)點(diǎn)是紅色的，則需要對(duì)紅黑樹(shù)進(jìn)行調(diào)整
		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent; //parent是紅色，則其父結(jié)點(diǎn)一定存在
			if (parent == grandfather->_left) //parent是grandfather的左孩子
			{
				Node* uncle = grandfather->_right; //uncle是grandfather的右孩子
				if (uncle && uncle->_col == RED) //情況1：uncle存在且為紅
				{
					//顏色調(diào)整
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
 
					//繼續(xù)往上處理
					cur = grandfather;
					parent = cur->_parent;
				}
				else //情況2+情況3：uncle不存在 + uncle存在且為黑
				{
					if (cur == parent->_left)
					{
						RotateR(grandfather); //右單旋
 
						//顏色調(diào)整
						grandfather->_col = RED;
						parent->_col = BLACK;
					}
					else //cur == parent->_right
					{
						RotateLR(grandfather); //左右雙旋
 
						//顏色調(diào)整
						grandfather->_col = RED;
						cur->_col = BLACK;
					}
					break; //子樹(shù)旋轉(zhuǎn)后，該子樹(shù)的根變成了黑色，無(wú)需繼續(xù)往上進(jìn)行處理
				}
			}
			else //parent是grandfather的右孩子
			{
				Node* uncle = grandfather->_left; //uncle是grandfather的左孩子
				if (uncle && uncle->_col == RED) //情況1：uncle存在且為紅
				{
					//顏色調(diào)整
					uncle->_col = parent->_col = BLACK;
					grandfather->_col = RED;
 
					//繼續(xù)往上處理
					cur = grandfather;
					parent = cur->_parent;
				}
				else //情況2+情況3：uncle不存在 + uncle存在且為黑
				{
					if (cur == parent->_left)
					{
						RotateRL(grandfather); //右左雙旋
 
						//顏色調(diào)整
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					else //cur == parent->_right
					{
						RotateL(grandfather); //左單旋
 
						//顏色調(diào)整
						grandfather->_col = RED;
						parent->_col = BLACK;
					}
					break; //子樹(shù)旋轉(zhuǎn)后，該子樹(shù)的根變成了黑色，無(wú)需繼續(xù)往上進(jìn)行處理
				}
			}
		}
		_root->_col = BLACK; //根結(jié)點(diǎn)的顏色為黑色（可能被情況一變成了紅色，需要變回黑色）
		return make_pair(iterator(newnode), true); //插入成功
	}
 
private:
	//拷貝樹(shù)
	Node* _Copy(Node* root, Node* parent)
	{
		if (root == nullptr)
		{
			return nullptr;
		}
		Node* copyNode = new Node(root->_data);
		copyNode->_parent = parent;
		copyNode->_left = _Copy(root->_left, copyNode);
		copyNode->_right = _Copy(root->_right, copyNode);
		return copyNode;
	}
 
	//析構(gòu)函數(shù)子函數(shù)
	void _Destroy(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Destroy(root->_left);
		_Destroy(root->_right);
		delete root;
	}
 
	//左單旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		Node* parentParent = parent->_parent;
 
		//建立subRL與parent之間的聯(lián)系
		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;
 
		//建立parent與subR之間的聯(lián)系
		subR->_left = parent;
		parent->_parent = subR;
 
		//建立subR與parentParent之間的聯(lián)系
		if (parentParent == nullptr)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			if (parent == parentParent->_left)
			{
				parentParent->_left = subR;
			}
			else
			{
				parentParent->_right = subR;
			}
			subR->_parent = parentParent;
		}
	}
 
	//右單旋
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* parentParent = parent->_parent;
 
		//建立subLR與parent之間的聯(lián)系
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
 
		//建立parent與subL之間的聯(lián)系
		subL->_right = parent;
		parent->_parent = subL;
 
		//建立subL與parentParent之間的聯(lián)系
		if (parentParent == nullptr)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (parent == parentParent->_left)
			{
				parentParent->_left = subL;
			}
			else
			{
				parentParent->_right = subL;
			}
			subL->_parent = parentParent;
		}
	}
 
	//左右雙旋
	void RotateLR(Node* parent)
	{
		RotateL(parent->_left);
		RotateR(parent);
	}
 
	//右左雙旋
	void RotateRL(Node* parent)
	{
		RotateR(parent->_right);
		RotateL(parent);
	}
 
	Node* _root=nullptr; //紅黑樹(shù)的根結(jié)點(diǎn)
};

#pragma once
 
#include "RBTree.h"
 
namespace MySet
{
	template<class K>
	class set
	{
		//仿函數(shù)
		struct SetKeyOfT
		{
			const K& operator()(const K& key) //返回鍵值Key
			{
				return key;
			}
		};
	public:
		typedef typename RBTree<K, const K, SetKeyOfT>::iterator iterator; //正向迭代器
		typedef typename RBTree<K, const K, SetKeyOfT>::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();
		}
 
		//插入函數(shù)
		pair<iterator, bool> insert(const K& key)
		{
			return _t.Insert(key);
		}
 
		//查找函數(shù)
		iterator find(const K& key)
		{
			return _t.Find(key);
		}
	private:
		RBTree<K, const K, SetKeyOfT> _t;
	};
 
	void test_set1()
	{
		set<int> s;
		int a[] = { 4,2,6,1,3,5,15,7,16,14 };
 
		for (auto e : a)
		{
			s.insert(e);
		}
 
		set<int>::iterator it = s.begin();
		while (it != s.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}
}

#pragma once
 
#include "RBTree.h"
 
namespace MyMap
{
	template<class K, class V>
	class map
	{
		//仿函數(shù)
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv) //返回鍵值對(duì)當(dāng)中的鍵值Key
			{
				return kv.first;
			}
		};
	public:
		typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator; //正向迭代器
		typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::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();
		}
 
		//插入函數(shù)
		pair<iterator, bool> insert(const pair<const K, V>& kv)
		{
			return _t.Insert(kv);
		}
		//[]運(yùn)算符重載函數(shù)
		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = insert(make_pair(key, V()));
			iterator it = ret.first;
			return it->second;
		}
		//查找函數(shù)
		iterator find(const K& key)
		{
			return _t.Find(key);
		}
	private:
		RBTree<K, pair<const K, V>, MapKeyOfT> _t;
	};
 
	void test_map1()
	{
		map<int, int> m;
		int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
		for (auto e : a)
		{
			m.insert(make_pair(e, e));
		}
 
		map<int, int>::iterator it = m.begin();
		while (it != m.end())
		{
			//it->first += 100;
			it->second += 100;
 
			cout << it->first << ":" << it->second << endl;
			++it;
		}
		cout << endl;
	}
}