手撕红黑树

最新推荐文章于 2024-09-22 20:09:34 发布
最新推荐文章于 2024-09-22 20:09:34 发布
阅读量1.3k 收藏 8
点赞数 17
分类专栏： C++ 文章标签： 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62106937/article/details/130633020
版权

手撕红黑树

红黑树的概念

由于AVL对于平衡的要求过于严格，这就导致了AVL的调整操作会被大量的进行，别看单词的时间消耗短，由于AVL树对于平衡要求的苛刻，这就会积累大量的旋转操作，这一累加起来就是不小的时间消耗；
为了减少AVL树的旋转操作，红黑树不就诞生了！
红黑树:红黑树不是一颗严格的二叉树，只是一颗近似平衡的二叉树；
满足一下性质的树就是一颗红黑树:

  1. 首先得是一颗搜索二叉树；
  2. 节点不是黑色就是红色；
  3. 根节点必须是黑色；
  4. 红色节点的左右孩子不允许是红色节点(这一点保证了红黑树不会有两个连续的红色节点)；
  5. 红黑树的叶子节点是黑色的，其中这里的叶子节点不是度为0的节点，而是空节点；
  6. 从任意一个节点到其后代所有叶子节点的路径上的黑色节点数必须相等！
    满足上面这些条件的二叉树就叫红黑树；
    在这里插入图片描述
    思考：为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点
    个数的两倍?
    假设某一个节点到其所有后代叶子节点的路径上的黑色节点数都是N个；
    那么该节点到其后代叶子叶子节点的最短路劲是不是就是这N个黑色节点组成的；
    同理，该节点到其后代叶子节点的最长路径是不是就是红黑相间的节点组成的，那么这个路径的长度不就是2N嘛；
    那么最长路径/最短路径不就刚好等于2嘛，这还是我们模拟的极端情况，实际情况是，我们的路径一定比最长路径短，一定不最短路径长，那么这么一除不就是红黑树中任意一个节点的任意两条路径的长度之商（长/短）都不会超过2,这不就保证了其最长路径中节点个数不会超过最短路径节点个数的两倍；

红黑树节点定义

//定义颜色
#define RED true//红色
#define BLOCK false//黑色
//红黑树节点
//T表示存放的数据的类型
template<class T>
struct RBTNode
	{
		RBTNode(const T&data)
			:_data(data),
			_color(RED),
			_left(nullptr),
			_right(nullptr),
		   _parent(nullptr)
		{}

		bool _color;//标记节点颜色
		T _data;//有效数据
		RBTNode<T>* _left;
		RBTNode<T>* _right;
		RBTNode<T>* _parent;
	};

从上面的定义中我们可以看到，我们将节点的默认颜色给成的红色，可是为什么要给红色，为什么不给黑色呢？
假设，我们给了黑色，我们进行插入过后，势必会造成 “插入节点” 的任意一个祖先节点都不在满足从该节点到其所有后代节点的路径上的黑色节点数目相等，在 “插入节点” 这条路劲上黑色节点的数目始终会比其他路径多一个，这就导致了我们插入节点过后改变了红黑树的性质，我们必须对其进行调整让其在插入节点过后还是颗红黑树，可是这样的话我们每插入一次就需要调整一次，那么这插入的成本也太高了！
假设，默认插入的是红色节点，我们进行插入过后，必然不会造成 “插入节点” 的任意一个祖先节点从该节点到其所有后代节点的路径上的黑色节点数目不相等，因为我这个“新插入”的节点必然是插在这些祖宗节点的某一条路径上面的，我们在利用红色节点进行插入过后，并没有使这条路径上的黑色节点数目改变，因此是满足上面的性质6的，可是我们还需要进行经一不检查，性质6是满足了，性质5就不一定了，如果“新插入的节点”的父节点是红色的话，那么我们是不是就要进行调整了，因为红黑树不允许出现两个连续的红色节点；可是如果父节点是黑色的话，那么我们这次插入不就是完美了嘛！
相比于两种情况，一种是插入了必调整，一种是插入了可能调整，二者谁的成本高一目了然；
为此我们采用的节点的默认颜色就是红色！

