红黑树插入代码实现（框架）

最新推荐文章于 2024-07-22 17:11:23 发布
最新推荐文章于 2024-07-22 17:11:23 发布
阅读量391 收藏 3
点赞数 1
分类专栏： 算法 文章标签： 数据结构 算法 红黑树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51641706/article/details/124871637
版权

文章目录

前言：个人观点，所谓手撕红黑树插入，就是记性好而已，理解并背下框架即可。插入代码量在200行左右

红黑树特征

  1. root是黑色的
  2. 若一个节点是红色的，则它两个孩子是黑色的。（没有连续的红节点）
    ps：黑色节点可以连续
  3. 每条路径的黑色节点数量相等（一条路径指从root到某一个叶子节点）
  4. 最长路径不超过最短路径的2倍

红黑树插入流程

这是总体流程，如果可以看着这张图写出红黑树插入，后面就不用看了。
在这里插入图片描述
ps:强调两点
1.插入的节点一定是红颜色的，因为要保证每条路径的黑色节点个数相同，如果插入了一个黑色的节点，会扰乱所有路径的黑色节点。
2.红黑树也要像AVL一样旋转，但是它的旋转规则是看叔叔是否存在且为红颜色的。如果叔叔不存在或者叔叔为黑颜色，那么就要旋转，旋转规则和AVL一致。
3. 红黑树这里是用left，right，parent三叉链+迭代实现的

核心代码框架：

while (parent && parent->color == RED)只要parent一直为红就一直更新
{
	Node* grandparent = parent->parent;
	if (parent == grandparent->left)
	{
		Node* uncle = grandparent->right;
		if (uncle && uncle->color == RED)
		{
			叔叔存在且为红，变色
			ps：有叔叔且为红的情况变色与普通的变色操作不同
		}
		else
		{
			if (cur == parent->left)
			{
				//rotate right;
				右旋
				变色
			}
			else
			{
				//rotate left and rotate right
				左右旋
				变色
			}
		}
	}
	else
	{
		Node* uncle = grandparent->left;
		if (uncle && uncle->color == RED)
		{
			叔叔存在且为红，变色
		}
		else
		{
			if (cur == parent->right)
			{
				左旋
				变色
			}
			else
			{
				右左旋
				变色
			}
		}
	}
}

有叔叔的情况处理

有叔叔，只变色。
ps：有叔叔且为红的情况变色与普通的变色操作不同
变色规则如下:

把p和u变成黑色的，g变成红色的。然后让cur等于g。若此时的cur的parent和uncle还是红色，则继续重复上面的动作，直到更新到根节点，再把根节点变成黑色。

ps：叔叔可以是在parent的左边，也可以是在grandparent的右边，这点无关紧要。

在这里插入图片描述
伪代码:

if (uncle && uncle->color == RED)
{
	parent->color = uncle->color = BLACK;
	grandparent->color = RED;
	cur = grandparent, parent = cur->parent;
}

这只是伪代码，后面再串起来

旋转怎么旋？

没叔叔就要旋转，具体是单旋还是双旋要具体分析。先说说旋转的过程是怎样的。

树只有一边高的情况

树一边高，证明要单旋。
右边高，则要左旋。左旋的意思就是把左子树压下来，使左右高度平衡。
左边高，则要右旋。右旋的意思就是把右子树压下来，使左右高度平衡。

总结一句就是：旋哪边就把那边的子树往下压。

左旋

注意：左旋是对grandparent左旋，也就是最高那个节点。

左旋就是右边高，要把左边压下来。如图：在这里插入图片描述

对grandparent左旋的步骤如下:

  1. grandparent->right = parent->left
  2. parent->left = grandparent

成果如下:

在这里插入图片描述
当然，真正的代码不只这么简单。还要解决两个问题

  1. 由于是三叉链，因此我们也要更新parent指针的指向。
  2. 并且，旋转之后parent节点还要接上grandparent的parent节点。

真正的代码（对grandparent左旋)如下:

