c 用一棵红黑树同时封装出set与map的实现代码-kb88凯时官网登录

免费资源网,https://freexyz.cn/

前言

我们了解到set中存储的一般为键k即可，而map存储的一般都是键值对kv，也就是说他们结构是不同的，那么我们如何才能用一颗红黑树同时封装出set与map两种容器呢？

简单的说就是模板的使用，对于set存储的，对于map存储的是>;

那么红黑树我们就可以使用模板，比如rbtree，t就是这个模板类，当set使用时就是k，当map使用时就是pair。

那么接下来我们具体地来研究下stl库中是怎样实现的，并且进行模拟实现。

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

template
class rbtree

那么对于set：

template
class set
{
public:
	//...
private:
	rbtree _t;
};

对于map：

template
class map
{
public:
	//...
private:
	rbtree> _t;
};

即：

思考：既然对于map来说pair中有k，那么是不是可以将第一个模板参数省略呢？

• 对于set容器来说：可以，因为set传入红黑树的第二个参数与第一个参数是一样的；
• 对于map容器来说：不行，因为map容器所提供的接口当中有些是只要求给出键值key的，比如find和erase。

2.红黑树节点的定义 

//红黑树结点的定义
template
struct rbtreenode
{
	//三叉链
	rbtreenode* _left;
	rbtreenode* _right;
	rbtreenode* _parent;
 
	//存储的数据
	t _data;
 
	//结点的颜色
	int _col;
 
	//构造函数
	rbtreenode(const t& data)
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(red)
	{}
};

对于模板参数t来说，set使用就是k，map使用就是pair，对应着set与map中节点存储的数据类型。

3.pair的比较规则引出红黑树仿函数设计

红黑树是一棵二叉搜索树，所以当我们寻找插入位置或者查找时一定会比较节点值之间的大小。

新插入节点值小于当前节点值，就往左走；

新插入节点值大于当前节点值，就往右走；

这是之前学习二叉搜索树最基本的特性，那么问题来了，对于map而言，节点值存储的是pair，可是pair是依据什么来决定自身的大小呢？first？second？还是什么？

我们来看一下stl库中对pair比较大小的定义：

可我们期望的比较规则是这样么？

很明显不是，我们期望的是set与map都只依据key来比较大小。

那么我们就需要想办法构造一个我们自己比较的方式出来。

首先比较的是key，所以我们需要想办法取出key，对于set而言那就是key，对于map而言是pair的first，所以我们可以在红黑树中设计仿函数来统一设计，然后在set和map中具体实现即可。

set：

template
class set
{
	//仿函数
	struct setkeyoft
	{
		const k& operator()(const k& key) //返回键值key
		{
			return key;
		}
	};
public:
	//...
private:
	rbtree _t;
};

map：

template
class map
{
	//仿函数
	struct mapkeyoft
	{
		const k& operator()(const pair& kv) //返回键值对当中的键值key
		{
			return kv.first;
		}
	};
public:
	//...
private:
	rbtree, mapkeyoft> _t;
};

rbtree：

template
class rbtree
{
	typedef rbtreenode node; //结点的类型
public:
    //...
private:
    node* _root;
}

即：

在实现红黑树时，只需要创建这个keyoft类对象，就相当于实例化了对应的set或map中实际的方法，比如：

//查找函数
iterator find(const k& key)
{
	keyoft kot;
	node* cur = _root;
	while (cur)
	{
		if (key < kot(cur->_data)) //key值小于该结点的值
		{
			cur = cur->_left; //在该结点的左子树当中查找
		}
		else if (key > kot(cur->_data)) //key值大于该结点的值
		{
			cur = cur->_right; //在该结点的右子树当中查找
		}
		else //找到了目标结点
		{
			return iterator(cur); //返回该结点
		}
	}
	return end(); //查找失败
}

所以对于红黑树来说，所有对应的需要比较的部分我们都需要进行修改。 

4.红黑树的正向迭代器 

红黑树的正向迭代器实际上就是对结点指针进行了封装，因此在正向迭代器当中实际上就只有一个成员变量，那就是正向迭代器所封装结点的指针。

4.1迭代器的定义 

//正向迭代器
template
struct __treeiterator
{
    typedef rbtreenode node; //结点的类型
    typedef __treeiterator self; //正向迭代器的类型
 