节点有了，我们再来把红黑树这个结构也定义一下吧：

//红黑树
//K,表示key的类型
//V,表示节点数据域的类型
//KeyOfValue:用于获取_data数据域的key值
//Compare:用于自定义比较，默认小于
template<class K,class V,class KeyOfValue,class Compare=std::less<K>>
class RBTree
{
	typedef RBTNode<V> Node;//红黑树的节点
public:
	RBTree()
		:_root(nullptr)
	{}
private:
	Node* _root;
}；

我来解释一下红黑树这些参数的意义:
K:表示key值的类型，用于find()函数使用的
V:表示的是实际要存储的数据类型;
KeyOfValue:是一个仿函数，由用户提供，是用于获取_data数据的中的Key值的，因为_data的类型不一定是一个自定义类型，也可能就是Key本身；
Compare：自定义Key的比较方式；
至于参数为什么这样设计:
1、主要是由于set和map底层是用红黑树实现的；
2、红黑树本身就是KV模型，对于map直接使用是没问题的，但是对于set来说由于只有key值，那么使用KV模型的红黑树就需要调整一下策略了；
map的模板参数是<Key,Value>,那么如果给红黑树传参的话，就是:<Key,pair<const Key,Value>,KeyOfValue,less< Key> >;
set的模板参数只有< Key>,那么如果给红黑树传参的话就是:<Key,Key,KeyOfValue,less< Key>>;
由于set和map对应的红黑树中的节点类型是不一样的，我们无法在红黑树中用一种统一的方式来获取Key值，因此我们需要set和map给红黑树自己传递一个能够获取节点的Key值的仿函数；

insert

我们就简单的手撕一下红黑树的插入吧；
老样子，我们先写入二叉搜索树的插入模板:

bool insert(const V& data)
{
	
	KeyOfValue kof;
	Compare com;
	if (_root == nullptr)
	{
		_root = new Node(data);
		_root->_color = BLOCK;
		return true;
	}
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		parent = cur;
		if ( com(kof(cur->_data),kof(data)))
		{
			cur = cur->_right;
		}
		else if (com(kof(data), kof(cur->_data)))
		{
			cur = cur->_left;
		}
		else
			return false;
	}
	cur = new Node(data);
	cur->_parent = parent;
	Node* tmp = cur;
	if (com(kof(cur->_data),kof(parent->_data)))
		parent->_left = cur;
	else
		parent->_right = cur;
	//检查插入节点过后，是否还是红黑树
	Node* grandfather = nullptr;
	Node* uncle = nullptr;
	//这里我们需要检测父亲是否也是红色节点
	while (parent && parent->_color == RED)
	{
		//父亲是红色节点，进行调整操作;
	}
	return true;
}

为了表述方便，我们就用parent表示父节点；
cur表示插入节点；
grandfather:表示爷爷节点；
uncle:表示叔叔节点；

只有当父亲是红色节点时，我们才进行调整：
分析:
如果父亲是红色节点的话，那么父亲一定不是根节点，因为根节点的颜色一定是黑色，那么grandfather一定存在且为黑色，如果grandfather为红色，那么说明在插入之前这棵树就不在是红黑树了；

对于如何调整的策略，有分为这几种情况:
①uncle节点存在且为红
在这里插入图片描述
很明显,cur和parent这两个节点存在了连续的红色节点，此时这整科数已经不在是红黑树了，我们需要对其进行调整；
这调整的原则就是:从grandfather节点(未调整以前的)的父节点看下来，这颗子树的任意一条路径上的黑色节点数目不变！ 记住这一个原则我们就可以完成红黑树的调整了，举个例子:
在这里插入图片描述
为此，对于uncle节点存在且为红色的情况的旋转方式就是:
将parent节点与uncle节点都染成黑色，grandfather节点染成红色：
在这里插入图片描述
如果我们像这样调整的话，再从pg节点的右子树来看：pg节点的右子树中的每一条路径是不是都至少有一个黑色节点，与调整前的要求一致，同时我cur节点和parent节点也解决了连续红色节点相连接的问题，这样的调整方案，堪称完美，可是这就完了吗？
显然没有，我们的grandfather节点被染成了红色，我们又不确定pg节点的颜色，如果pg节点的颜色也为红色，那么不是又出现了两个连续的红色节点:
在这里插入图片描述
这样一来，又不满足红黑树的要求了，因此我们需要继续往上调整:
cur=parent;
parent=grandfather;
grandfather=grandfather->_parent;
但是如果pg节点的颜色是黑色，那么就不存在两个红色节点相连接，此次插入很完美！我们可以退出了：
在这里插入图片描述
当然，对于上面我们只是讨论LL类型，其实还有LR、RR、RL类型由于这些情况的处理方法都是一样的，为此读者们可以自己验证；

