红黑树及map与set的模拟实现

最新推荐文章于 2023-09-09 11:13:15 发布

向着梦想dё方向前进

最新推荐文章于 2023-09-09 11:13:15 发布

阅读量812

点赞数 1

分类专栏： C++ STL 文章标签：数据结构二叉树 c++

本文链接：https://blog.csdn.net/fjhugjkdsd/article/details/108080725

版权

C++ 同时被 2 个专栏收录

25 篇文章 3 订阅

订阅专栏

STL

5 篇文章 2 订阅

订阅专栏

红黑树及map与set的模拟实现

1. 红黑树的概念

1.1. 什么是红黑树

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。

通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树可以确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。

1.2. 红黑树的性质

1. 每个结点都有颜色，非红即黑
2. 根节点为黑
3. 父子两节点不得同时为红
4. 任一节点至NULL(树尾端)的任何路径，所含之黑节点数必须相同
5. 为求方便，视NULL节点为黑节点

红黑树

1.3. 红黑树节点的定义

代码表示：

// 节点的颜色
enum Color
{
	RED, 
	BLACK
};
// 红黑树节点的定义
template<class ValueType>
struct RBTreeNode
{
	RBTreeNode(const ValueType& data = ValueType()，Color color = RED)
		: _pLeft(nullptr)
		, _pRight(nullptr)
		, _pParent(nullptr)
		, _data(data)
		, _color(color)
	{}
	RBTreeNode<ValueType>* _pLeft; // 节点的左孩子
	RBTreeNode<ValueType>* _pRight; // 节点的右孩子
	RBTreeNode<ValueType>* _pParent; // 节点的双亲(红黑树需要旋转，为了实现简单给出该字段)
	ValueType _data; // 节点的值域
	Color _color; // 节点的颜色
};

1.4. 红黑树结构

为了后续实现关联式容器简单，红黑树的实现中增加了一个头结点，因为跟节点必须为黑色，为了与根节点进行区分，将头结点给成黑色，并且让头结点的pParent 域指向红黑树的根节点，pLeft域指向红黑树中最小的节点，_pRight域指向红黑树中最大的节点，如下：

红黑树结构

2. 红黑树的插入操作

红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可分为两步：

2.1. 按照二叉搜索的树规则插入新节点

template<class ValueType>
class RBTree
{
	bool Insert(const ValueType& data)
	{
		PNode& pRoot = GetRoot();
		if (nullptr == pRoot)
		{
			pRoot = new Node(data, BLACK);
			// 根的双亲为头节点
			pRoot->_pParent = _pHead;
			_pHead->_pParent = pRoot;
		}
		else
		{
			// 1. 按照二叉搜索的树方式插入新节点
			// 2. 检测新节点插入后，红黑树的性质是否造到破坏，
			// 若满足直接退出，否则对红黑树进行旋转着色处理
		}
		// 根节点的颜色可能被修改，将其改回黑色
		pRoot->_color = BLACK;
		_pHead->_pLeft = LeftMost();
		_pHead->_pRight = RightMost();
		return true;
	}
private:
	PNode _pHead;
};

2.2. 检测新节点插入后，检测红黑树的性质是否造到破坏

因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整；当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连在一起的红色节点，此时需要对红黑树分情况来讨论：

规定:cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点情况一: cur为红，p为红，g为黑，u存在且为红

1. 情况一: cur为红，p为红，g为黑，u存在且为红
情况1
此时cur和p均为红，违反了性质三，怎样处理？
解决方式：将p,u改为黑，g改为红，然后把g当成cur，继续向上调整。

2. 情况二: cur为红，p为红，g为黑，u不存在/u为黑
情况2
p为g的左孩子，cur为p的左孩子，则进行右单旋转；相反，p为g的右孩子，cur为p的右孩子，则进行左单旋转p、g变色–p变黑，g变红

注：这里的旋转与AVL树的旋转规则以及代码完全一致

3. 情况三: cur为红，p为红，g为黑，u不存在/u为黑

情况三
p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；相反，p为g的右孩子，cur为p的左孩子，则针对p做右单旋转，则转换成了情况二，针对每种情况进行相应的处理即可

代码表示：

bool Insert(const ValueType& data)
{
	// 新节点插入后，如果其双亲节点的颜色为空色，则违反性质3：不能有连在一起的红色结点
	while(pParent && RED == pParent->_color)
	{
		// 注意：grandFather一定存在
		// 因为pParent存在，且不是黑色节点，则pParent一定不是根，则其一定有双亲
		PNode grandFather = pParent->_pParent;
		// 先讨论左侧情况
		if(pParent == grandFather->_pLeft)
		{
			PNode unclue = grandFather->_pRight;
			// 情况三：叔叔节点存在，且为红
			if(unclue && RED == unclue->_color)
			{
				pParent->_color = BLACK;
				unclue->_color = BLACK;
				grandFather->_color = RED;
				pCur = grandFather;
				pParent = pCur->_pParent;
			}
			else
			{
				// 情况五：叔叔节点不存在，或者叔叔节点存在且为黑
				if(pCur == pParent->_pRight)
				{
				_RotateLeft(pParent);
				swap(pParent, pCur);
				}
				// 情况五最后转化成情况四
				grandFather->_color = RED;
				pParent->_color = BLACK;
				_RotateRight(grandFather);
			}
		}
	}
}

注：旋转操作可以查看博客AVL树及其调整：代码传送门

3. 红黑树的验证

红黑树的检测分为两步：
1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)
2. 检测其是否满足红黑树的性质

