【C++】使用红黑树封装map和set

最新推荐文章于 2025-10-12 23:27:16 发布
原创 最新推荐文章于 2025-10-12 23:27:16 发布 · 583 阅读 · 21 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #红黑树 #map #set #数据结构

文章目录

前言

在上一篇文章中，我们详细介绍了红黑树的实现，内容很重要，请大家务必掌握！那么本篇文章将带大家详细讲解红黑树封装map和set的实现，接下来一起看看吧！

一. 源码及框架分析

map和set的实现结构框架核心部分截取出来如下：

// set
#ifndef __SGI_STL_INTERNAL_TREE_H
#include <stl_tree.h>
#endif
#include <stl_set.h>
#include <stl_multiset.h>
// map
#ifndef __SGI_STL_INTERNAL_TREE_H
#include <stl_tree.h>
#endif
#include <stl_map.h>
#include <stl_multimap.h>
// stl_set.h
template <class Key, class Compare = less<Key>, class Alloc = alloc>
class set {
public:
	// typedefs:
	typedef Key key_type;
	typedef Key value_type;
private:
	typedef rb_tree<key_type, value_type,
		identity<value_type>, key_compare, Alloc> rep_type;
	rep_type t; // red-black tree representing set
};
// stl_map.h
template <class Key, class T, class Compare = less<Key>, class Alloc = alloc>
class map {
public:
	// typedefs:
	typedef Key key_type;
	typedef T mapped_type;
	typedef pair<const Key, T> value_type;
private:
	typedef rb_tree<key_type, value_type,
		select1st<value_type>, key_compare, Alloc> rep_type;
	rep_type t; // red-black tree representing map
};
// stl_tree.h
struct __rb_tree_node_base
{
	typedef __rb_tree_color_type color_type;
	typedef __rb_tree_node_base* base_ptr;
	color_type color;
	base_ptr parent;
	base_ptr left;
	base_ptr right;
};
// stl_tree.h
template <class Key, class Value, class KeyOfValue, class Compare, class Alloc
	= alloc>
class rb_tree {
protected:
	typedef void* void_pointer;
	typedef __rb_tree_node_base* base_ptr;
	typedef __rb_tree_node<Value> rb_tree_node;
	typedef rb_tree_node* link_type;
	typedef Key key_type;
	typedef Value value_type;
public:
	// insert⽤的是第⼆个模板参数左形参
	pair<iterator, bool> insert_unique(const value_type& x);
	// erase和find⽤第⼀个模板参数做形参
	size_type erase(const key_type& x);
	iterator find(const key_type& x);
protected:
	size_type node_count; // keeps track of size of tree
	link_type header;
};
template <class Value>
struct __rb_tree_node : public __rb_tree_node_base
{
	typedef __rb_tree_node<Value>* link_type;
	Value value_field;
};

通过下图对框架的分析，我们可以看到源码中rb_tree用了一个巧妙的泛型思想实现，rb_tree是实现key的搜索场景，还是key/value的搜索场景不是直接写死的，而是由第二个模板参数Value决定_rb_tree_node中存储的数据类型。

  • set实例化rb_tree时第二个模板参数给的是key，map实例化rb_tree时第二个模板参数给的是pair<const key, T>，这样一颗红黑树既可以实现key搜索场景的set，也可以实现key/value搜索场景的map。
  • 要注意一下，源码里面模板参数是用T代表value，而内部写的value_type不是我们我们日常key/value场景中说的value，源码中的value_type反而是红黑树结点中存储的真实的数据的类型。
  • rb_tree第二个模板参数Value已经控制了红黑树结点中存储的数据类型，为什么还要传第一个模板参数Key呢？尤其是set，两个模板参数是一样的。要注意的是对于map和set，find/erase时的函数参数都是Key，所以第一个模板参数传给find/erase等函数做形参的类型的。对于set而言两个参数都是一样的，但是对于map而言就完全不一样了，map的insert的对象是pair对象，但是find和erase的是Key对象。

二. 模拟实现map和set

2.1 复用红黑树框架并实现insert

红黑树的模板参数至少要用到三个：

template<class K, class T, class KeyOfT>

K表示存储的Key值，T表示实际存储的数据类型，KeyOfT的作用是什么？

首先insert的是T类型，但是我们并不知道T是Key还是pair<const K,V>，那么该如何比较大小呢？

看一下pair对象的比较方法是什么：
在这里插入图片描述

可以看到库里面的pair比较大小的方法是first大就大，first小就小，first相等则比较second。

但是我们不需要这样的比较方式，我们就想比较first（Key），first相等就相等。

这个时候KeyOfT就派上用场了：

KeyOfT是一个仿函数，通过重载operator()方法获得T中的K
如果T是K则返回K，如果T是pair<K,V>则返回K