②uncle节点不存在
在这里插入图片描述
而针对uncle不存在这种情况，我们又可以对其进行细分：

  1. grandfather与parent、cur节点成LL型：
    在这里插入图片描述
    从图中我们可以看到：调整之前，pg节点的右子树中的每一条路径至少都有一个黑色节点，那么秉承着前面调整的原则，我们再调整之后也需要保持pg节点的右子树中的每一条路径都至少有一个黑色节点：
    为此，我们的调整策略就是:
    将grandfather这颗子树进行右旋，关于什么是右旋、左旋可以移步至我的另一篇博客:二叉搜索树(内含AVL树的旋转操作的详细解释)；
    于是我们就得到了如下的一颗子树:
    在这里插入图片描述
    可是我们发现调整过后的子树中并不能满足pg的右子树中的每一条路径都含有至少有1个黑色节点的数目：为此，我们还需要进行进一步的染色处理，你看，如果我们将parent节点染成黑色，grandfather节点染成红色，是不是就满足了调整d原则了，同时也将parent与cur这两个连续红色节点的条件给消除了:
    在这里插入图片描述
    这样我们就完成了本次的处理，同时我们也不需要继续往上调整了，因为pg节点的右节点都是黑色了，无论pg节点本身是什么颜色都能保证整颗红黑树是合法的！为此在调整完毕过后，我们可以立马break；
  2. grandfather与parent、cur节点成LR型:
    在这里插入图片描述
    对于这种情况，我们的调整策略是:
    a.现将parent这课子树进行左旋:
    在这里插入图片描述
    我们可以发现，虽然调整前后满足调整的原则，但是cur和parent这两个红色节点还是连接在一起的，不是特别合适,为此我们还需要进行旋转，实际上通过查看旋转过后的树，我们可以发现这和LL型的模型是一模一样的，因此，我们可以采取针对LL型模型的处理方法;
    b. 将grandfather这课子树进行右旋：
    在这里插入图片描述
    c. 再根据调整原则进行染色:
    将cur节点染成黑色；
    grandfather节点染成红色;
    在这里插入图片描述
    这样的话，本次调整就完美完成了，也不需要继续往上调整了，因为pg的右节点是黑色，无论pg节点本身是什么颜色都满足红黑树的特点；
  3. grandfather与parent、cur节点成RR型:
    在这里插入图片描述
    调整策略:
    将grandfather这课子树进行左旋:
    在这里插入图片描述
    然后再根据染色的原则，
    将parent节点染成黑色;
    grandfather节点染成红色;
    在这里插入图片描述
  4. grandfather与parent、cur节点成RL型:
    在这里插入图片描述
    >调整策略:
    a. 现将parent这课树进行右旋:
    在这里插入图片描述
    从图中看出来，将parent这课树进行右旋过后，grandfather这课树就变成了RR模型，为此我们采用RR模型的处理方式来解决:
    b. 将grandfather这颗树进行左旋:
    在这里插入图片描述
    c. 根据染色原则进行染色:
    cur染成黑色；
    grandfather染成红色;