bool IsValidRBTree()
{
	Node* pRoot = _root;
	// 空树也是红黑树
	if (nullptr == pRoot)
		return true;

	// 检测根节点是否满足情况
	if (BLACK != pRoot->_col)
	{
		std::cout << "违反红黑树性质二：根节点必须为黑色" << std::endl;
		return false;
	}

	// 获取任意一条路径中黑色节点的个数
	size_t blackCount = 0;
	Node* pCur = pRoot;
	while (pCur)
	{
		if (BLACK == pCur->_col)
			blackCount++;
		pCur = pCur->_left;
	}

	// 检测是否满足红黑树的性质，k用来记录路径中黑色节点的个数
	size_t k = 0;
	return _IsValidRBTree(pRoot, k, blackCount);
}

bool _IsValidRBTree(Node* pRoot, size_t k, const size_t blackCount)
{
	//走到null之后，判断k和black是否相等
	if (nullptr == pRoot)
	{
		if (k != blackCount)
		{
			std::cout << "违反性质四：每条路径中黑色节点的个数必须相同" << std::endl;
			return false;
		}
		return true;
	}

	// 统计黑色节点的个数
	if (BLACK == pRoot->_col)
		k++;

	// 检测当前节点与其双亲是否都为红色
	Node* pParent = pRoot->_parent;
	if (pParent && RED == pParent->_col && RED == pRoot->_col)
	{
		std::cout << "违反性质三：没有连在一起的红色节点" << std::endl;
		return false;
	}
	return _IsValidRBTree(pRoot->_left, k, blackCount) &&
	       _IsValidRBTree(pRoot->_right, k, blackCount);
}

4. 红黑树的性能与运用

4.1. 红黑树与AVL树的比较

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O(logN )，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，红黑树降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现较简单，所以实际运用红黑树更广泛。

4.2. 红黑树的应用

1. C++ STL库 – map/set、mutil_map/mutil_set
2. Java 库
3. linux内核(epoll)
4. 其他一些库

5. 红黑树模拟实现STL中的map与set

map与set底层都是红黑树，只是map为K-V模型，set为key模型。它们均为红黑树的高度复用。

5.1. 红黑树的迭代器

迭代器的好处是可以方便遍历，是数据结构的底层实现与用户透明。如果想要给红黑树增加迭代器，需要考虑以前问题：

1. begin()与end()

STL明确规定，begin()与end()代表的是一段前闭后开的区间，而对红黑树进行中序遍历后，可以得到一个有序的序列，因此：begin()可以放在红黑树中最小节点(即最左侧节点)的位置，end()放在最大节点(最右侧节点)的下一个位置，关键是最大节点的下一个位置能否给成nullptr呢？答案是行不通的，因为对end()位置的迭代器进行–操作，必须要能找最后一个元素，此处就不行，因此最好的方式是将end()放在头结点的位置。

红黑树end()

2. operator++()与operator–()

Self& operator++()
{
	// 1、如果右不为空，中序的下一个就是右子树的最左节点
	// 2、如果右为空，表示_node所在的子树已经访问完成,在一个节点在他的祖先中找
	//  沿着路径往上找孩子是它的左的那个祖先
	if (_node->_right)
	{
		Node* subLeft = _node->_right;
		while (subLeft->_left)
		{
			subLeft = subLeft->_left;
		}

		_node = subLeft;
	}

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

		_node = parent;
	}
	return *this;
}

Self& operator--()
{
	//分三种情况讨论：_node 在head的位置，_node 左子树存在，_node 左子树不存在
	// 1. _node 在head的位置，--应该将_node放在红黑树中最大节点的位置
	if (_node->_parent->_parent == _node && _node->_col == RED)
		_node = _node->_right;
	else if (_node->_left)
	{
		// 2. _node的左子树存在,在左子树中找最大的节点，即左子树中最右侧节点
		_node = _node->_left;
		while (_node->_right)
			_node = _node->_right;
	}
	else
	{
		// _node的左子树不存在，只能向上找
		Node* parent = _node->_parent;
		while (_node == parent->_pLeft)
		{
			_node = parent;
			parent = _node->_parent;
		}
		_node = parent;
	}
	return *this;
}

RB-tree树的模拟实现(github链接)：代码传送门

5.2. map的模拟实现

map的底层结构就是红黑树，因此在map中直接封装一棵红黑树，然后将其接口包装下即可

#include "RBTree.hpp"
namespace my_map
{
	template<class K, class V>

	class map
	{
		struct MapkeyOfT
		{
			const K& operator()(const std::pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename RBTree<K, std::pair<K, V>, MapkeyOfT>::iterator iterator;

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

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

		V& operator[](const K& key)
		{
			std::pair<iterator, bool> ret = _t.Insert(std::make_pair(key, V()));
			return ret.first->second;
		}
	private:
		RBTree<K, std::pair<K, V>, MapkeyOfT> _t;
	};
}

5.3. set的模拟实现

set的底层为红黑树，因此只需在set内部封装一棵红黑树，即可将该容器实现出来(具体实现可参考map)。

#include "RBTree.hpp"
namespace my_set
{
	template<class K>

	class set
	{
		struct SetketOfT
		{
			const K& operator()(const K& k)
			{
				return k;
			}
		};
	public:
		typedef typename RBTree<K, K, SetketOfT>::iterator iterator;
		iterator begin()
		{
			return _t.begin();
		}

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

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

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

向着梦想dё方向前进

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
红黑树及map与set的模拟实现

AVL-tree之外，另一个颇具历史并被广泛运用的平衡二叉搜素树是RB-tree（红黑树）。所谓RB-tree,不仅是一个二叉搜索树，而且其中一些条件，可以满足最长路径中节点个数不超过最短路径节点个数的两倍。
复制链接

扫一扫