红黑树的插入、及模拟实现红黑树（附代码 + 图解 + 注释）

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

1.红黑树概念及性质

红黑树：为一棵二叉搜索树，树中的每一个结点颜色不是红色就是黑色。

红黑树性质：

  1. 根节点和所有的外部节点的颜色都是黑色；外部节点为叶子节点的左右孩子节点
  2. 从根节点到外部节点的途中没有连续两个节点的颜色为红色；
  3. 从根节点到外部节点的所有路径上都有着相同的黑色节点。
  4. 最长路径中节点个数不会超过最短路径节点个数的两倍。

证第4条性质：
假设一红黑树任意路径的黑色节点个数为r，由性质2可得，不存在连续两个红色的节点，因此红色节点 后面都会跟随着黑色节点，则从根节点到任一外部节点路径上都有r~2r个节点。故得证。

结论1.设h为红黑树的高度，n为树中节点的个数，r为任一路径的黑色节点个数，则有以下关系：
(1) h ≤ 2r
(2) n ≥ 2^r - 1
(3) h ≤ 2log2(n + 1)

证明：
（1）从根到任一外部节点的路径长度不超过2r，同时从树的定义可知，树的高度即为根节点的高度，等于从根到离根最远的外部节点的路径的长度，因此有h ≤ 2r。
（2）红黑树任一路径黑色节点数为r，则从第1层到第r层没有外部节点，因而在这些层内共有2^r - 1个内部节点，也就是说，内部节点的总数至少为2 ^ r - 1。
（3）由（2）得 r ≤ log2(n + 1)，则推得，h ≤ 2log2(n + 1)。

红黑树的最大高度为2log2(n + 1)，所以插入、搜索、删除的时间复杂度为O(log2(n))。

2.红黑树的插入

使用bst的插入算法将一个元素插入到红黑树中，将该元素作为新的叶节点插入到某一位置，并为该元素进行染色。

  1. 如果插入前为空树，那么新元素将成为根节点，根据性质1，根节点必须为黑色；
  2. 如果插入前树非空，若新节点被染成黑色，那么将违反性质3，根节点到任一外部节点路径上黑色节点数不相等，因此，一般将新插入的节点默认为染成红色，但这可能会违反性质2，出现连续2个红色节点，故需要重新平衡。

cur：当前节点，parent：父节点，grandfather：祖父节点，uncle：叔叔节点

2.1 第一种情况

cur为红，parent为红，grandfather为黑，uncle存在且为红。

cur 和 parent 出现连续两个红色节点，则违反了性质3，解决办法：对parent、uncle节点染色为黑，将grandfather染色为红色，此时可能依然会出现两个连续的红色节点，则将cur节点变更为grandfather节点，继续向上更新。

在这里插入图片描述

情况1伪代码： 

if (uncle && uncle->_color == RED)//uncle节点存在且为红色
{
	parent->_color = BLACK;//父节点变为黑色
	uncle->_color == BLACK;//叔叔节点变为黑色
	grandfather->_color = RED;//祖父节点变为红色
	cur = grandfather;//cur变更为当前祖父节点，继续向上更新
	parent = cur->_parent;//parent变为当前cur的父节点
}

继续向上更新是因为，当前祖父节点可能是子树，可能为根节点，若为子树，则需要向上更新，若为根节点，则在更新完毕之后，再将根节点置为黑色。

2.2 第二种情况

cur为红，parent为红，grandfather为黑，uncle不存在或者uncle为黑。

uncle的两种情况：

  1. 如果uncle节点不存在，则cur一定为刚插入的新节点，因为如果cur不是新插入的节点，则cur和parent一定有一个节点的颜色为黑色，则不满足性质3，每条路径上黑色节点数相同；
  2. 如果uncle节点存在，则一定为黑色，那么cur节点原来的颜色一定是黑色的，现在变为红色是因为cur的子树在调整的过程中将cur节点的颜色由黑色变为了红色。