我们只需要在set和map类中实现一个内部类MapKeyOfT和SetKeyOfT，再直接传过去给红黑树的第三个模板参数就可以了，这样RBTree就可以拿到T中的K。

实现insert

RBTree.h

// 枚举值表示颜色
enum  Color
{
	RED,
	BLACK
};
// T存储实际存储的数据类型
template<class T>
struct RBTreeNode
{
	// 这里更新控制平衡也要加入parent指针
	T _kv;
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	Color _col;

	RBTreeNode(const T& kv)
		:_kv(kv),
		_left(nullptr),
		_right(nullptr),
		_parent(nullptr),
		_col(RED)
	{
	}
};
template<class K, class T, class KeyOfT>
class RBTree
{
	KeyOfT kot;
public:
	typedef RBTreeNode<T> Node;
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr) {
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (kv.first > cur->_kv.first) {
				parent = cur;
				cur = cur->_right;
			}
			else if (kv.first < cur->_kv.first) {
				parent = cur;
				cur = cur->_left;
			}
			else {
				return false;
			}
		}
		cur = new Node(kv);
		// 新增节点，颜色红色
		cur->_col = RED;
		cur->_parent = parent;
		if (kv.first > parent->_kv.first) {
			parent->_right = cur;
		}
		else {
			parent->_left = cur;
		}
		//对不满足规则的情况进行调整
		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			//   g
			// p   u
			if (grandfather->_left == parent) {
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_col == RED) {
					// 叔叔存在且为红，变色再继续往上处理
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;
					cur = grandfather;
					parent = cur->_parent;
				}
				else {
					// 叔叔不存在或存在且为黑，旋转+变色
					if (parent->_left == cur) {
						//    g
						//  p   u
						//c
						//单旋
						RotateR(grandfather);
						grandfather->_col = RED;
						parent->_col = BLACK;
					}
					else {
						//    g
						//  p   u
						//    c
						//双旋
						RotateL(parent);
						RotateR(grandfather);
						grandfather->_col = RED;
						cur->_col = BLACK;
					}
					break;
				}
			}
			else {
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED) {
					// 叔叔存在且为红，变色再继续往上处理
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;
					cur = grandfather;
					parent = cur->_parent;
				}
				else {
					// 叔叔不存在或存在且为黑，旋转+变色
					if (parent->_right == cur) {
						//   g
						// u   p
						//       c
						// 单旋
						RotateL(grandfather);
						grandfather->_col = RED;
						parent->_col = BLACK;
					}
					else {
						//   g
						// u   p
						//   c
						// 双旋
						RotateR(parent);
						RotateL(grandfather);
						grandfather->_col = RED;
						cur->_col = BLACK;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}
private:
	// 右单旋
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
	
		subL->_right = parent;
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
		Node* parentParent = parent->_parent;
		parent->_parent = subL;
		if (parentParent == nullptr) {
			// 如果parent为根节点则更新根节点
			_root = subL;
			subL->_parent = nullptr;
		}
		else {
			// subL和parentParent建立联系
			if (parentParent->_left == parent) {
				parentParent->_left = subL;
			}
			else {
				parentParent->_right = subL;
			}
			subL->_parent = parentParent;
		}
	}
	
	//左单旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
	
		subR->_left = parent;
		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;
		Node* parentParent = parent->_parent;
		parent->_parent = subR;
		if (parentParent == nullptr) {
			// 如果parent为根节点则更新根节点
			_root = subR;
			subR->_parent = nullptr;
		}
		else {
			// subR和parentParent建立联系
			if (parentParent->_left == parent) {
				parentParent->_left = subR;
			}
			else {
				parentParent->_right = subR;
			}
			subR->_parent = parentParent;
		}
	}
private:
	Node* _root = nullptr;
};

mymap.h

map的iterator不支持修改key但是可以修改value，我们把map的第二个模板参数pair的第一个参
数改成const K即可， RBTree<K, pair<const K, V>, MapKeyOfT> _rbtree;

namespace MyMap
{
	template<class K, class V>
	class map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		map() = default;
		bool insert(const pair<const K, V>& kv)
		{
			return _rbtree.Insert(kv);
		}
	private:
		RBTree<K, pair<const K, V>, MapKeyOfT> _rbtree;
	};
}

myset.h

set的iterator也不支持修改，我们把set的第二个模板参数改成const K即可， RBTree<K, const K, SetKeyOfT> _rbtree;

