当前位置：
  1. 首页
  2. 互联网
  3. 正文
本文介绍: 本片文章介绍了数据结构中红黑树插入元素进行调整改色！！！

=========================================================================

个人主页点击直达：小白不是程序媛

C++系列专栏：C++干货铺

代码仓库：Gitee

=========================================================================

目录

前言

红黑树的概念

红黑树的性质

红黑树结点的定义

红黑树的插入操作

插入新的结点

检查规则进行改色

情况一

情况二

情况三

插入完整代码

红黑树的验证

红黑树的删除(了解)

红黑树和AVL树的比较

红黑树的应用

前言

上篇文章中我们提到AVL树通过旋转来控制防止二叉树退化成为单只树，但是插入数据量过大且每个数据的紧密程度不大时，插入一个数据时AVL树可能会触发多重旋转，很是浪费时间。但是依然是一个有关数据BST(插入、查找、删除）非常优秀的数据结构，奈何那个时代人才济济，10年后出现了比AVL树性能更优秀一点的红黑树（Red Black Tree)。

红黑树的概念

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或
Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路
径会比其他路径长出俩倍，因而是接近平衡的。

 

红黑树的性质

  • 1. 每个结点不是红色就是黑色
  • 2. 根节点是黑色的
  • 3. 如果一个节点是红色的，则它的两个孩子结点是黑色的
  • 4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点
  • 5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)

这里我们可以再推出来一个性质：红黑树中没有两个连续的红色结点

红黑树结点的定义

enum Colour
{
	RED,
	BLACK
};
template<class k, class v>
struct RBTreeNode
{
	//指向左孩子
	RBTreeNode<k, v>* _left;
	//指向右孩子
	RBTreeNode<k, v>* _right;
	//指向父亲
	RBTreeNode<k, v>* _parent;
	//键值对
	pair<k, v> _kv;
	//节点内的颜色
	Colour _col;

	//使用初始化列表初始化
	RBTreeNode(const pair<k,v>&kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		//一定插入的是红色结点
		,_col(RED)
	{}
};

为什么要将结点的默认颜色设置为红色？

假设如果插入一个黑色结点，相当于二叉树中的某一条路径多了一个黑色结点，违反了红黑树的性质四，需要对整棵树进行调整，牵一发而动全身。如果插入红色结点，恰好其父亲是黑色结点刚好不需要调整；如果父亲是红色，插入一个红色，只需要对这条路径或者这条路径的这块区域进行变色就可以符合红黑树的条件。

红黑树的插入操作

红黑树是在二叉搜索树的基础上加上其平衡限制条件因此分两步：按照搜索二叉树的规则插入新的结点、检查规则进行改色

插入新的结点

//首先判断根结点是否为空
		if (_root == nullptr)
		{
			//开辟根节点
			_root = new Node(kv);
			//红黑树的根节点一定是黑色的
			_root->_col = BLACK;
			return true;
		}
		//不为空根据左小右大找到要插入的位置
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
			//找到位置开始插入结点
			cur = new Node(kv);
			//插入的新增结点应该为红色
			cur->_col = RED;
			//根据左小右大插入
			if (parent->_kv.first < kv.first)
			{
				parent->_right = cur;
				cur->_parent = parent;
			}
			else
			{
				parent->_left = cur;
				cur->_parent = parent;
			}

依然是基于搜索二叉树的特点左小右大进行插入

注：搜索二叉树中没有相同的两个结点

检查规则进行改色

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

约定:cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点

情况一

cur为红，p为红，g为黑，u存在且为红

Node* grandfather = parent->_parent;
                //第一种情况(父亲和叔叔都存在且都为红，爷爷为黑)
				//           g(黑)
				//       p(红)   u(红)
				// 插入 c(红) 

				//修改后(父亲和叔叔修改为黑色，爷爷改为红色)
				//           g(红)
				//       p(黑)   u(黑)
				// 插入 c(红) 

				//当父亲不为空且父亲的颜色为红时一直向上修改
				//直到父亲结点为空时代表修改到了根节点