    node* _node; //正向迭代器所封装结点的指针
};

4.2迭代器的构造 

我们通过一个结点的指针便可以构造出一个正向迭代器。

//构造函数
__treeiterator(node* node)
    :_node(node) //根据所给结点指针构造一个正向迭代器
{}

4.3重载解引用操作符 * 

当对正向迭代器进行解引用操作时，我们直接返回对应结点数据的引用即可。

ref operator*()
{
    return _node->_data; //返回结点数据的引用
}

4.4重载箭头操作符 -> 

当对正向迭代器进行->操作时，我们直接返回对应结点数据的指针即可。

ptr operator->()
{
    return &_node->_data; //返回结点数据的指针
}

注意：这里与链表list部分的->操作符重载一样，返回的是地址，即使用时为了可读性省略了一个->。 

4.5重载 == 和 != 操作符 

实现时直接判断两个迭代器所封装的结点是否是同一个即可。

//判断两个正向迭代器是否不同
bool operator!=(const self& s) const
{
    return _node != s._node; //判断两个正向迭代器所封装的结点是否是同一个
}
//判断两个正向迭代器是否相同
bool operator==(const self& s) const
{
    return _node == s._node; //判断两个正向迭代器所封装的结点是否是同一个
}

4.6重载 、-- 操作符 

之前链表list迭代器的 操作符重载的逻辑非常简单，只需要 node=node->next即可，但是对于一棵二叉搜索树而言显然不会这么简单。

那么按照搜索的逻辑，我们知道 应该得到的是中序遍历的后一个节点。

根据图像我们可以推导出 的逻辑： 

• 如果当前结点的右子树不为空，则 操作后应该找到其右子树当中的最左结点。
• 如果当前结点的右子树为空，则 操作后应该在该结点的祖先结点中，找到孩子不在父亲右的祖先。

//前置  
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&&cur == parent->_right)
		{
			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&&cur == parent->_left)
		{
			cur = parent;
			parent = parent->_parent;
		}
		_node = parent; //--后变为该结点
	}
	return *this;
}

正向迭代器实现后，我们需要在红黑树的实现当中进行迭代器类型的typedef。

需要注意的是，为了让外部能够使用typedef后的正向迭代器类型iterator，我们需要在public区域进行typedef。

然后在红黑树当中实现成员函数begin和end：

• begin函数返回中序序列当中第一个结点的正向迭代器，即最左结点。
• end函数返回中序序列当中最后一个结点下一个位置的正向迭代器，这里直接用空指针构造一个正向迭代器。

template
class rbtree
{
	typedef rbtreenode node; //结点的类型
public:
	typedef __treeiterator iterator; //正向迭代器
	
	iterator begin()
	{
		//寻找最左结点
		node* left = _root;
		while (left&&left->_left)
		{
			left = left->_left;
		}
		//返回最左结点的正向迭代器
		return iterator(left);
	}
	iterator end()
	{
		//返回由nullptr构造得到的正向迭代器（不严谨）
		return iterator(nullptr);
	}
private:
	node* _root; //红黑树的根结点
};

但这样实现的end()迭代器其实并不符合要求，因为如果对end()位置的迭代器--后，应该得到最后一个位置的正向迭代器，但这里很明显无法实现。

实际上在stl库中是这样设计的：

在红黑树的根节点新增一个头节点，这个头结点的左孩子为最左节点，右孩子为最右节点。

在这样的结构下，正向迭代器的begin()只需用头节点的左孩子构造即可，反向迭代器的rbegin()只需用头结点的右孩子构造出一个正向迭代器然后再对该正向迭代器进行封装，得到反向迭代器即可。end和rend()

但是如果红黑树加入了这个头节点，就会改变之前我们实现的红黑树的很多逻辑，这里就不实现了。

5.红黑树的反向迭代器

还记得我们之前学习过的反向迭代器的实现么？

反向迭代器需不需要我们从零开始写呢？还是和适配器一样，利用普通迭代器的结构满足反向迭代器的特性即可？这样是不是比较方便？

• rbegin()相当于end()
• rend()相当于begin()
• 反向迭代器 相当于正向迭代器--
• 其他操作* != ->和正向迭代器相同

//反向迭代器---迭代器适配器
template
struct reverseiterator
{
	typedef reverseiterator self; //反向迭代器的类型
    