namespace MySet
{
	template<class K>
	class set
	{
		struct SetKeyOfT {
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		set() = default;
		bool insert(const K& kv)
		{
			return _rbtree.Insert(kv);
		}
	private:
		RBTree<K, const K, SetKeyOfT> _rbtree;
	};
}

2.2 支持iterator的实现

iterator的核心源码：

struct __rb_tree_base_iterator
{
	typedef __rb_tree_node_base::base_ptr base_ptr;
	base_ptr node;
	void increment()
	{
		if (node->right != 0) {
			node = node->right;
			while (node->left != 0)
				node = node->left;
		}
		else {
			base_ptr y = node->parent;
			while (node == y->right) {
				node = y;
				y = y->parent;
			}
			if (node->right != y)
				node = y;
		}
	}
	void decrement()
	{
		if (node->color == __rb_tree_red &&
			node->parent->parent == node)
			node = node->right;
		else if (node->left != 0) {
			base_ptr y = node->left;
			while (y->right != 0)
				y = y->right;
			node = y;
		}
		else {
			base_ptr y = node->parent;
			while (node == y->left) {
				node = y;
				y = y->parent;
			}
			node = y;
		}
	}
};
template <class Value, class Ref, class Ptr>
struct __rb_tree_iterator : public __rb_tree_base_iterator
{
	typedef Value value_type;
	typedef Ref reference;
	typedef Ptr pointer;
	typedef __rb_tree_iterator<Value, Value&, Value*> iterator;
	__rb_tree_iterator() {}
	__rb_tree_iterator(link_type x) { node = x; }
	__rb_tree_iterator(const iterator& it) { node = it.node; }
	reference operator*() const { return link_type(node)->value_field; }
#ifndef __SGI_STL_NO_ARROW_OPERATOR
	pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
	self& operator++() { increment(); return *this; }
	self& operator--() { decrement(); return *this; }
	inline bool operator==(const __rb_tree_base_iterator& x,
		const __rb_tree_base_iterator& y) {
		return x.node == y.node;
	}
	inline bool operator!=(const __rb_tree_base_iterator& x,
		const __rb_tree_base_iterator& y) {
		return x.node != y.node;
	}
}

iterator实现的大框架跟list的iterator思路是一致的，用一个类型封装结点的指针，再通过重载运算符实现，迭代器像指针一样访问的行为。

2.2.1 基本的运算符重载

template<class T, class Ref, class Ptr>
struct RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef RBTreeIterator<T, Ref, Ptr> Self;
	RBTreeIterator(Node* node)
		:_node(node),
	{
	}
	Ref operator*()
	{
		return _node->_kv;
	}
	Ptr operator->()
	{
		return &_node->_kv;
	}
	bool operator!=(const Self& it) const
	{
		return _node != it._node;
	}
	bool operator==(const Self& it) const
	{
		return _node == it._node;
	}
	Node* _node;
};

2.2.2 operator++的重载

这里的难点是operator++和operator–的实现。之前使用部分，我们分析了，map和set的迭代器走的是中序遍历：左子树->根结点->右子树。那么begin()会返回中序第一个节点所在位置的迭代器。

如果遍历到当前节点的时候，要继续访问下一个节点应当去访问它的右子树，因为当前节点的左子树肯定遍历完了才会遍历到当前节点。

  • 如果当前节点的右子树不为空，代表当前节点的左子树访问完了，要访问下一个节点是右子树的中序第一个，一棵树中序第一个是最左节点，也就是右子树的最左节点。
  • 如果当前节点的右子树为空，代表当前节点已经访问完了且当前节点所在的子树也访问完了，要访问的下一个节点在当前节点的祖先里面，所以要沿着当前节点到根的祖先路径向上找。
  • 如何找？根据中序遍历：左子树->根结点->右子树这个访问顺序就可以发现：如果当前节点是它父亲节点的左孩子，说明父亲节点的左子树访问完了，下一个访问的节点就是父亲节点；如果当前节点是它父亲节点的右孩子，那么父亲节点的右子树访问完了，说明以父节点为根的子树也访问完了，那么下一个访问的节点需要继续往根的祖先中去找，直到找到孩子是父亲左的那个祖先就是下一个节点。

代码实现：

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;
}

2.2.3 operator–的重载

迭代器–的实现跟++的思路完全类似，逻辑正好反过来即可，因为他访问顺序是右子树->根结点->左子树。

  • 当使用迭代器遍历红黑树的节点时，如果遇到nullptr，我们就用nullptr去充当end()，当–end()判断到节点为空时，还需要特殊处理一下：让迭代器节点指针指向红黑树的最右节点（中序的最后一个）
  • 那么怎么找到最右节点？（源码使用一个哨兵位节点去充当end()，让哨兵位节点的右孩子指向最右节点，这样就可以找到了）我们这里让迭代器类增加一个成员去存储红黑树的根节点即可，通过根节点就可以找到最右节点。

代码实现：