解决办法：parent为grandfather的左孩子，cur为parent的左孩子，对grandfather进行右单旋，parent变为黑色，grandfather变为红色。

  1. uncle存在且为黑
    在这里插入图片描述
  2. uncle不存在
    在这里插入图片描述

2.3 第三种情况

cur为红，parent为红，grandfather为黑，uncle不存在或者uncle为黑。

这种情况下，主要是cur节点在parent节点右侧。

解决办法：parent为grandfather的左孩子，cur为parent的右孩子，先对parent进行左单旋，交换cur和parent节点，再对grandfather进行右单旋，parent变为黑色，grandfather变为红色。

  1. uncle存在且为黑
    在这里插入图片描述
  2. uncle不存在
    在这里插入图片描述

情况2与情况3伪代码： 

if (cur == parent->_right)//cur节点在右侧，先左单旋，转化为情况2
{
	RotateLeft(parent);//左单旋
	swap(parent, cur);//交换parent和cur节点
}

RotateRight(grandfather);//祖父节点右单旋
grandfather->_color = RED;//祖父颜色变为红色
parent->_color = BLACK;//父节点颜色变为黑色

上述三种情况，全部是在parent节点在祖父节点左侧的情况。
下面讨论，parent节点在祖父节点右侧的情况。

2.4 第四种情况

cur为红，parent为红，grandfather为黑，uncle存在且为红。

与情况一类似，解决方法相同。

解决办法：对parent、uncle节点染色为黑，将grandfather染色为红色，此时可能依然会出现两个连续的红色节点，则将cur节点变更为grandfather节点，继续向上更新。

在这里插入图片描述

情况4伪代码： 

if (uncle && uncle->_color == RED)//uncle节点存在且为红色
{
	parent->_color = BLACK;//父节点变为黑色
	uncle->_color == BLACK;//叔叔节点变为黑色
	grandfather->_color = RED;//祖父节点变为红色
	cur = grandfather;//cur变更为当前祖父节点，继续向上更新
	parent = cur->_parent;//parent变为当前cur的父节点
}

2.5 第五种情况

cur为红，parent为红，grandfather为黑，uncle不存在或者uncle为黑。

cur为parent的右孩子。

解决办法：parent为grandfather的右孩子，cur为parent的右孩子，对grandfather进行左单旋，parent变为黑色，grandfather变为红色。
在这里插入图片描述

2.6 第六种情况

cur为红，parent为红，grandfather为黑，uncle不存在或者uncle为黑。

cur为parent的左孩子。

解决办法：parent为grandfather的右孩子，cur为parent的左孩子，先对parent进行右单旋，交换cur和parent节点，再对grandfather进行左单旋，parent变为黑色，grandfather变为红色。

在这里插入图片描述

情况5与情况6伪代码： 

if (cur == parent->_left)//cur节点在左侧，先右单旋，转化为情况5
{
	RotateRight(parent);//左单旋
	swap(parent, cur);//交换parent和cur节点
}

RotateLeft(grandfather);//祖父节点右单旋
grandfather->_color = RED;//祖父颜色变为红色
parent->_color = BLACK;//父节点颜色变为黑色

3.模拟实现红黑树

#pragma once

#include <iostream>
using namespace std;

enum Color{ RED, BLACK };
template<class T>
struct RBTreeNode
{
	RBTreeNode(const T& x = T(), Color c = RED)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_data(x)
		,_color(c)
	{}
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	T _data;
	Color _color;
};