    //限定符不能区分静态变量和类型，所以前面可以加上typename标识为类型
	typedef typename iterator::reference ref; //结点指针的引用
	typedef typename iterator::pointer ptr; //结点指针
 
	iterator _it; //反向迭代器所封装的正向迭代器
 
	//构造函数
	reverseiterator(iterator it)
		:_it(it) //根据所给正向迭代器构造一个反向迭代器
	{}
 
	ref operator*()
	{
		return *_it; //通过调用正向迭代器的operator*返回结点数据的引用
	}
	ptr operator->()
	{
		return _it.operator->(); //通过调用正向迭代器的operator->返回结点数据的指针
	}
 
	//前置  
	self& operator  ()
	{
		--_it; //调用正向迭代器的前置--
		return *this;
	}
	//前置--
	self& operator--()
	{
		  _it; //调用正向迭代器的前置  
		return *this;
	}
 
	bool operator!=(const self& s) const
	{
		return _it != s._it; //调用正向迭代器的operator!=
	}
	bool operator==(const self& s) const
	{
		return _it == s._it; //调用正向迭代器的operator==
	}
};

需要注意的是，反向迭代器只接收了一个模板参数，即正向迭代器的类型，也就是说，反向迭代器不知道结点的引用类型和结点的指针类型，因此我们需要在正向迭代器当中对这两个类型进行typedef，这样反向迭代器才能通过正向迭代器获取结点的引用类型和结点的指针类型。

//正向迭代器
template
struct __treeiterator
{
	typedef ref reference; //结点指针的引用
	typedef ptr pointer; //结点指针
};

反向迭代器的rbegin()：红黑树的最右节点；

反向迭代器的rend()：空指针构造；

template
class rbtree
{
	typedef rbtreenode node; //结点的类型
public:
	typedef reverseiterator reverse_iterator; //反向迭代器
	
	reverse_iterator rbegin()
	{
		//寻找最右结点
		node* right = _root;
		while (right&&right->_right)
		{
			right = right->_right;
		}
		//返回最右结点的反向迭代器
		return reverse_iterator(iterator(right));
	}
	reverse_iterator rend()
	{
		//返回由nullptr构造得到的反向迭代器（不严谨）
		return reverse_iterator(iterator(nullptr));
	}
private:
	node* _root; //红黑树的根结点
};

注意：此时迭代器指向的值可以被修改，而在set中我们存储的是,map中存储的是>，为了防止二叉树遭到破坏，所以我们需要进行类似这样的处理：

• set;
• map>;

6.完整代码

rbtree.h

#pragma once
 
//枚举定义结点的颜色
enum colour
{
	red,
	black
};
 
//红黑树结点的定义
template
struct rbtreenode
{
	//三叉链
	rbtreenode* _left;
	rbtreenode* _right;
	rbtreenode* _parent;
 
	//存储的数据
	t _data;
 
	//结点的颜色
	int _col; //红/黑
 
	//构造函数
	rbtreenode(const t& data)
		: _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(red)
	{}
};
 
//正向迭代器
template
struct __treeiterator
{
	typedef ref reference; //结点指针的引用
	typedef ptr pointer; //结点指针
 
	typedef rbtreenode node; //结点的类型
	typedef __treeiterator self; //正向迭代器的类型
 
	node* _node; //正向迭代器所封装结点的指针
 
	//构造函数
	__treeiterator(node* node)
		:_node(node) //根据所给结点指针构造一个正向迭代器
	{}
 
	ref operator*()
	{
		return _node->_data; //返回结点数据的引用
	}
	ptr operator->()
	{
		return &_node->_data; //返回结点数据的指针
	}
	//判断两个正向迭代器是否不同
	bool operator!=(const self& s) const
	{
		return _node != s._node; //判断两个正向迭代器所封装的结点是否是同一个
	}
	//判断两个正向迭代器是否相同
	bool operator==(const self& s) const
	{
		return _node == s._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 && cur == parent->_right)
			{
				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 && cur == parent->_left)
			{
				cur = parent;
				parent = parent->_parent;
			}
			_node = parent; //--后变为该结点
		}
		return *this;
	}
};
 
//反向迭代器---迭代器适配器
template
struct reverseiterator
{
	typedef reverseiterator self; //反向迭代器的类型
	typedef typename iterator::reference ref; //结点指针的引用
	typedef typename iterator::pointer ptr; //结点指针
 