Self& operator--()
{
	if (_node == nullptr)
	{
		Node* cur = _root;
		while (cur && cur->_right)
		{
			cur = cur->_right;
		}
		_node = cur;
	}
	else 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;
}

上面的前置++和前置–已经实现了，那么后置++和后置–就很简单了，下面看完整代码：

template<class T, class Ref, class Ptr>
struct RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef RBTreeIterator<T, Ref, Ptr> Self;
	RBTreeIterator(Node* node, Node* root)
		:_node(node),
		_root(root)
	{
	}
	Ref operator*()
	{
		return _node->_kv;
	}
	Ptr operator->()
	{
		return &_node->_kv;
	}
	bool operator!=(const Self& it) const
	{
		return _node != it._node;
	}
	bool operator==(const Self& it) const
	{
		return _node == it._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;
	}
	// 前置--
	Self& operator--()
	{
		if (_node == nullptr)
		{
			Node* cur = _root;
			while (cur && cur->_right)
			{
				cur = cur->_right;
			}
			_node = cur;
		}
		else 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;
	}
	// 后置++
	Self operator++(int)
	{
		Self tmp = *this;
		++(*this);
		return tmp;
	}
	// 后置--
	Self operator--(int)
	{
		Self tmp = *this;
		--(*this);
		return tmp;
	}
	Node* _node;
	Node* _root;
};

2.2.4 RBTree、set和map的迭代器实现

RBTree

这里begin()返回的是中序遍历的第一个节点的位置，也就是红黑树的最左节点；而end()返回的则是nullptr的位置

typedef RBTreeIterator<T, T&, T*> Iterator;
typedef RBTreeIterator<T, const T&, const T*> ConstIterator;
Iterator Begin()
{
	Node* cur = _root;
	while (cur->_left)
	{
		cur = cur->_left;
	}
	return Iterator(cur, _root);
}
Iterator End()
{
	return Iterator(nullptr, _root);
}
ConstIterator Begin() const
{
	Node* cur = _root;
	while (cur->_left)
	{
		cur = cur->_left;
	}
	return ConstIterator(cur, _root);
}
ConstIterator End() const
{
	return ConstIterator(nullptr, _root);
}

set和map

直接对RBTree的迭代器进行复用即可。

set

typedef typename RBTree<K, const K, SetKeyOfT>::Iterator iterator;
typedef typename RBTree<K, const K, SetKeyOfT>::ConstIterator const_iterator;
iterator begin()
{
	return _rbtree.Begin();
}
iterator end()
{
	return _rbtree.End();
}
const_iterator begin() const
{
	return _rbtree.Begin();
}
const_iterator end() const
{
	return _rbtree.End();
}

map

typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::Iterator iterator;
typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::ConstIterator const_iterator;
iterator begin()
{
	return _rbtree.Begin();
}
iterator end()
{
	return _rbtree.End();
}
const_iterator begin() const
{
	return _rbtree.Begin();
}
const_iterator end() const
{
	return _rbtree.End();
}

这里的typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::Iterator iterator;中的typename是告诉编译器这是个类型，因为编译器不知道Iterator是类型还是成员变量（因为编译器是按需实例化的），加了typename是明确告诉编译器这是个类型。

测试：