template<class T>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	RBTree()
	{
		_head = new Node;
		_head->_left = _head;
		_head->_right = _head;
		_head->_parent = nullptr;
	}

	~RBTree()
	{
		Destroy(_head->_parent);
		delete _head;
		_head = nullptr;
	}

	bool insert(const T& data)
	{
		//先找到红黑树的根节点
		Node*& root = GetRoot();
		if (root == nullptr)//说明红黑树为空
		{
			root = new Node(data, BLACK);
			root->_parent = _head;
			_head->_left = root;
			_head->_right = root;
			_head->_parent = root;
			return true;
		}

		Node* cur = root;
		Node* parent = _head;
		while (cur)
		{
			parent = cur;
			if (data > cur->_data)
				cur = cur->_right;
			else if (data < cur->_data)
				cur = cur->_left;
			else//不插入重复的元素
				return false;
		}

		cur = new Node(data);
		cur->_parent = parent;
		if (data > parent->_data)
			parent->_right = cur;
		else
			parent->_left = cur;

		//检测节点颜色

		while (parent != _head && parent->_color == RED)
		{
			Node* grandfather = parent->_parent;//祖父

			if (parent == grandfather->_left)//在左侧
			{
				Node* uncle = grandfather->_right;//叔叔节点
				if (uncle && uncle->_color == RED)//第一种情况
				{
					parent->_color = BLACK;
					uncle->_color = BLACK;
					grandfather->_color = RED;
					cur = grandfather;
					parent = cur->_parent;
				}
				else//第2 3种情况
				{
					if (cur == parent->_right)//第三种情况,先左单旋，交换cur 和parent节点
					{
						RotateLeft(parent);
						swap(parent, cur);
					}

					RotateRight(grandfather);//再对grandfather节点进行右单旋
					parent->_color = BLACK;
					grandfather->_color = RED;//重新染色
				}
			}
			else//在右侧
			{
				Node* uncle = grandfather->_left;//叔叔节点
				if (uncle && uncle->_color == RED)//第4种情况
				{
					parent->_color = BLACK;
					uncle->_color = BLACK;
					grandfather->_color = RED;
					cur = grandfather;
					parent = cur->_parent;
				}
				else//第5 6种情况
				{
					if (cur == parent->_left)//第5种情况,先右单旋，交换cur 和parent节点
					{
						RotateRight(parent);
						swap(parent, cur);
					}

					RotateLeft(grandfather);//再对grandfather节点进行左单旋
					parent->_color = BLACK;
					grandfather->_color = RED;//重新染色
				}
			}
		}

		root->_color = BLACK;
		_head->_left = LeftMost();
		_head->_right = RightMost();
		return true;
	}

	void inOrder()
	{
		_inOrder(GetRoot());
		cout << endl;
	}

	bool isRBTree()
	{
		Node* root = _head->_parent;
		Node* cur = root;
		int BLACKCOUNT = 0;
		while (cur != nullptr)
		{
			if (cur->_color == BLACK)
				++BLACKCOUNT;
			cur = cur->_left;
		}

		return _isRBTree(root, 0, BLACKCOUNT);
	}
private:

	bool _isRBTree(Node* root, int PATHBLACKCOUNT, const int& BLACKCOUNT)
	{
		if (root == nullptr)
			return true;
		if (root->_color == BLACK)
			PATHBLACKCOUNT++;

		//性质3
		if (root->_left == nullptr && root->_right == nullptr && (PATHBLACKCOUNT != BLACKCOUNT))
		{
			cout << "违反了性质3" << endl;
			return false;
		}

		//性质2
		if (root->_parent != _head && root->_color == RED && root->_parent->_color == RED)
		{
			cout << "违反了性质2" << endl;
			return false;
		}

		return _isRBTree(root->_left, PATHBLACKCOUNT, BLACKCOUNT) && _isRBTree(root->_right, PATHBLACKCOUNT, BLACKCOUNT);
	}

	Node*& GetRoot()const
	{
		return _head->_parent;
	}

	void Destroy(Node*& root)
	{
		if (root == nullptr)
			return;
		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
		root = nullptr;
	}

	Node* LeftMost()const 
	{
		Node* cur = _head->_parent;
		while (cur->_left)
			cur = cur->_left;
		return cur;
	}

	Node* RightMost()const
	{
		Node* cur = _head->_parent;
		while (cur->_right)
			cur = cur->_right;
		return cur;
	}

	void RotateRight(Node* parent)//右单旋
	{
		Node* subL = parent->_left;

		parent->_left = subL->_right;
		if (subL->_right != nullptr)
			subL->_right->_parent = parent;
		subL->_right = parent;
		subL->_parent = parent->_parent;
		if (parent->_parent != _head)
		{
			if (parent == parent->_parent->_left)
				parent->_parent->_left = subL;
			else
				parent->_parent->_right = subL;
		}
		else
		{
			parent->_parent->_parent = subL;
		}
		parent->_parent = subL;
	}

	void RotateLeft(Node* parent)//左单旋
	{
		Node* subR = parent->_right;
		parent->_right = subR->_left;
		subR->_parent = parent->_parent;
		if (subR->_left != nullptr)
			subR->_left->_parent = parent;
		subR->_left = parent;
		if (parent->_parent != _head)
		{
			if (parent == parent->_parent->_left)
				parent->_parent->_left = subR;
			else
				parent->_parent->_right = subR;
		}
		else
		{
			parent->_parent->_parent = subR;
		}
		parent->_parent = subR;
	}

	void _inOrder(Node* root)const
	{
		if (root == nullptr)
			return;
		_inOrder(root->_left);

		cout << root->_data << "  ";

		_inOrder(root->_right);
	}