	iterator _it; //反向迭代器所封装的正向迭代器
 
	//构造函数
	reverseiterator(iterator it)
		:_it(it) //根据所给正向迭代器构造一个反向迭代器
	{}
 
	ref operator*()
	{
		return *_it; //通过调用正向迭代器的operator*返回结点数据的引用
	}
	ptr operator->()
	{
		return _it.operator->(); //通过调用正向迭代器的operator->返回结点数据的指针
	}
 
	//前置  
	self& operator  ()
	{
		--_it; //调用正向迭代器的前置--
		return *this;
	}
	//前置--
	self& operator--()
	{
		  _it; //调用正向迭代器的前置  
		return *this;
	}
 
	bool operator!=(const self& s) const
	{
		return _it != s._it; //调用正向迭代器的operator!=
	}
	bool operator==(const self& s) const
	{
		return _it == s._it; //调用正向迭代器的operator==
	}
};
 
//红黑树的实现
template
class rbtree
{
	typedef rbtreenode node; //结点的类型
public:
	typedef __treeiterator iterator; //正向迭代器
	typedef reverseiterator reverse_iterator; //反向迭代器
 
	reverse_iterator rbegin()
	{
		//寻找最右结点
		node* right = _root;
		while (right && right->_right)
		{
			right = right->_right;
		}
		//返回最右结点的反向迭代器
		return reverse_iterator(iterator(right));
	}
	reverse_iterator rend()
	{
		//返回由nullptr构造得到的反向迭代器（不严谨）
		return reverse_iterator(iterator(nullptr));
	}
 
	iterator begin()
	{
		//寻找最左结点
		node* left = _root;
		while (left && left->_left)
		{
			left = left->_left;
		}
		//返回最左结点的正向迭代器
		return iterator(left);
	}
	iterator end()
	{
		//返回由nullptr构造得到的正向迭代器（不严谨）
		return iterator(nullptr);
	}
	//构造函数
	rbtree()
		:_root(nullptr)
	{}
 
	//拷贝构造
	rbtree(const rbtree& t)
	{
		_root = _copy(t._root, nullptr);
	}
 
	//赋值运算符重载（现代写法）
	rbtree& operator=(rbtree t)
	{
		swap(_root, t._root);
		return *this; //支持连续赋值
	}
 
	//析构函数
	~rbtree()
	{
		_destroy(_root);
		_root = nullptr;
	}
 
	//查找函数
	iterator find(const k& key)
	{
		keyoft kot;
		node* cur = _root;
		while (cur)
		{
			if (key < kot(cur->_data)) //key值小于该结点的值
			{
				cur = cur->_left; //在该结点的左子树当中查找
			}
			else if (key > kot(cur->_data)) //key值大于该结点的值
			{
				cur = cur->_right; //在该结点的右子树当中查找
			}
			else //找到了目标结点
			{
				return iterator(cur); //返回该结点
			}
		}
		return end(); //查找失败
	}
 