#include "mymap.h"
#include "myset.h"
void test_set()
{
	MySet::set<int> st;
	st.insert(1);
	st.insert(6);
	st.insert(3);
	st.insert(8);
	MySet::set<int>::iterator it = st.begin();
	while (it != st.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}
void test_map()
{
	MyMap::map<int, int> mp;
	mp.insert({ 4,40 });
	mp.insert({ 2,20 });
	mp.insert({ 1,10 });
	mp.insert({ 3,30 });
	MyMap::map<int, int>::iterator it = mp.begin();
	while (it != mp.end())
	{
		cout << it->first << " " << it->second << endl;
		++it;
	}
	cout << endl;
}
int main()
{
	test_set();
	test_map();
	return 0;
}

在这里插入图片描述

三. map的operator[]的实现

map的operator[]，我们知道它有两种功能：

  1. 查找+修改：key存在，返回value的引用
  2. 插入+修改：key不存在，插入key和value的缺省值，返回value的引用

看一下map库里面的insert函数：
在这里插入图片描述
库里面返回的是pair<iterator , bool>类型，说明：

  1. 如果key存在，则返回该节点的迭代器和false。
  2. 如果key不存在，则返回新插入节点的迭代器和true。

修改后的插入函数（RBTree）：

pair<Iterator, bool> Insert(const T& kv)
{
	if (_root == nullptr) {
		_root = new Node(kv);
		_root->_col = BLACK;
		return make_pair(Iterator(_root, _root), true);
	}
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (kot(kv) > kot(cur->_kv)) {
			parent = cur;
			cur = cur->_right;
		}
		else if (kot(kv) < kot(cur->_kv)) {
			parent = cur;
			cur = cur->_left;
		}
		else {
			return make_pair(Iterator(cur, _root), false);
		}
	}
	cur = new Node(kv);
	Node* newnode = cur;
	// 新增节点，颜色红色
	cur->_col = RED;
	cur->_parent = parent;
	if (kot(kv) > kot(parent->_kv)) {
		parent->_right = cur;
	}
	else {
		parent->_left = cur;
	}
	while (parent && parent->_col == RED)
	{
		Node* grandfather = parent->_parent;
		//   g
		// p   u
		if (grandfather->_left == parent) {
			Node* uncle = grandfather->_right;
			if (uncle && uncle->_col == RED) {
				// 叔叔存在且为红，变色再继续往上处理
				parent->_col = BLACK;
				uncle->_col = BLACK;
				grandfather->_col = RED;
				cur = grandfather;
				parent = cur->_parent;
			}
			else {
				// 叔叔不存在或存在且为黑，旋转+变色
				if (parent->_left == cur) {
					//    g
					//  p   u
					//c
					//单旋
					RotateR(grandfather);
					grandfather->_col = RED;
					parent->_col = BLACK;
				}
				else {
					//    g
					//  p   u
					//    c
					//双旋
					RotateL(parent);
					RotateR(grandfather);
					grandfather->_col = RED;
					cur->_col = BLACK;
				}
				break;
			}
		}
		else {
			Node* uncle = grandfather->_left;
			if (uncle && uncle->_col == RED) {
				// 叔叔存在且为红，变色再继续往上处理
				parent->_col = BLACK;
				uncle->_col = BLACK;
				grandfather->_col = RED;
				cur = grandfather;
				parent = cur->_parent;
			}
			else {
				// 叔叔不存在或存在且为黑，旋转+变色
				if (parent->_right == cur) {
					//   g
					// u   p
					//       c
					// 单旋
					RotateL(grandfather);
					grandfather->_col = RED;
					parent->_col = BLACK;
				}
				else {
					//   g
					// u   p
					//   c
					// 双旋
					RotateR(parent);
					RotateL(grandfather);
					grandfather->_col = RED;
					cur->_col = BLACK;
				}
				break;
			}
		}
	}
	_root->_col = BLACK;
	return make_pair(Iterator(newnode, _root), true);
}

map实现operator[]：

pair<iterator, bool> insert(const pair<K, V>& kv)
{
	return _rbtree.Insert(kv);
}
V& operator[](const K& key)
{
	pair<iterator, bool> ret = insert(make_pair(key, V()));
	return ret.first->second;
}

测试：

void test_map()
{
	MyMap::map<string, string> dict;
	dict.insert({ "sort", "排序" });
	dict.insert({ "left", "左边" });
	dict.insert({ "right", "右边" });
	dict["left"] = "左边，剩余";
	dict["insert"] = "插入";
	dict["string"];
	MyMap::map<string, string>::iterator it = dict.begin();
	while (it != dict.end())
	{
		it->second += 's';
		cout << it->first << ":" << it->second << endl;
		++it;
	}
	cout << endl;
}

在这里插入图片描述

四. set和map的erase函数（可选）

RBTree的erase比较难，感兴趣的可以看看：