③uncle节点存在且为黑;
在这里插入图片描述
这样的话，pg这个节点的右子树中的每一条路径都需要至少含有两个黑色节点！为此我们再用上面的图来讨论就不死那么合适了，我们需要对上面的图做一下处理，让其保证grandfather这课子树中的任意一条路径黑色节点数至少为2：
在这里插入图片描述
这样就保证了，grandfather这课子树中的每一条路径的黑色节点数至少是2个;

  1. grandfather与parent、cur节点成LL型:
    在这里插入图片描述
    调整策略:
    将grandfather这课子树进行右旋:
    在这里插入图片描述
    然后根据染色原则，
    将parent节点染成黑色，
    grandfather节点染成红色;    在这里插入图片描述
  2. grandfather与parent、cur节点成LR型:
    在这里插入图片描述
    调整策略:
    a. 先将parent这课子树进行右旋:
    在这里插入图片描述
    b. 在将grandfather这课子树进行右旋:
    在这里插入图片描述
    c. 然后根据调整原则进行染色:
    cur染黑色；
    grandfather染成红色    :
    在这里插入图片描述
  3. grandfather与parent、cur节点成RR型:
    在这里插入图片描述
    调整策略:
    将grandfather这课树进行右旋    :
    在这里插入图片描述
    然后根据染色原则，
    将parent染成黑色，
    grandfather染成红色    :
    在这里插入图片描述
  4. grandfather与parent、cur节点成RL型:
    在这里插入图片描述
    调整策略:
    a. 将parent这棵树进行右旋:
    在这里插入图片描述
    b. 将grandfather这课树进行左旋:
    在这里插入图片描述
    c. 根据调整原则，进行染色:
    cur染成黑色,
    grandfather染成红色:
    在这里插入图片描述

综上所述,也就这三种大情况，同时通过上面的讨论为我们可以知道，对于uncle不存在/uncle存在且为黑这两种情况来说处理方法是完全一样的，我们可以合并为一起处理，这样的话，最终的情况也就变为了2种,下面是代码实现,可能有点略有不同(博主主要是跟着STL的新式保持一致，看不懂的地方可以去查手册，但是大体逻辑是不变的):

std::pair<iterator,bool> insert(const V& data)
{
	//insert的返回值pair<iterator,bool>
	//插入位置的迭代器和插入是否成功
	KeyOfValue kof;
	Compare com;
	if (_root == nullptr)
	{
		_root = new Node(data);
		_root->_color = BLOCK;
		return std::make_pair(iterator(_root),true);
	}
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		parent = cur;
		if ( com(kof(cur->_data),kof(data)))
		{
			cur = cur->_right;
		}
		else if (com(kof(data), kof(cur->_data)))
		{
			cur = cur->_left;
		}
		else
			return std::make_pair(iterator(cur), false);
	}
	cur = new Node(data);
	cur->_parent = parent;
	Node* tmp = cur;
	if (com(kof(cur->_data),kof(parent->_data)))
		parent->_left = cur;
	else
		parent->_right = cur;
	//检查插入节点过后，是否还是红黑树
	Node* grandfather = nullptr;
	Node* uncle = nullptr;
	while (parent && parent->_color == RED)
	{
		//cur为红，parent为红，grandfather一定存在
		grandfather = parent->_parent;
		//确定叔叔节点的位置
		if (parent == grandfather->_left)
			uncle = grandfather->_right;
		else
			uncle = grandfather->_left;
		//根据叔叔分情况
		//1、叔叔不存在或者||叔叔存在且为黑,这两种情况处理方式一样，可以归为一类
		if (uncle == nullptr || uncle->_color == BLOCK)
		{
			if (grandfather->_left == parent && parent->_left == cur)//LL
			{
				RotateR(grandfather);
				parent->_color = BLOCK;
				grandfather->_color = RED;
			}
			else if (grandfather->_left == parent && parent->_right == cur)//LR
			{
				RotateL(parent);
				RotateR(grandfather);
				cur->_color = BLOCK;
				grandfather->_color = RED;
			}
			else if (grandfather->_right == parent && parent->_right == cur)//RR
			{
				RotateL(grandfather);
				parent->_color = BLOCK;
				grandfather->_color = RED;
			}
			else if (grandfather->_right == parent && parent->_left == cur)//RL
			{
				RotateR(parent);
				RotateL(grandfather);
				cur->_color = BLOCK;
				grandfather->_color = RED;
			}
			else
				assert(false);
			break;
	
		}//2、叔叔存在且为红
		else if (uncle->_color == RED)
		{
			//p->黑，u->黑,g->变红
			parent->_color = BLOCK;
			uncle->_color = BLOCK;
			grandfather->_color = RED;
			//grandfather为红，有可能与其父亲是连续红，需要向上继续调整
			cur = grandfather;
			parent = cur->_parent;
			//如果已经无法向上调整了，说明grandfather就是根节点，我们需要矫正根节点的颜色;
			if (parent == nullptr)
				grandfather->_color = BLOCK;
		}
		else//出现其他情况直接报错
			assert(false);
	}
	return std::make_pair(iterator(tmp), true);
}