这里的parent其实就是grandparent
void RotateL(Node* parent)
{
	Node* subR = parent->right;
	Node* subRL = subR->left;
	parent->right = subRL;
	if (subRL) subRL->parent = parent;
	保存parent（上图的grandparent）的parent指针，因为后面要改变了，做个备份
	Node* parentparent = parent->parent;
	subR->left = parent;
	parent->parent = subR;
	如果parent（上图的grandparent）是根了，那么就让subR（上图的parent）变成根
	if (parent == root)
	{
		root = subR;
		root->parent = nullptr;
	}
	否则，链接一下
	else
	{
		//if (subR->data.second < parentparent->data.second)这样写也可以
		if(parentparent->left == parent)
		{
			parentparent->left = subR;
			subR->parent = parentparent;
		}
		else
		{
			parentparent->right = subR;
			subR->parent = parentparent;
		}
	}
}

右旋

注意：右旋是对grandparent右旋，也就是最高那个节点。

右旋和左旋是一致的。
在这里插入图片描述

右旋步骤：
1.grandparent->left = parent->right;
2.parent->right = grandparent

在这里插入图片描述

要考虑的问题也和左旋一致，其实我觉得看了左旋之后就要会写右旋了。

右旋代码:

void RotateR(Node* parent)
	{
		Node* subL = parent->left;
		Node* subLR = subL->right;
		parent->left = subLR;
		if (subLR) subLR->parent = parent;
		subL->right = parent;
		Node* parentparent = parent->parent;
		parent->parent = subL;
		if (parent == root)
		{
			root = subL;
			root->parent = nullptr;
		}
		else
		{
			//if (subL->data.second < parentparent->data.second)这样写也可以
			if(parent == parentparent->left)
			{
				parentparent->left = subL;
				subL->parent = parentparent;
			}
			else
			{
				parentparent->right = subL;
				subL->parent = parentparent;
			}
		}
	}

树一边是左边高一边是右边高

先右边旋再左边旋

解决两个问题：

  1. 啥时候要先右旋再左旋？
  2. 左旋的是谁？右旋呢？

在这里插入图片描述

先对parent左旋
在这里插入图片描述
ps：不要按感觉旋，就按左旋的规则来，切记。

再对grandparent左旋
在这里插入图片描述

在红黑树这里的左右旋超简单！！！（插一句，比AVL简单多了，因为AVL要维护平衡因子）

void RotateRL(Node* parent)
{
	RotateR(parent->right);
	RotateL(parent);
}

先左旋再右旋

还是上面两个问题

  1. 啥时候要先左旋再右旋？
  2. 左旋的是谁？右旋呢？

当发现parent的右边高，grandparent的左边高的时候要先左旋再右旋
在这里插入图片描述

parent的右边高，因此先对parent左旋。具体步骤：

  1. cur的左子树给parent的右
  2. cur的左变成parent
    在这里插入图片描述
    然后对grandparent右旋：
    cur的右变成grandparent的左
    grandparent变成cur的右
    在这里插入图片描述

代码:

void RotateLR(Node* parent)
{
	RotateL(parent->left);
	RotateR(parent);
}

没叔叔或者叔叔为黑色的情况

左边高

具体情况如下：
在这里插入图片描述

操作为先右旋，再变色。

左旋后的效果
在这里插入图片描述

由于根要是黑颜色的，因此parent要变成黑色，又由于一开始每条路径黑颜色节点只有一个，因此要把grandparent变成红色。

因此变色操作为:

parent->color = Black;
grandparent->color = Red;