// 删除
bool Erase(const K& key)
{
	if (_root == nullptr) return false;
	/*Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (key > kot(cur->_kv)) {
			parent = cur;
			cur = cur->_right;
		}
		else if (key < kot(cur->_kv)) {
			parent = cur;
			cur = cur->_left;
		}
		else {
			break;
		}
	}
	if (cur == nullptr) return false;*/

	Node* cur = Find(key)._node;
	if (cur == nullptr) {
		return false;
	}
	Node* parent = cur->_parent;
	if (cur->_left && cur->_right)
	{
		Node* minRight = cur->_right;
		Node* minRightParent = cur;
		while (minRight->_left)
		{
			minRightParent = minRight;
			minRight = minRight->_left;
		}
		// cur->_kv = minRight->_kv;
		// 用新节点代替cur，解决不能直接代替值的问题
		Node* ReplaceNode = new Node(minRight->_kv);
		ReplaceNode->_col = cur->_col;
		ReplaceNode->_left = cur->_left;
		ReplaceNode->_right = cur->_right;
		ReplaceNode->_parent = cur->_parent;
		if (ReplaceNode->_left) ReplaceNode->_left->_parent = ReplaceNode;
		if (ReplaceNode->_right) ReplaceNode->_right->_parent = ReplaceNode;
		if (cur->_parent) {
			if (cur->_parent->_left == cur) {
				cur->_parent->_left = ReplaceNode;
			}
			else {
				cur->_parent->_right = ReplaceNode;
			}
		}
		else {
			_root = ReplaceNode;
		}
		if (minRightParent == cur)
		{
			// 细节：如果minRightParent指向cur，需要将minRightParent指向ReplaceNode
			minRightParent = ReplaceNode;
		}
		// 删除原节点
		delete cur;
		cur = minRight;
		parent = minRightParent;
	}
	Node* child = nullptr;
	if (cur->_left) child = cur->_left;
	else child = cur->_right;

	if (child) child->_parent = parent;
	if (parent == nullptr) {
		_root = child;
		if (_root) _root->_col = BLACK;
		delete cur;
		return true;
	}
	if (child) {
		if (parent->_left == cur) {
			parent->_left = child;
		}
		else {
			parent->_right = child;
		}
		child->_col = BLACK;
	}
	else {
		Node* pNode = cur;
		if (pNode->_col == RED) {
			if (parent->_left == cur) {
				parent->_left = nullptr;
			}
			else {
				parent->_right = nullptr;
			}
			delete cur;
			return true;
		}
		// pNode表示双黑节点
		while (pNode)
		{
			if (pNode->_col == RED || pNode == _root)
			{
				pNode->_col = BLACK;
				break;
			}
			Node* bro = nullptr;
			if (parent->_left == pNode)
			{
				bro = parent->_right;
				if (bro->_col == BLACK)
				{
					Node* broR = bro->_right;
					Node* broL = bro->_left;
					if (broR && broR->_col == RED)
					{
						broR->_col = bro->_col;
						bro->_col = parent->_col;
						parent->_col = BLACK;
						RotateL(parent);
						break;
					}
					else if (broL && broL->_col == RED)
					{
						broL->_col = parent->_col;
						parent->_col = BLACK;
						RotateR(bro);
						RotateL(parent);
						break;
					}
					else
					{
						bro->_col = RED;
						pNode = parent;
						parent = parent->_parent;
					}
				}
				else
				{
					bro->_col = BLACK;
					parent->_col = RED;
					RotateL(parent);
				}
			}
			else
			{
				bro = parent->_left;
				if (bro->_col == BLACK)
				{
					Node* broR = bro->_right;
					Node* broL = bro->_left;
					if (broL && broL->_col == RED)
					{
						broL->_col = bro->_col;
						bro->_col = parent->_col;
						parent->_col = BLACK;
						RotateR(parent);
						break;
					}
					else if (broR && broR->_col == RED)
					{
						broR->_col = parent->_col;
						parent->_col = BLACK;
						RotateL(bro);
						RotateR(parent);
						break;
					}
					else
					{
						bro->_col = RED;
						pNode = parent;
						parent = parent->_parent;
					}
				}
				else
				{
					bro->_col = BLACK;
					parent->_col = RED;
					RotateR(parent);
				}
			}
		}
		parent = cur->_parent;
		if (parent->_left == cur) {
			parent->_left = nullptr;
		}
		else {
			parent->_right = nullptr;
		}
		delete cur;
	}
	_root->_col = BLACK;
	return true;
}

这里代替节点时不能简单地使用cur->_kv = minRight->_kv;了，因为key是不能修改的，我们可以再开辟一个新节点代替cur的位置，再删除cur节点，再让cur指向要被删除的节点即可。

代码实现：

set和map

void erase(const K& key)
{
	_rbtree.Erase(key);
}

测试：