	//插入函数
	pair insert(const t& data)
	{
		if (_root == nullptr) //若红黑树为空树，则插入结点直接作为根结点
		{
			_root = new node(data);
			_root->_col = black; //根结点必须是黑色
			return make_pair(iterator(_root), true); //插入成功
		}
		//1、按二叉搜索树的插入方法，找到待插入位置
		keyoft kot;
		node* cur = _root;
		node* parent = nullptr;
		while (cur)
		{
			if (kot(data) < kot(cur->_data)) //待插入结点的key值小于当前结点的key值
			{
				//往该结点的左子树走
				parent = cur;
				cur = cur->_left;
			}
			else if (kot(data) > kot(cur->_data)) //待插入结点的key值大于当前结点的key值
			{
				//往该结点的右子树走
				parent = cur;
				cur = cur->_right;
			}
			else //待插入结点的key值等于当前结点的key值
			{
				return make_pair(iterator(cur), false); //插入失败
			}
		}
 
		//2、将待插入结点插入到树中
		cur = new node(data); //根据所给值构造一个结点
		node* newnode = cur; //记录新插入的结点（便于后序返回）
		if (kot(data) < kot(parent->_data)) //新结点的key值小于parent的key值
		{
			//插入到parent的左边
			parent->_left = cur;
			cur->_parent = parent;
		}
		else //新结点的key值大于parent的key值
		{
			//插入到parent的右边
			parent->_right = cur;
			cur->_parent = parent;
		}
 
		//3、若插入结点的父结点是红色的，则需要对红黑树进行调整
		while (parent && parent->_col == red)
		{
			node* grandfather = parent->_parent; //parent是红色，则其父结点一定存在
			if (parent == grandfather->_left) //parent是grandfather的左孩子
			{
				node* uncle = grandfather->_right; //uncle是grandfather的右孩子
				if (uncle && uncle->_col == red) //情况1：uncle存在且为红
				{
					//颜色调整
					parent->_col = uncle->_col = black;
					grandfather->_col = red;
 
					//继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else //情况2 情况3：uncle不存在   uncle存在且为黑
				{
					if (cur == parent->_left)
					{
						rotater(grandfather); //右单旋
 
						//颜色调整
						grandfather->_col = red;
						parent->_col = black;
					}
					else //cur == parent->_right
					{
						rotatelr(grandfather); //左右双旋
 
						//颜色调整
						grandfather->_col = red;
						cur->_col = black;
					}
					break; //子树旋转后，该子树的根变成了黑色，无需继续往上进行处理
				}
			}
			else //parent是grandfather的右孩子
			{
				node* uncle = grandfather->_left; //uncle是grandfather的左孩子
				if (uncle && uncle->_col == red) //情况1：uncle存在且为红
				{
					//颜色调整
					uncle->_col = parent->_col = black;
					grandfather->_col = red;
 
					//继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else //情况2 情况3：uncle不存在   uncle存在且为黑
				{
					if (cur == parent->_left)
					{
						rotaterl(grandfather); //右左双旋
 
						//颜色调整
						cur->_col = black;
						grandfather->_col = red;
					}
					else //cur == parent->_right
					{
						rotatel(grandfather); //左单旋
 
						//颜色调整
						grandfather->_col = red;
						parent->_col = black;
					}
					break; //子树旋转后，该子树的根变成了黑色，无需继续往上进行处理
				}
			}
		}
		_root->_col = black; //根结点的颜色为黑色（可能被情况一变成了红色，需要变回黑色）
		return make_pair(iterator(newnode), true); //插入成功
	}
 
private:
	//拷贝树
	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;
	}
 
	//析构函数子函数
	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之间的联系
		parent->_right = subrl;
		if (subrl)
			subrl->_parent = parent;
 
		//建立parent与subr之间的联系
		subr->_left = parent;
		parent->_parent = subr;
 
		//建立subr与parentparent之间的联系
		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之间的联系
		parent->_left = sublr;
		if (sublr)
			sublr->_parent = parent;
 
		//建立parent与subl之间的联系
		subl->_right = parent;
		parent->_parent = subl;
 
		//建立subl与parentparent之间的联系
		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; //红黑树的根结点
};

myset.h

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

mymap.h

#pragma once
 
#include "rbtree.h"
 
namespace mymap
{
	template
	class map
	{
		//仿函数
		struct mapkeyoft
		{
			const k& operator()(const pair& kv) //返回键值对当中的键值key
			{
				return kv.first;
			}
		};
	public:
		typedef typename rbtree, mapkeyoft>::iterator iterator; //正向迭代器
		typedef typename rbtree, 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();
		}
 
		//插入函数
		pair insert(const pair& kv)
		{
			return _t.insert(kv);
		}
		//[]运算符重载函数
		v& operator[](const k& key)
		{
			pair ret = insert(make_pair(key, v()));
			iterator it = ret.first;
			return it->second;
		}
		//查找函数
		iterator find(const k& key)
		{
			return _t.find(key);
		}
	private:
		rbtree, mapkeyoft> _t;
	};
 
	void test_map1()
	{
		map m;
		int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
		for (auto e : a)
		{
			m.insert(make_pair(e, e));
		}
 
		map::iterator it = m.begin();
		while (it != m.end())
		{
			//it->first  = 100;
			it->second  = 100;
 
			cout << it->first << ":" << it->second << endl;
			  it;
		}
		cout << endl;
	}
}

以上就是c 用一棵红黑树同时封装出set与map的实现详解的详细内容，更多关于c 红黑树封装set与map的资料请关注其它相关文章！