整体旋转加变色的代码如下(上面已经判断过没有叔叔了，只不过代码没贴出来，后面再说）:

if (cur == parent->left)
{
	//rotate right;
	RotateR(grandparent);
	grandparent->color = RED, parent->color = BLACK;
}

右边高

右变高和左边高的操作是一样的，都是先旋转再变色。
变色操作代码也是和上面一致的。

if (cur == parent->right)
{
	//rotate left;
	RotateL(grandparent);
	grandparent->color = RED, parent->color = BLACK;
}

左右旋

这种情况要左右旋
在这里插入图片描述

旋转后的效果如下:
在这里插入图片描述
然后变色，由于root要求是黑颜色的，因此要把cur变成black。又由于一开始所有路径的只有一个黑节点，因此又要把grandparent变成红色的。

前面已经判断了parent在grandparent左边了
if(cur == parent->right)
{
	//rotate left and rotate right
	RotateLR(grandparent);
	grandparent->color = RED;
	cur->color = BLACK;
}

右左旋转

在这里插入图片描述

旋转后是这个效果：
在这里插入图片描述
然后变色。变色逻辑和上面一样。

最后的代码:

//rotate right and rotate left
RotateRL(grandparent);
cur->color = BLACK, grandparent->color = RED;

至此，所有的情况已经分类讨论完了

最终的代码:

插入代码:

void Insert(const T& data)
{
	if (root == nullptr)
	{
		root = new Node(data);
		root->color = BLACK;
		return;
	}

	Compare cmp;
	Node* cur = root, * parent = nullptr;
	while (cur)
	{
		if (cmp(cur->data) < cmp(data))
		//if(cur->data.first < data.first)
		{
			parent = cur;
			cur = cur->right;
		}
		else if (cmp(cur->data) > cmp(data))
		//else if(cur->data.first > data.first)
		{
			parent = cur;
			cur = cur->left;
		}
		else
		{
			return;
		}
	}

	Node* newnode = new Node(data);
	if (cmp(data) < cmp(parent->data)) parent->left = newnode;
	//if (data.first < parent->data.first) parent->left = newnode;
	else parent->right = newnode;
	newnode->parent = parent;
	cur = newnode;
	//ReBalance

	while (parent && parent->color == RED)
	{
		Node* grandparent = parent->parent;
		if (parent == grandparent->left)
		{
			Node* uncle = grandparent->right;
			if (uncle && uncle->color == RED)
			{
				parent->color = uncle->color = BLACK;
				grandparent->color = RED;
				cur = grandparent, parent = cur->parent;
			}
			else
			{
				if (cur == parent->left)
				{
					//rotate right;
					RotateR(grandparent);
					parent->color = BLACK;
					grandparent->color = RED;
				}
				else
				{
					//rotate left and rotate right
					RotateLR(grandparent);
					grandparent->color = RED;
					cur->color = BLACK;
				}
			}
		}
		else
		{
			Node* uncle = grandparent->left;
			if (uncle && uncle->color == RED)
			{
				parent->color = uncle->color = BLACK;
				grandparent->color = RED;
				cur = grandparent, parent = cur->parent;
			}
			else
			{
				if (cur == parent->right)
				{
					//rotate left;
					RotateL(grandparent);
					grandparent->color = RED, parent->color = BLACK;
				}
				else
				{
					//rotate right and rotate left
					RotateRL(grandparent);
					cur->color = BLACK, grandparent->color = RED;
				}
			}
		}
	}

	root->color = BLACK;
}

各种旋转的代码

void RotateR(Node* parent)
{
	Node* subL = parent->left;
	Node* subLR = subL->right;
	parent->left = subLR;
	if (subLR) subLR->parent = parent;
	subL->right = parent;
	Node* parentparent = parent->parent;
	parent->parent = subL;
	if (parent == root)
	{
		root = subL;
		root->parent = nullptr;
	}
	else
	{
		//if (subL->data.second < parentparent->data.second)
		if(parent == parentparent->left)
		{
			parentparent->left = subL;
			subL->parent = parentparent;
		}
		else
		{
			parentparent->right = subL;
			subL->parent = parentparent;
		}
	}
}

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 (parent == root)
	{
		root = subR;
		root->parent = nullptr;
	}
	else
	{
		//if (subR->data.second < parentparent->data.second)
		if(parentparent->left == parent)
		{
			parentparent->left = subR;
			subR->parent = parentparent;
		}
		else
		{
			parentparent->right = subR;
			subR->parent = parentparent;
		}
	}
}

void RotateLR(Node* parent)
{
	RotateL(parent->left);
	RotateR(parent);
}

void RotateRL(Node* parent)
{
	RotateR(parent->right);
	RotateL(parent);
}

验证红黑树的正确性

红黑树必须满足的两个性质：

  1. 没有两个连续的红节点
  2. 每条路径的黑色节点个数相同