//右旋
void RotateR(Node* parent)
{
	KeyOfValue kof;
	Compare com;
	Node* SubL = parent->_left;
	Node* SubLR = SubL->_right;
	Node* ppNode = parent->_parent;
	parent->_left = SubLR;
	if (SubLR)//SubLR节点存在
		SubLR->_parent = parent;
	SubL->_right = parent;
	parent->_parent = SubL;
	if (ppNode == nullptr)//parent是根节点
	{
		SubL->_parent = nullptr;
		_root = SubL;
	}
	else
	{
		SubL->_parent = ppNode;
		if (com(kof(SubL->_data), kof(ppNode->_data)))
			ppNode->_left = SubL;
		else
			ppNode->_right = SubL;
	}
}

//左旋
void RotateL(Node* parent)
{
	KeyOfValue kof;
	Compare com;
	Node* SubR = parent->_right;//这个节点一定存在，可以证明
	Node* SubRL = parent->_right->_left;//这个节点就不一定存在了
	Node* ppNode = parent->_parent;//提前记录一下parent的父亲
	//开始链接SubRL节点
	parent->_right = SubRL;
	if (SubRL)//只有当这个节点存在时，才需要维护器=其父亲节点
		SubRL->_parent = parent;
	//开始链接parent节点
	SubR->_left = parent;
	parent->_parent = SubR;
	
	//开始链接SubR节点
	if (ppNode == nullptr)//如果parent就是根，那么需要更新根节点
	{
		SubR->_parent = nullptr;
		_root = SubR;
	}
	else//parent不是根节点
	{
		SubR->_parent = ppNode;
		if (com(kof(SubR->_data), kof(ppNode->_data)))
			ppNode->_left = SubR;
		else
			ppNode->_right = SubR;
	}
}

红黑树的验证

我们写完了红黑树的插入，必然要检查一下红黑树的合法性，为此，我们可以从一下几个方面进行验证:
0、检查是否是二叉搜索树(中序打印结果);
1、判断根节点是不是黑色;
2、判断是否存在连续的红色节点;
3、判断是否任意一个节点到其后代叶子节点的所有路径上的黑色节点数目均相等;

//检查是否是二叉搜索树(中序打印结果);
void inoder()const
{
	KeyOfValue kof;
	std::stack<Node*> st;
	Node* cur = _root;
	while (cur || st.empty() == false)
	{
		while (cur)
		{
			st.push(cur);
			cur = cur->_left;
		}
		std::cout << kof(st.top()->_data) << " ";
		cur = st.top()->_right;
		st.pop();
	}
std::cout << std::endl;
}

//检查1、2、3合在一起检查
bool check()const
{
	if (_root == nullptr)
		return true;
	//1、检查根是否为黑色
	if (_root->_color == RED)
		return false;
	//2、检查是否有连续的红色节点
	if (red(_root) == true)
		return false;
	//3、检查一颗树的所有路径的黑节点数目是否相等
	return same(_root);
}
//检查是否有连续的红色节点
bool red(Node* root)const
{
	if (root == nullptr)
		return false;
	if (root->_color == RED && root->_parent->_color == RED)
		return true;
	return red(root->_left) && red(root->_right);
}

//检查该树中的任意一个节点的所有路径上的黑节点数目是否相等
bool same(Node* root)const
{
	if (root == nullptr)
		return true;
	int size = 0;
	Node* cur = root;
	//先求出该树的任意一条路径，的黑节点的个数
	while (cur)
	{
		if (cur->_color == BLOCK)
			size++;
		cur = cur->_left;
	}
	//先检查根节点的所有路径上黑节点数目是否相等
	if (check_path(root,size) == false)
		return false;
	//用同样的方法检测左子树，右子树
	return same(root->_left)&&same(root->_right);
}