void test_set()
{
	MySet::set<int> st;
	st.insert(1);
	st.insert(6);
	st.insert(3);
	st.insert(8);
	MySet::set<int>::iterator it = st.begin();
	while (it != st.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	st.erase(3);
	it = st.begin();
	while (it != st.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	st.erase(8);
	it = st.begin();
	while (it != st.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}
void test_map()
{
	MyMap::map<string, string> dict;
	dict.insert({ "sort", "排序" });
	dict.insert({ "left", "左边" });
	dict.insert({ "right", "右边" });
	dict["left"] = "左边，剩余";
	dict["insert"] = "插入";
	dict["string"];
	MyMap::map<string, string>::iterator it = dict.begin();
	while (it != dict.end())
	{
		it->second += 's';
		cout << it->first << ":" << it->second << endl;
		++it;
	}
	cout << endl;

	dict.erase("insert");
	auto it1 = dict.begin();
	while (it1 != dict.end())
	{
		cout << it1->first << ":" << it1->second << endl;
		++it1;
	}
	cout << endl;

	dict.erase("string");
	it1 = dict.begin();
	while (it1 != dict.end())
	{
		cout << it1->first << ":" << it1->second << endl;
		++it1;
	}
	cout << endl;
}
int main()
{
	test_set();
	test_map();
	return 0;
}

在这里插入图片描述

五. map和set的构造函数和析构函数

RBTree的构造函数和析构函数：

RBTree() = default;
~RBTree()
{
	Destory(_root);
}
RBTree(const Self& rbtree)
{
	_root = NodeCopy(rbtree._root, nullptr);
}
Self& operator=(const Self& rbtree)
{
	_root = NodeCopy(rbtree._root, nullptr);
	return *this;
}
void Destory(Node* root)
{
	if (root == nullptr) return;
	if (root->_left) Destory(root->_left);
	if (root->_right) Destory(root->_right);
	delete root;
	root = nullptr;
}

Node* NodeCopy(Node* root, Node* parent)
{
	if (root == nullptr) return nullptr;
	Node* newnode = new Node(root->_kv);
	newnode->_col = root->_col;
	newnode->_parent = parent;
	newnode->_left = NodeCopy(root->_left, newnode);
	newnode->_right = NodeCopy(root->_right, newnode);
	return newnode;
}

set的构造函数和析构函数：

set() = default;
set(initializer_list<K> il)
{
	for (const auto& e : il)
	{
		_rbtree.Insert(e);
	}
}
template<class InputIterator>
set(InputIterator first, InputIterator last)
{
	while (first != last)
	{
		_rbtree.Insert(*first);
		++first;
	}
}
set(const set& x)
{
	//_rbtree = x._rbtree;
	for (const auto& e : x)
	{
		_rbtree.Insert(e);
	}
}
set& operator=(const set& x)
{
	_rbtree = x._rbtree;
	return *this;
}

map的构造函数和析构函数：

map() = default;
map(initializer_list<pair<K, V>> il)
{
	for (const auto& e : il)
	{
		_rbtree.Insert(e);
	}
}
template<class InputIterator>
map(InputIterator first, InputIterator last)
{
	while (first != last)
	{
		_rbtree.Insert(*first);
		++first;
	}
}
map(const map& x)
{
	//_rbtree = x._rbtree;
	for (const auto& e : x)
	{
		_rbtree.Insert(e);
	}
}
map& operator=(const map& x)
{
	_rbtree = x._rbtree;
	return *this;
}

使用红黑树封装map和set的源代码：https://gitee.com/xie-zhus-shovel/c-learning/tree/master/C%2B%2BLearning/%E4%BD%BF%E7%94%A8%E7%BA%A2%E9%BB%91%E6%A0%91%E5%B0%81%E8%A3%85set%E5%92%8Cmap

最后

本篇关于使用红黑树封装map和set的实现到这里就结束了，难度还是蛮大的，需要大家多去敲代码，其中还有很多细节值得我们去探究，需要我们不断地学习。如果本篇内容对你有帮助的话就给一波三连吧，对以上内容有异议或者需要补充的，欢迎大家来讨论！

【C++】用红黑树封装set和map
春风不语。
11-13 1186
本篇内容到这里就结束啦，主要讲了如何用红黑树来封装set和map容器，希望对大家有帮助，祝生活愉快！
【C++】红黑树详解并封装实现map和set
love_guanghui的博客
03-18 3489
红黑树详解
从 .NET 到 Java 的转型指南：详细学习路线与实践建议。
最新发布
EpM_ud89的博客
10-12 378
C# 和 Java 在语法上高度相似，但仍存在关键差异。
渗透测试工具集（非常详细），从零基础入门到精通，看完这一篇就够了（附安装）
leah126的博客
01-31 3028
文件格式和网络协议剖析语言和Web IDE，使用C ++，C＃，Java，JavaScript，Perl，PHP，Python，Ruby生成解析器。- 在线密码破解工具，内置支持许多网络协议，包括HTTP，SMB，FTP，telnet，ICQ，MySQL，LDAP，IMAP，VNC等。我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。- Perl脚本，用于枚举域中的DNS信息，尝试区域传输，执行强力字典样式攻击，然后对结果执行反向查找。
2024我在优快云的年度总结，一份如何变得优秀的秘籍(3)
X7gUWZnYP的博客
04-02 766
这一年八月，我有幸认识了优快云的一些大佬，从此加入了优快云博主的队伍。写博客对于我的成长，有着莫大的帮助，一来是巩固自己的知识，二来我很喜欢别人阅读我的博客，这是一个双向的过程，读我博客的人越多，我越有动力学习，越有动力写博客。
django求职招聘网站的设计和实现(程序+开题报告)
皇森斯毕设程序
02-14 1414
6] 郭婺, 郭建, 张劲松, 石翠萍, 刘道森, 刘超. 基于Python的网络爬虫的设计与实现[J]. 信息记录材料, 2023, 24 (04): 159-162.后端框架: Python开发的 Django 框架。[4] 张华, 翟新军, 胥勇, 李伟强, 杨健, 赵嘉伟, 张涛. Python在集控大数据应用的研究[J]. 价值工程, 2023, 42 (21): 84-86.总之，通过本研究的实施，将为求职者和企业提供一个功能全面、用户体验良好的求职招聘网站，促进就业市场的健康发展。
C++封装红黑树实现map和set
05-26
C++封装红黑树实现mymap和myset
从零开始的C++之旅——红黑树封装map_set
2302_81813630的博客
12-25 1807
map和set的封装可以算是目前最难的知识点了，在实现的过程中，我也遭遇了许多困境，其中涉及了众多的知识点，我将其罗列出来并进行总结。
C++红黑树封装实现map和set模拟
本资源将通过封装红黑树来模拟实现map和set。红黑树是一种自平衡的二叉搜索树，通过对插入和删除操作的特定处理，它可以保证最坏情况下的时间复杂度为O(log n)，这对于需要高效搜索和插入操作的场景非常有用。 在...
我的创作纪念日
白昼小丑的博客
02-25 656
提示：你过去写得最好的一段代码是什么？提示：当前创作和你的工作、学习是什么样的关系。提示：可以和大家分享最初成为创作者的初心。提示：在创作的过程中都有哪些收获。提示：职业规划、创作规划等​​。
通俗易懂，什么是.NET?什么是.NET Framework？什么是.NET Core?
weixin_30435261的博客
07-02 3万+
什么是.NET？什么是.NET Framework?本文将从上往下，循序渐进的介绍一系列相关.NET的概念，先从类型系统开始讲起，我将通过跨语言操作这个例子来逐渐引入一系列.NET的相关概念，这主要包括：CLS、CTS(CLI)、FCL、Windows下CLR的相关核心组成、Windows下托管程序运行概念、什么是.NET Framework，.NET Core，.NET Standard及一些V...
新手指南｜欢迎来到优快云
优快云 官方博客
08-18 13万+
嘿，新朋友～第一次来到优快云想必有点蒙圈儿吧！C菌吐血整理了一份使用指南，带你轻松玩转优快云～ 一、登录/注册 1、PC端 1.1 微信注册登录 点击「微信注册登录」按钮，用微信扫描下方小程序码，而后点击「微信登录」，绑定相应手机号即可登录。 1.2 手机免密登录 输入手机号，获取验证码并输入即可。未注册手机验证后自动注册登录，需要注意的是，以下号段不支持注册： 手机卡（虚拟运营商）不支持号段: 中国移动：165 / 1703 / 1705 / 1706 中国联通：167 / 1704 / 1707
Windows7系统ipsmsnap.dll文件丢失问题
amio555的专栏
02-14 1066
其实很多用户玩单机游戏或者安装软件的时候就出现过这种问题，如果是新手第一时间会认为是软件或游戏出错了，其实并不是这样，其主要原因就是你电脑系统的该dll文件丢失了或没有安装一些系统软件平台所需要的动态链接库，这时你可以下载这个ipsmsnap.dll文件(挑选合适的版本文件)把它放入到程序或系统目录中，当我们执行某一个.exe程序时，相应的DLL文件就会被调用，因此将缺失的文件放回到原目录之后就能打开你的软件或游戏了.那么出现ipsmsnap.dll丢失要怎么解决？
C#编程入门基础，开启你的编程之旅
m0_61490399的博客
07-01 22万+
C#使得C++程序员可以高效的开发程序，且因可调用由 C/C++ 编写的本机原生函数，而绝不损失C/C++原有的强大的功能。因为这种继承关系，C#与C/C++具有极大的相似性，熟悉类似语言的开发者可以很快的转向C#。 ................................................................................................
五年了，我在 优快云 的两个一百万。
热门推荐
Jack-Cui
04-16 48万+
在路上
C++实战项目-网络编程基础包含TCP详解
weixin_46120107的博客
08-24 5978
本篇从网络结构模式(网络应用程序设计模式)开始到TCP详解。对于网络编程的所有基础知识一文全部概述。清晰的表达，特别的解释方式，小白也能够看懂，带你打好socket编程的基础。（重点：对TCP从根上进行刨析）
每个.NET开发都应掌握的C#多线程知识点
zls365365的博客
11-23 376
上篇文章讲述了C#特性（Attribute）知识点，本文将介绍多线程的知识点。多线程编程是现代软件开发中的重要组成部分，它能够充分利用多核处理器，提高应用程序的性能和响应性。C#作为.NET开发的主要语言，提供了强大的多线程支持。本文将介绍C#多线程知识点，帮助.NET开发者更好地应对多线程编程。1.多线程基础1）进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，是系统进行资...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值