从这两个地方入手。

对于没有两个连续的红节点判断思路是：正常的递归整颗树，若遇见了一个红色节点，就看它的parent节点是不是红色的，如果是红色的，就证明已经违反红黑树的性质了。

对于每条路径的黑色节点个数，先遍历一条路径，然后看其他路径的黑色节点是否和第一条路径的黑色节点的个数相同。

代码:

bool isBalance()
{
	int benchmark = 0;
	Node* cur = root;
	while (cur)
	{
		benchmark++;
		cur = cur->left;
	}
	int blacknum = 0;
	return _isBalance(root, benchmark, blacknum);
}

bool _isBalance(Node* root, int benchmark, int blacknum)
{
	if (root == nullptr)
	{
		//cout << blacknum << " " << benchmark << endl;
		if (blacknum != benchmark) return false;
		return true;
	}

	if (root->color == BLACK) blacknum++;
	if (root->color == RED && root->parent->color == RED) return false;
	return _isBalance(root->left, benchmark, blacknum) && _isBalance(root->right, benchmark, blacknum);
}
小丑小丑小丑
关注
专栏目录
红黑树插入代码（严蔚敏数据结构）
08-27
严蔚敏《数据结构》红黑树插入的实现C代码
红黑树-基于Java实现的红黑树数据结构.zip
03-21
- 实现红黑树需要对二叉树和颜色规则有深入理解，代码复杂度较高。 - 需要精确处理旋转和颜色调整，避免破坏红黑树的性质。 总的来说，红黑树是数据结构中的重要组成部分，尤其在需要高效存储和检索大量有序数据...
红黑树的模拟实现
qq_56663697的博客
02-28 672
文章目录红黑树的概念红黑树的性质红黑树节点的定义红黑树的插入操作按照二叉搜索的树规则插入新节点调整红黑树红黑树的验证红黑树与AVL树的比较 红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 红黑树的性质 每个结点不是红色就是黑色。 根节点是黑色的。 如果一个节点是红色的，则它的两个孩子结点是黑色的。 对于每个结点，从该结点到
红黑树（C++实现）
最新发布
2202_75331338的博客
07-22 1060
◉ 如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的，现在看到红色的原因是因为cur的子树在调整的过程中将cur节点的颜色由黑色改成红色。◉ 如果u节点不存在，则cur一定是新插入节点，因为如果cur不是新插入节点，则cur和p一定有一个节点的颜色是黑色，就不满足性质4：每条路径黑色节点个数相同。p为g的左孩子，cur为p的右孩子，则对p先进行左单旋，回到情况二 再对g进行右单旋。p为g的右孩子，cur为p的左孩子，则对p先进行右单旋，回到情况二 再对g进行左单旋。
红黑树插入操作分析及代码实现
踏雁寻花
03-19 1752
首先说一下红黑树的五个性质： 1、每个结点要么是红色的，要么是黑色的； 2、根结点是黑色的； 3、每个叶结点，即空结点(NIL)是黑色的； 4、如果一个结点是红色的，那么它的两个子结点都是黑色的； 5、对每个结点，从该结点到其子结点的所有路径上包含相同数目的黑结点。 在对红黑树插入的时候，我们一般都会插入红色的结点，红黑树的插入主要有这几种情况： 1、插入的是根结点；
STL源码剖析---红黑树原理详解上
tempsitegoogle
07-12 592
一、红黑树概述 红黑树和我们以前学过的AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。不过自从红黑树出来后，AVL树就被放到了博物馆里，据说是红黑树有更好的效率，更高的统计性能。这一点在我们了解了红黑树的实现原理后，就会有更加深切的体会。 红黑树和AVL树的区别在于它使用颜色来标识结点的高度，它所追求的是局部平衡而不是AVL树中的非常严格的...
红黑树的插入
zhuoya_的博客
07-12 3421
本篇目录****************************************************************** 红黑树的概念及性质 ******** 利用图示法介绍红黑树的插入是怎么实现的 ********************...
红黑树的c语言代码实现
05-30
根据给定的信息，本文将详细解释红黑树的C语言实现方法，...总之，这段代码提供了一个完整的红黑树的C语言实现框架，通过理解和掌握这些核心概念和实现细节，可以帮助开发者更好地理解和应用红黑树这一高效的数据结构。
map与set的底层大概框架-红黑树
04-04
接口主要有插入， 寻找， 判断是否为一棵红黑树等等的代码。 一共五百行左右。 学习map和set的友友们如果对红黑树的底层框架很模糊。 可以借鉴一下本文件中的红黑树。 虽然有些地方写的不够全不够好， 但是基本的...
HashMap中红黑树插入节点的调整过程.doc
07-10
本文将详细解析HashMap中红黑树插入节点后的调整过程。 一、红黑树插入节点的概述 在HashMap中，当一个新节点插入到红黑树时，可能会破坏红黑树的性质，包括以下几点： 1. 每个节点要么是红色，要么是黑色。 2. ...
java 红黑树实现.rar
04-27
同时，需要提供插入、删除、查找和修改的方法，并在这些方法中添加处理红黑树特性的代码。在实现过程中，为了简化逻辑，可以使用`enum`类型来表示颜色，如`RED`和`BLACK`。 通过实践理解并实现红黑树，不仅可以深入...
红黑树插入以及删除代码
08-31
红黑树插入删除代码，一些关键地方有打注释，比较好理解 删除部分可以配合http://sunblog.72pines.com/rb-tree-erase/看
【C++】红黑树的插入实现
QiHai的博客
11-12 2158
特化AVL平衡二叉搜索树--红黑树的插入实现
红黑树插入代码学习
weixin_33708432的博客
12-07 129
算法导论的伪代码的注释看的很晕啊，网上找到代码，研究下：   代码 void rb_tree_insert(rb_tree * &amp;T, int value){ rb_tree *z = new rb_tree(); z-&gt;data = value;//即将插入的节点 rb_tree *y = nil; rb_tree *x = T; while (x...
红黑树及插入代码
IS_MOKE的博客
05-20 234
红黑树在插入任何一个节点之前就已经是红黑树了，用数学的归纳法，所以插入一个节点只能是红的（红色不改变黑高）把代码中的所有x改为y，y改为x，left改为right，right改为left；红黑树没有对相同的节点处理：对于业务场景丢弃或者是加一个eps。场景：hashmap、cfs、epoll、定时器、nginx。强查找：红黑树、hash、b/b++树、跳表。红黑树性质被破坏时，就会产生旋转。插入的所有的值都会在最底层。
红黑树的插入-java代码实现
dengjili的专栏
01-27 219
本文基于上一博客红黑树的插入理论讲解-多图进行代码实现，若代码有疑问，可以结合上文。 实现 定义颜色 public enum Color { BLACK, RED; } 定义节点 public class RBNode { private int value; private RBNode left; private RBNode right; private RBNode parent; private Color color = Color.BLACK; // setter getter
红黑树的插入、及模拟实现红黑树（附代码 + 图解 + 注释）
w903414的博客
02-10 2334
红黑树
红黑树插入操作和删除的代码
Faded0104的博客
07-15 382
头文件：RBTree.h #pragma once typedef int Type; typedef enum{RED = 0,BLACK}COLOR; typedef struct RBNode { COLOR color; Type data; struct RBNode *parent; struct RBNode *leftChild; struct RBNode *r
第101篇 C++数据结构（十一）红黑树的插入
weixin_49188222的博客
05-15 595
红黑树特性 1.结点是黑色或红色 2.根节点是黑色 3.叶子结点是黑色的空结点 4.任意节点到其每个叶子结点的所有路径都包含相同数目的黑色结点 注：黑点都是2（或者算成1也行）。 5.红色结点的父结点和子结点都是黑色结点 红黑树特性推论 1.如果一个结点只有一个孩子，那么该结点的颜色一定是黑色的，且该结点的孩子一定是红色的，如果其是红色或者其孩子是黑色，违反了第4条特性 正确： 错误： 2.如果一个结点没有孩子，那么该结点可能是黑色，也可能是红色 注：如果是红色结点的话，一定有父结点，是黑色结
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值