private:
	Node* _head;
};
903419
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
一棵树，怎么就平衡了(图解AVL+实现)
bigsai
10-11 1279
什么是AVL树 大家好，我是bigsai，好久不见，甚是想念。 对于树这种数据结构，想必大家也已经不再陌生，我们简单回顾一下。 在树的种类中，通常分成二叉树和多叉树，我们熟悉的二叉树种类有二叉搜索(排序、查找)树、二叉平衡树、伸展树、红黑树等等。而熟悉的多叉树像B树、字典树都是经典多叉树。 普通的二叉树，我们研究其遍历方式，因为其没啥规则约束查找和插入都很随意所以很少有研究价值。 但是二叉树结构上很有特点：左孩子和右孩子，两个不同方向的孩子对应二进制的01，判断的对错，比较的大小 ，所以根据这个结构所有树左
红黑树基础-第三篇-源码解析
IntelliJzzy的博客
06-15 669
本文主要解析java8中HashMap的红黑树源码部分，如有不懂可以先看我写的红黑树基础-第一篇和红黑树基础-第二篇 1.左旋 注意：图中节点标号跟下面代码中变量名一致，便于理解。 /** * 红黑树节点左旋操作 * @param root 根节点 * @param p 旋转节点 * @return 新root节点 */ static <K,V> TreeNode...
红黑树插入代码（严蔚敏数据结构）
08-27
严蔚敏《数据结构》红黑树插入的实现C代码
红黑树的插入
zhuoya_的博客
07-12 3414
本篇目录****************************************************************** 红黑树的概念及性质 ******** 利用图示法介绍红黑树的插入是怎么实现的 ********************...
红黑树（C++实现）
最新发布
2202_75331338的博客
07-22 1041
◉ 如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的，现在看到红色的原因是因为cur的子树在调整的过程中将cur节点的颜色由黑色改成红色。◉ 如果u节点不存在，则cur一定是新插入节点，因为如果cur不是新插入节点，则cur和p一定有一个节点的颜色是黑色，就不满足性质4：每条路径黑色节点个数相同。p为g的左孩子，cur为p的右孩子，则对p先进行左单旋，回到情况二 再对g进行右单旋。p为g的右孩子，cur为p的左孩子，则对p先进行右单旋，回到情况二 再对g进行左单旋。
查找（一）史上最简单清晰的红黑树讲解
热门推荐
菜鸟的自留地-mooyang
05-18 12万+
查找（一） 我们使用符号表这个词来描述一张抽象的表格，我们会将信息（值）存储在其中，然后按照指定的键来搜索并获取这些信息。键和值的具体意义取决于不同的应用。 符号表中可能会保存很多键和很多信息，因此实现一张高效的符号表也是一项很有挑战性的任务。 我们会用三种经典的数据类型来实现高效的符号表：二叉查找数、红黑树、散列表。 二分查找 我们使用有序数组存
红黑树插入操作分析及代码实现
踏雁寻花
03-19 1752
首先说一下红黑树的五个性质： 1、每个结点要么是红色的，要么是黑色的； 2、根结点是黑色的； 3、每个叶结点，即空结点(NIL)是黑色的； 4、如果一个结点是红色的，那么它的两个子结点都是黑色的； 5、对每个结点，从该结点到其子结点的所有路径上包含相同数目的黑结点。 在对红黑树插入的时候，我们一般都会插入红色的结点，红黑树的插入主要有这几种情况： 1、插入的是根结点；
红黑树的插入-java代码实现
dengjili的专栏
01-27 218
本文基于上一博客红黑树的插入理论讲解-多图进行代码实现，若代码有疑问，可以结合上文。 实现 定义颜色 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
IT笔试面试--红黑树详细解析，代码+图解
04-14
然而，红黑树上的插入操作和删除操作会导致不再符合红黑树的性质。恢复红黑树的性质需要少量（O(log n)）的颜色变更（实际是非常快速的）和不超过三次树旋转（对于插入操作是两次）。 插入操作可以概括为以下几个...
算法图解笔记以及代码文件.zip
08-09
4. **树算法**：如二叉搜索树、AVL树、红黑树等平衡二叉树，以及最小生成树的Prim算法和Kruskal算法。这些数据结构和算法在数据存储和检索中起着关键作用。 5. **动态规划**：用于解决最优化问题，如背包问题、最长...
TypeScript手写红黑树
wangzi95211的博客
02-20 144
使用TypeScript手写一个红黑树，具体的思路步骤可以边看代码边看解析。 一. 实现步骤分析 实现一个 TypeScript 红黑树的详细步骤： 定义红黑树的节点：定义一个带有键、值、颜色、左子节点、右子节点和父节点的类；实现左旋操作：将一个节点向左旋转，保持红黑树的性质；实现右旋操作：将一个节点向右旋转，保持红黑树的性质；实现插入操作：在红黑树中插入一个新的节点，并保持红黑树的性质；实现删除操作：从红黑树中删除一个节点，并保持红黑树的性质；实现修复红黑树性质：在插入或删除操作后，通过旋转和变色
红黑树插入以及删除代码
08-31
红黑树插入删除代码，一些关键地方有打注释，比较好理解 删除部分可以配合http://sunblog.72pines.com/rb-tree-erase/看
Qrbtree delphi7 红黑树
05-25
qdac里的红黑树 改了下，delphi7能用，还有哈希列表，不错
红黑树的模拟实现
qq_56663697的博客
02-28 669
文章目录红黑树的概念红黑树的性质红黑树节点的定义红黑树的插入操作按照二叉搜索的树规则插入新节点调整红黑树红黑树的验证红黑树与AVL树的比较 红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 红黑树的性质 每个结点不是红色就是黑色。 根节点是黑色的。 如果一个节点是红色的，则它的两个孩子结点是黑色的。 对于每个结点，从该结点到
红黑树详解+模拟实现
向未来❀去探索 的博客
09-02 412
红黑树详解+模拟实现
红黑树插入代码实现（框架）
m0_51641706的博客
05-21 391
前言：个人观点，所谓手撕红黑树插入，就是记性好而已，理解并背下框架即可。插入代码量在200行左右 红黑树特征 root是黑色的 若一个节点是红色的，则它两个孩子是黑色的。（没有连续的红节点） ps：黑色节点可以连续 每条路径的黑色节点数量相等（一条路径指从root到某一个叶子节点） 最长路径不超过最短路径的2倍 红黑树插入流程 这是总体流程，如果可以看着这张图写出红黑树插入，后面就不用看了。 ps:强调两点 1.插入的节点一定是红颜色的，因为要保证每条路径的黑色节点个数相同，如果插入了一个黑色的节.
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值