//先检查根节点的所有路径上黑节点数目是否相等
bool check_path(Node* root,int size)const
{
	if (root == nullptr)
		return size == 0 ? true : false;
	if (root->_color == BLOCK)
		size--;
	return check_path(root->_left, size) && check_path(root->_right, size);
}

红黑树的迭代器

红黑树的迭代器，就是针对Node* 节点的封装

正向迭代器

//正向迭代器
	template<class V, class Sef, class Ptr>
	class ___RBTree___iterator___
	{
		typedef ___RBTree___iterator___<V, Sef, Ptr>  Self;//正向迭代器
		typedef  RBTNode <V>  Node;//红黑树的节点
	public:
		___RBTree___iterator___(Node* cur = nullptr) :_cur(cur)
		{}
		bool operator!=(const Self& s)const
		{
			return _cur != s._cur;
		}
		//前置--
		Self& operator--()
		{
			//右子树 根 左子树
			if (_cur->_left)
			{
				_cur = _cur->_left;
				while (_cur->_right)
				{
					_cur = _cur->_right;
				}
			}
			else
			{
				Node* parent = _cur->_parent;
				//_cur==parent->_left,说明_cur是parent的左子树，表示parent这课树访问完了
				//继续往上走
				while (parent && parent->_left == _cur)
				{
					parent = parent->_parent;
					_cur = _cur->_parent;
				}
				_cur = parent;
			}
			return *this;
		}
		//前置++
		Self& operator++()
		{
			if (_cur->_right)
			{
				_cur = _cur->_right;
				while (_cur->_left)
				{
					_cur = _cur->_left;
				}
			}
			else
			{
				Node* parent = _cur->_parent;
				while (parent && parent->_right == _cur)
				{
					_cur = _cur->_parent;
					parent = parent->_parent;
				}
				_cur = parent;
			}
			return *this;
		}

		Sef operator*()
		{
			return _cur->_data;
		}
		Ptr operator->()
		{
			return &(_cur->_data);
		}
	private:
		Node* _cur;
	};
}

反向迭代器

//反向迭代器
	//It:封装的正向迭代器
	//Sef:*的返回值
	//Ptr:->的返回值
	//根据是不是const对象来决定传那个参数
	template<class It,class Sef,class Ptr>
	class ___RBTree__reverse_iterator___
	{
	typedef ___RBTree__reverse_iterator___<It,Sef,Ptr> ReSelf;
	public:
		explicit ___RBTree__reverse_iterator___(const It& it=It()) :_it(it) {};
		bool operator!=(const ReSelf& rit)
		{
			return _it != rit._it;
		}
		//前置++,也就是正向迭代器的--
		ReSelf& operator++()
		{
			--_it;
			return *this;
		}
		//前置--也就是正向迭代器的++
		ReSelf& operator--()
		{
			++_it;
			return *this;
		}
		Sef operator*()
		{
			return *_it;
		}
		Ptr operator->()
		{
			return _it.operator->();
		}
			private:
		It _it;//正向迭代器
	};

class RBTree 类中:

template <class K,class V,class KeyOfValue,class Compare=less<K>>
class RBTree
{
typedef RBTNode<V> Node;//红黑树的节点
	public:
//正向迭代器
typedef ___RBTree___iterator___<V, V&, V*> iterator;
typedef ___RBTree___iterator___<V, const V&, const V*> const_iterator;
//反向迭代器
typedef ___RBTree__reverse_iterator___<iterator, V&, V*> reverse_iterator;
typedef ___RBTree__reverse_iterator___<const_iterator, const V&, const V*> const_reverse_iterator;
	private:
	Node*_root;
};
南猿北者
关注
专栏目录
【数据结构】手撕红黑树
学了就忘是正常现象
02-26 8995
红黑树和AVL树一样，因其逻辑复杂，面试时现场要求手撕就是纯纯刁难面试者。但某大厂面试官曾要求某些求职者现场手撕红黑树（我赌5毛，让面试官撕，他也撕不出来，而且你家员工上班手搓红黑树啊？），随后求职遭遇被发到网上吐槽，这便有了“手撕红黑树”的梗，也让红黑树成为了知名度最高的数据结构。（话虽如此，对于红黑树的性质、插入思想等概念还是需要掌握的）
深入浅出C++ ——手撕红黑树
weixin_55051736的博客
02-22 824
/节点的值域 Colour _col;//节点的颜色 RBTreeNode < K , V > * _left;//节点的左孩子 RBTreeNode < K , V > * _right;//节点的右孩子 RBTreeNode < K , V > * _parent;//节点的双亲 };
C++手撕红黑树
分享学习的知识，记录我的技术成长道路
08-07 662
红黑树在表意上就是一棵每个节点带有颜色的二叉搜索树，并通过对节点颜色的控制，使该二叉搜索树达到尽量平衡的状态。红黑树确保没有一条路径比其他路径长两倍。和AVL树不同的是，AVL树是一棵平衡树，而红黑树可能平衡也可能不平衡(因为是尽量平衡的状态)每一次插入都对根节点置为黑操作，因为第一种情况可能导致根节点不是黑。同时对根节点置黑也并不违反三条规定。...
【高阶数据结构】手撕红黑树（超详细版本）
qq_42996461的博客
01-08 2499
但行好事，莫问前程
手撕红黑树Java_手撕红黑树(1)-预备知识
weixin_33817338的博客
02-28 134
本篇文章为红黑树的预备知识，暂且不涉及节点颜色。二叉树左旋左旋的过程是将x的右子树绕x逆时针旋转，使得x的右子树成为x的父节点，同时修改相关节点的引用。旋转之后，二叉查找树的属性仍然满足。示例：旋转前|/------3(null)-------\| |1(null) /------10(null)\| |6(null) ...
手撕红黑树代码（Java）
qq_52485934的博客
04-02 281
红黑树详细讲解，详细的源码讲解
手撕红黑树(图文并茂)
weixin_73869209的博客
11-27 180
大家好,今天带着大家手撕红黑树一 . 红黑树的概念红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何 一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。// 新创建的节点默认是红色RED,BLACK思考：在节点的定义中，为什么要将节点的默认颜色给成红色的？不妨来看一下如果默认值给成黑色会发生什么?
天天说手撕红黑树？你真的能撕的下来吗？（详细解释+代码注释）
CYK_byte的博客
12-22 1161
/新增结点，默认必须是红色}}//根节点}}注意：每次新增结点必须是红色的，因为如果某一个分支上增加一个黑色结点，根据红黑树的特点，那么其他每一个分支上也必须都增加一个黑色结点，但实际上我需要增加一个结点，而为了满足红黑树特点多增加的这些结点是没有意义的；如果添加一个红色节点，我们只需要通过调整颜色，即可满足要求；
手撕红黑树（红黑树介绍 + 红黑树插入代码详细讲解）
Love 6's Private Blog
11-04 1827
文章目录前引推荐数据结构可视化网址推荐讲解红黑树的博客与视频红黑树介绍1、接触红黑树的原因2、二叉搜索树的介绍1、二叉搜索树BST（不自平衡）2、AVL树（完美自平衡二叉搜索树）3、红黑树（综合性能强劲 不平凡的二叉弱平衡搜索树）3、红黑树的特性4、红黑树的属性介绍5、红黑树的插入代码解析1、没有根节点（直接插入）2、父节点黑色、叔节点任意（直接插入）3、父节点红、叔节点黑（LL、LR、RL、RR）1、LL旋转2、LR旋转3、RL旋转4、RR旋转4、父节点红、叔节点红（递归）红黑树代码实现（插入）1、验证数
【数据结构与算法】手撕红黑树
pythonxxoo的博客
04-02 850
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 红黑树 定义 动机： 二叉查找树查找、插入、删除最坏情况时间复杂度可能退化为 O(n)。 AVL 树很好的限制了数的高度为 O(logn)，插入、删除、查找的最坏时间复杂度均为 O(logn)；但删除操作最多需要做 O(logn) 次旋转。 红黑树是具有如下特点的二
Java手撕红黑树
wufeifan_learner的博客
01-07 789
前言 我这个人懒得不行，其实早就想学习学习红黑树了，以前只是知道这东西，也知道他是构成HashMap的底层数据结构（jdk1.8以后），但是每次一看红黑树的5条性质就头疼，不想去自习考虑这个数据结构。这个寒假终于下定决心用java手撕一遍红黑树，为了以后的面试做准备。由于这个数据结构有点庞大，我不想从基础开始讲解了，B站好多教学视频，我看了好多，但是现场手撕红黑树的，翻来翻去就那么几个。他们写代码的风格我不是太喜欢，且多是用的idea这个IDE，学生哪有钱买正版，我就直接用eclipse了，反正原理都一样，
数据结构：手撕红黑树(python方式)
Winnie_boy的博客
05-24 995
前言：不知道同学有没有看完昨天的B树和B+树，虽说那个B+树在面试中很少被要求手写，但是有一个常考的考点，红黑树，可以一个经常被问到的知识噢，那么今天，我就来跟大家一起手撕红黑树！ 红黑树 说到红黑树不得不先提一下AVL树(平衡二叉搜索树)，不了解AVL树的同学可以自行查询相关文献，然后回来以后，请回答我的两个问题： 红黑树和AVL树的区别是什么？ 1.附上红黑颜色属性，通过颜色控制树的平衡 2.相对于AVL树来说，没有那么严格的要求平衡 3.插入和删除的复杂度和次数较AVL来说，跟随着数量节点的增大，越
手撕红黑树——C++高阶数据结构详解
热门推荐
qq_61500888的博客
09-06 1万+
带你一命通关红黑树 十五分钟手撕数据结构原理
golang 手撕红黑树
l1002544188的博客
03-21 1279
GOLANG 手撕红黑树 前言 GOLANG表中包中自带的数据结构比较少，目前找到的红黑树都是开源实现，索性自己手撕一颗来练练手。以下主要讲解代码实现。 github地址:https://github.com/Julius-Li/daily/tree/master/rbtree 红黑树简单介绍 红黑树是一种不严格平衡二叉树，通过**保持其性质**就能保持整个树的平衡。红黑...
atcoder abc372 启发式合并， dp
2201_75845839的博客
09-22 175
现在考虑如何存数据。可以用并查集合并两个集合，并且在合并的时候一定要将小的集合合并到大的集合中去，因为小集合合并到大集合中，最后的集合一定大于小集合元素数量的两倍，因此合并的时间复杂度不会超过logn。思路：判断当前变化的位置对结果是否会产生影响，在询问前先计算有多少ABC, 每次变换位置x前后扫描一下[x - 2, x + 2]范围内是否有ABC，变换前有让cnt --， 变换后有让cnt ++思路：三进制转换，可以参考二进制，先把当前可以加入的最大的3的幂次加入,这样一定可以凑出答案。
力扣 16.最接近的三数之和
qq_51352130的博客
09-16 412
设 s=nums[i]+nums[j]+nums[k]，为了判断 s 是不是与 target 最近的数，我们还需要用一个变量 minDiff 维护 ∣s−target∣ 的最小值。分类讨论：如果 s=target，那么答案就是 s，直接返回 s。如果 s>target，那么如果 s−target<minDiff，说明找到了一个与 target 更近的数，更新 minDiff 为 s−target，更新答案为 s。然后和三数之和一样，把 k 减一。
C语言题目之单身狗2
something for nothing的博客
09-22 287
c语言题目之找单身狗2：在一堆数中找到两个只出现过一次数的数
全栈项目小组【算法赛】题目及解题
最新发布
2201_75648436的博客
09-22 161
全栈项目小组【算法赛】
红黑树与AVL树解析：网络工程师考前算法冲刺
“算法与数据结构-网络工程师考前冲刺100题”是一份针对网络工程师考试的复习资料，包含关于算法和数据结构的面试题，特别是关于红黑树和AVL树的知识。这份资料来源于牛客网，一个提供名企校招笔试面试真题的在线...
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

南猿北者

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值