C++RedBlackTree实现set&map-优快云博客

本文链接：https://blog.youkuaiyun.com/2301_78029441/article/details/143855793

文章目录

一、框架分析

通过下图对框架的分析，可以看到源码中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和ease的是Key对象。

二、模拟实现

参考源码框架，map和set复用之前实现的红黑树。
这里相比源码调整⼀下，key参数就用K，value参数就用V，红黑树中的数据类型，我们使用T。
其次因为RBTree实现了泛型不知道T参数导致是K，还是pair<K,V>，那么insert内部进行插入逻辑比较时，就没办法进行比较，因为pair的默认支持的是key和value⼀起参与比较，我们需要时的任何时候只比较key，所以我们在map和set层分别实现⼀个MapKeyOfT和SetKeyOfT的仿函数传给
RBTree的KeyOfT，然后RBTree中通过KeyOfT仿函数取出T类型对象中的key，再进行比较，具体细节参考如下代码实现

源码中pair支持的<重载实现

template <class T1, class T2>
bool operator< (const pair<T1,T2>& lhs, const pair<T1,T2>& rhs)
{ return lhs.first<rhs.first || (!(rhs.first<lhs.first) && 
lhs.second<rhs.second); }

iterator实现思路分析

iterator实现的大框架跟list的iterator思路是⼀致的，用⼀个类型封装结点的指针，再通过重载运算符实现，迭代器像指针一样访问的行为。
这里的难点是operator++和operator–的实现。之前使用部分，我们分析了，map和set的迭代器走的是中序遍历，左子树->根结点->右子树，那么begin()会返回中序第一个结点的iterator也就是10所在结点的迭代器。
迭代器++的核心逻辑就是不看全局，只看局部，只考虑当前中序局部要访问的下⼀个结点。
迭代器++时，如果it指向的结点的右子树不为空，代表当前结点已经访问完了，要访问下一个结点是右子树的中序第一个，一棵树中序第一个是最左结点，所以直接找右子树的最左结点即可。
迭代器++时，如果it指向的结点的右子树空，代表当前结点已经访问完了且当前结点所在的子树也访问完了，要访问的下⼀个结点在当前结点的祖先里面，所以要沿着当前结点到根的祖先路径向上找。
如果当前结点是父亲的左，根据中序左⼦树->根结点->右子树，那么下⼀个访问的结点就是当前结点的父亲；如下图：it指向25，25右为空，25是30的左，所以下⼀个访问的结点就是30。
如果当前结点是父亲的右，根据中序左子树->根结点->右子树，当前当前结点所在的子树访问完了，当前结点所在父亲的子树也访问完了，那么下一个访问的需要继续往根的祖先中去找，直到找到孩子是父亲左的那个祖先就是中序要问题的下⼀个结点。如下图：it指向15，15右为空，15是10的右，15所在子树话访问完了，10所在子树也访问完了，继续往上找，10是18的左，那么下一个访问的结点就是18。
end()如何表示呢如下图：当it指向50时，++it时，50是40的右，40是30的右，30是18的右，18到根没有父亲，没有找到孩子是父亲左的那个祖先，这是父亲为空了，那我们就把it中的结点指针置为nullptr，用nullptr去充当end。需要注意的是stl源码空，红黑树增加了一个哨兵位头结点做为end()，这哨兵位头结点和根互为父亲，左指向最左结点，右指向最右结点。相比我们用nullptr作为end()，差别不大，他能实现的，我们也能实现。只是–end()判断到结点时空，特殊处理⼀下，让迭代器结点指向最右结点。具体参考迭代器–实现。
迭代器–的实现跟++的思路完全类似，逻辑正好反过来即可，因为他访问顺序是右⼦树->根结点->左子树。
set的iterator也不⽀持修改，我们把set的第二个模板参数改成const K即可， RBTree<K, const K, SetKeyOfT> _t;
map的iterator不支持修改key但是可以修改value，我们把map的第⼆个模板参数pair的第⼀个参数改成const K即可， RBTree<K, pair<const K, V>, MapKeyOfT> _t;

源码的

map支持[]
map要支持[]需要修改insert返回值支持,修改RBtree中的insert返回值为
pair<Iterator, bool> Insert(const T& data)
其他就是红黑树的结构了红黑树的博客：数据结构~红黑树

三、代码实现

Mayset