				//先讨论左边插入，右边插入和左边插入雷同
				if (parent == grandfather->_left)
				{
					Node* uncle = grandfather->_right;
					if (uncle && uncle->_col == RED)
					{
						//变色
						parent->_col = uncle->_col = BLACK;
						grandfather->_col = RED;
						//继续向上变颜色
						cur = grandfather;
						parent = cur->_parent;
					}

情况二

cur为红，p为红，g为黑，u不存在/u存在且为黑

  • p为g的左孩子，cur为p的左孩子，则进行右单旋转；相反，
  • p为g的右孩子，cur为p的右孩子，则进行左单旋转
  • p、g变色–p变黑，g变红 
                    else
						//第二种情况(爷爷为黑色，父亲为红色，叔叔不存在或者叔叔存在为黑色)
						//当叔叔不存在时候cur一定是插入的新的结点
						//当叔叔存在且为黑色的时候cur一定不是插入的新节点，而是之前是黑色的但是通过下面子树的变色变上来成为了红色
						//恰好此时的叔叔是黑色的直接对这一部分进行变色

						//处理方式都是一样的先左(右)旋，再进行变色 叔叔的颜色是不会变的
					{
						if (cur == parent->_left)
						{
							RotateR(grandfather);
							parent->_col = BLACK;
							grandfather->_col = RED;
							//      g(黑)
							//     p(红)
							//插入c(红）

							//         g(黑)
							//     p(红)  u(黑)
							//插入c(红）

							//旋转改色的结果
							//       p(黑）
							//    c(红)  g(红)
							//           u(黑)
						}

情况三

cur为红，p为红，g为黑，u不存在/u存在且为黑

  • p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；相反，
  • p为g的右孩子，cur为p的左孩子，则针对p做右单旋转
  • 则转换成了情况2 

插入完整代码

	bool Insert(const pair<k, v>& kv)
	{
		//首先判断根结点是否为空
		if (_root == nullptr)
		{
			//开辟根节点
			_root = new Node(kv);
			//红黑树的根节点一定是黑色的
			_root->_col = BLACK;
			return true;
		}
		//不为空根据左小右大找到要插入的位置
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
			//找到位置开始插入结点
			cur = new Node(kv);
			//插入的新增结点应该为红色
			cur->_col = RED;
			//根据左小右大插入
			if (parent->_kv.first < kv.first)
			{
				parent->_right = cur;
				cur->_parent = parent;
			}
			else
			{
				parent->_left = cur;
				cur->_parent = parent;
			}
			//插入介绍后开始调整颜色
			while (parent && parent->_col == RED)
			{
				Node* grandfather = parent->_parent;
				//第一种情况(父亲和叔叔都存在且都为红，爷爷为黑)
				//           g(黑)
				//       p(红)   u(红)
				// 插入 c(红) 

				//修改后(父亲和叔叔修改为黑色，爷爷改为红色)
				//           g(红)
				//       p(黑)   u(黑)
				// 插入 c(红) 

				//当父亲不为空且父亲的颜色为红时一直向上修改
				//直到父亲结点为空时代表修改到了根节点

				//先讨论左边插入，右边插入和左边插入雷同
				if (parent == grandfather->_left)
				{
					Node* uncle = grandfather->_right;
					if (uncle && uncle->_col == RED)
					{
						//变色
						parent->_col = uncle->_col = BLACK;
						grandfather->_col = RED;
						//继续向上变颜色
						cur = grandfather;
						parent = cur->_parent;
					}
					else
						//第二种情况(爷爷为黑色，父亲为红色，叔叔不存在或者叔叔存在为黑色)
						//当叔叔不存在时候cur一定是插入的新的结点
						//当叔叔存在且为黑色的时候cur一定不是插入的新节点，而是之前是黑色的但是通过下面子树的变色变上来成为了红色
						//恰好此时的叔叔是黑色的直接对这一部分进行变色

						//处理方式都是一样的先左(右)旋，再进行变色 叔叔的颜色是不会变的
					{
						if (cur == parent->_left)
						{
							RotateR(grandfather);
							parent->_col = BLACK;
							grandfather->_col = RED;
							//      g(黑)
							//     p(红)
							//插入c(红）

							//         g(黑)
							//     p(红)  u(黑)
							//插入c(红）

							//旋转改色的结果
							//       p(黑）
							//    c(红)  g(红)
							//           u(黑)
						}
						else
							//第三种情况和第二种情况差不多 只不过cur不再是左孩子，而是右孩子
							// 左旋后就是第二中情况
							//先进行左旋在进行右旋，最后再改色
						{
							//      g(黑)    //左旋->  g(黑)
							//     p(红)              c(红)
							//     插入c(红）        p(红）

							//      g(黑)    //左旋->  g(黑)
							//     p(红) u(黑)        c(红) u(黑)
							//     插入c(红）        p(红）

							//右旋
							//      c(红)
							//   p(红)  g(红)
							//           u(黑)
							RotateL(parent);
							RotateR(grandfather);
							cur->_col = BLACK;
							grandfather->_col = RED;
						}
						break;
					}
				}
				else
					//右边插入
				{
					Node* uncle = grandfather->_left;
					if (uncle && uncle->_col == RED)
					{
						// 变色
						//
						//
						//
						parent->_col = uncle->_col=BLACK;
						grandfather->_col = RED;

						// 继续往上处理
						cur = grandfather;
						parent = cur->_parent;
					}
					else
					{
						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 true;
	}

注：情况三中含有的旋转和AVL树中的旋转是一样的旋转的代码在本篇文章中就不展示了，大家可以在上篇文章AVL树中找到。

红黑树的验证

红黑树的检测分为两步：

1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}

2. 检测其是否满足红黑树的性质

	bool Check(Node* root, int blacknum,const int refVal)
	{
		if (root == nullptr)
		{
			//走到空代表一条路走完了
			//用参考的黑色结点数和所求的黑色节点数进行比较
			if (blacknum != refVal)
			{
				cout << "存在黑色结点数量不相等的路径" << endl;
				return false;
			}
			return true;
		}
		//遇到红色结点判断其父亲结点是否为红色结点即可
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "有连续的红色结点" << endl;
			return false;
		}
		if (root->_col == BLACK)
		{
			++blacknum;
		}
		return Check(root->_left, blacknum,refVal)
			&& Check(root->_right, blacknum,refVal);
	}
	bool IsBalance()
	{
		if (_root == nullptr)
			return true;
		if (_root->_col == RED)
			return false;
		int refVal = 0;
		Node* cur = _root;
		//先求出其中一条路中含有多少个黑色结点
		//一边递归一边进行往下比较
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++refVal;
			}
			cur = cur->_left;
		}
		int blacknum = 0;
		return Check(_root, blacknum,refVal);
	}

红黑树的删除(了解)

和AVL树的删除一样，通过插入操作我们对红黑树的认识和了解已经差不多了；想要了解删除的朋友可以可参考：《算法导论》或者《STL源码剖析》

红黑树和AVL树的比较

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

红黑树的应用

  • 1. C++ STL库 — map/set、mutil_map/mutil_set
  • 2. Java 库
  • 3. linux内核
  • 4. 其他一些库

今天的对数据结构中基于二叉搜索树的红黑树(RBTree)的分享到这里就结束啦！如果觉得文章还不错的话，可以三连支持一下，个人主页还有很多有趣的文章，欢迎小伙伴们前去点评，您的支持就是我前进的动力！ 

原文地址:https://blog.csdn.net/qq_55119554/article/details/135643752

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。

如若转载，请注明出处：http://www.7code.cn/show_57836.html

如若内容造成侵权/违法违规/事实不符，请联系代码007邮箱：suwngjj01@126.com进行投诉反馈，一经查实，立即删除！

上一篇 Python密码本连接wifi
下一篇 面试 React 框架八股文十问十答第十一期

相关文章

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

插入图片
浏览器会保存昵称、邮箱和网站cookies信息，下次评论时使用。