#include"RBTree.h"
namespace TU
{
	template<class K>
	class set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename RBTree<K, const K, SetKeyOfT>::Iterator iterator;
		typedef typename RBTree<K, const K, SetKeyOfT>::ConstIterator
			const_iterator;
		iterator begin()
		{
			return _t.Begin();
		}
		iterator end()
		{
			return _t.End();
		}
		const_iterator begin() const
		{
			return _t.Begin();
		}
		const_iterator end() const
		{
			return _t.End();
		}
		pair<iterator, bool> insert(const K& key)
		{
			return _t.Insert(key);
		}
		iterator find(const K& key)
		{
			return _t.Find(key);
		}
	private:
		RBTree<K, const K, SetKeyOfT> _t;
	};
	void Print(const set<int>& s)
	{
		set<int>::const_iterator it = s.end();
		while (it != s.begin())
		{
			--it;
			// 不⽀持修改 
			//*it += 2;

			cout << *it << " ";
		}
		cout << endl;
	}
}

Mymap

#include"RBTree.h"
namespace TU
{
	template<class K, class V>
	class map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		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 _t.Begin();
		}

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

		const_iterator begin() const
		{
			return _t.Begin();
		}

		const_iterator end() const
		{
			return _t.End();
		}

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

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

	private:
		RBTree<K, pair<const K, V>, MapKeyOfT> _t;
	};

}

RBTree.h 数据结构~红黑树

enum Colour
{
	RED,
	BLACK
};
template<class T>
struct RBTreeNode
{
	T _data;
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	Colour _col;
	RBTreeNode(const T& data)
		: _data(data)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
	{}
};
template<class T, class Ref, class Ptr>
struct RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef RBTreeIterator<T, Ref, Ptr> Self;

	Node* _node;
	Node* _root;

	RBTreeIterator(Node* node, Node* root)
		:_node(node)
		, _root(root)
	{}

	Self& operator++()
	{
		if (_node->_right)
		{
			// 右不为空，右⼦树最左结点就是中序第⼀个 
			Node* leftMost = _node->_right;
			while (leftMost->_left)
			{
				leftMost = leftMost->_left;
			}

			_node = leftMost;
		}
		else
		{
			// 孩⼦是⽗亲左的那个祖先 
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_right)
			{
				cur = parent;
				parent = cur->_parent;
			}

			_node = parent;
		}

		return *this;
	}

	Self& operator--()
	{
		if (_node == nullptr) // end()
		{
			// --end()，特殊处理，⾛到中序最后⼀个结点，整棵树的最右结点 
			Node* rightMost = _root;
			while (rightMost && rightMost->_right)
			{
				rightMost = rightMost->_right;
			}

			_node = rightMost;
		}
		else if (_node->_left)
		{
			// 左⼦树不为空，中序左⼦树最后⼀个 
			Node* rightMost = _node->_left;
			while (rightMost->_right)
			{
				rightMost = rightMost->_right;
			}

			_node = rightMost;
		}
		else
		{
			// 孩⼦是⽗亲右的那个祖先 
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_left)
			{
				cur = parent;
				parent = cur->_parent;
			}

			_node = parent;
		}

		return *this;
	}

	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;
	}
};
template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef RBTreeIterator<T, T&, T*> Iterator;
	typedef RBTreeIterator<T, const T&, const T*> ConstIterator;

	Iterator Begin()
	{
		Node* leftMost = _root;
		while (leftMost && leftMost->_left)
		{
			leftMost = leftMost->_left;
		}
		return Iterator(leftMost, _root);
	}
	Iterator End()
	{
		return Iterator(nullptr, _root);
	}
	ConstIterator Begin() const
	{
		Node* leftMost = _root;
		while (leftMost && leftMost->_left)
		{
			leftMost = leftMost->_left;
		}
		return ConstIterator(leftMost, _root);
	}
	ConstIterator End() const
	{
		return ConstIterator(nullptr, _root);
	}
	RBTree() = default;
	RBTree(const RBTree& t)
	{
		_root = Copy(t._root);
	}
	RBTree& operator=(RBTree t)
	{
		swap(_root, t._root);
		return *this;
	}
	~RBTree()
	{
		Destroy(_root);
		_root = nullptr;
	}
	pair<Iterator, bool> Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return make_pair(Iterator(_root, _root), true);
		}
		KeyOfT kot;
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kot(cur->_data) < kot(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kot(cur->_data) > kot(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return make_pair(Iterator(cur, _root), false);
			}
		}
		cur = new Node(data);
		Node* newnode = cur;
		// 新增结点。颜⾊红⾊给红⾊ 
		cur->_col = RED;
		if (kot(parent->_data) < kot(data))
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;
		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			// g
			// p u
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_col == RED)
				{
					// u存在且为红 -》变⾊再继续往上处理 
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					// u存在且为⿊或不存在 -》旋转+变⾊ 
					if (cur == parent->_left)
					{
						// g
						// p u
						//c
						//单旋 
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						// g
						// p u
						// c
						//双旋 
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			else
			{
				// g
				// u p
				Node* uncle = grandfather->_left;
				// 叔叔存在且为红，-》变⾊即可 
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					// 继续往上处理 
					cur = grandfather;
					parent = cur->_parent;
				}
				else // 叔叔不存在，或者存在且为⿊ 
				{
					// 情况⼆：叔叔不存在或者存在且为⿊ 
					// 旋转+变⾊ 
					// g
					// u p
					// c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						// g
						// u p
						// c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return make_pair(Iterator(newnode, _root), true);
	}
	Iterator Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return Iterator(cur, _root);

			}
			

		}
		return End();
	}

 private:
	 void RotateL(Node* parent)
	 {
		 Node* subR = parent->_right;
		 Node* subRL = subR->_left;
		 parent->_right = subRL;
		 if (subRL)
			 subRL->_parent = parent;
		 Node* parentParent = parent->_parent;
		 subR->_left = parent;
		 parent->_parent = subR;
		 if (parentParent == nullptr)
		 {
			 _root = subR;
			 subR->_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;
		 parent->_left = subLR;
		 if (subLR)
			 subLR->_parent = parent;
		 Node* parentParent = parent->_parent;
		 subL->_right = parent;
		 parent->_parent = subL;
		 if (parentParent == nullptr)
		 {
			 _root = subL;
			 subL->_parent = nullptr;
		 }
		 else
		 {
			 if (parent == parentParent->_left)
			 {
				 parentParent->_left = subL;
			 }
			 else
			 {
				 parentParent->_right = subL;
			 }
			 subL->_parent = parentParent;
		 }
	 }
	 void Destroy(Node* root)
	 {
		 if (root == nullptr)
			 return;
		 Destroy(root->_left);
		 Destroy(root->_right);
		 delete root;
	 }
	 Node* Copy(Node* root)
	 {
		 if (root == nullptr)
			 return nullptr;
		 Node* newRoot = new Node(root->_kv);
		 newRoot->_left = Copy(root->_left);
		 newRoot->_right = Copy(root->_right);
		 return newRoot;
	 }
private:
	Node* _root = nullptr;
};

四、总结

整体思路
- 数据结构基础：红黑树是一种自平衡二叉搜索树，通过在每个节点上添加一个表示颜色的属性（通常为红色或黑色），并在插入和删除等操作后进行一系列调整来维持树的平衡，从而保证基本操作（如插入、删除、查找等）能在对数时间复杂度内完成。
- 实现目标：利用红黑树的特性来构建类似set（集合，存储唯一元素）和map（键值对集合）的数据结构，使其具有高效的插入、删除和查找性能。
关键实现步骤
- 节点定义
  定义红黑树节点结构体，包含数据域（对于set就是元素值，对于map就是键值对中的键）、颜色域（表示节点是红色还是黑色）以及左右子节点和父节点的指针。
基本操作函数
- 插入操作：
  首先按照二叉搜索树的规则找到插入位置，将新节点插入到树中。
  新插入的节点初始化为红色，因为这样不会改变从根到叶子路径上黑色节点的数量（这是红黑树平衡的一个关键性质），但可能会破坏其他红黑树性质，所以需要进行插入修复操作。
  插入修复操作通过一系列的旋转（左旋、右旋）和颜色调整来恢复红黑树的性质，确保树始终保持平衡。
- 查找操作：
  依据二叉搜索树的查找方式，从根节点开始，根据节点值与要查找的值的大小关系，递归地在左子树或右子树中查找，直到找到目标节点或到达叶子节点确定未找到。
- 删除操作：
  先按照二叉搜索树的查找方式找到要删除的节点。
  如果该节点有子节点，需要通过一些操作（如找到后继节点并替换等）来处理，使其能顺利删除。
  删除节点后，同样可能破坏红黑树的平衡性质，所以要进行删除修复操作，通过旋转和颜色调整来恢复平衡。
与标准库中 set 和 map 的关联
- C++ 标准库中的set和map实际上通常也是基于类似红黑树这样的平衡二叉搜索树来实现的（具体实现可能因编译器和标准库版本有所不同）。
- 自行实现红黑树来构建set和map可以帮助深入理解这些数据结构的底层原理和操作机制，在一些特定场景下（如对性能有特殊要求且标准库实现不能满足需求时），也可以根据自身需求对实现进行定制化优化。