C++实现红黑树

最新推荐文章于 2022-11-05 16:34:52 发布
最新推荐文章于 2022-11-05 16:34:52 发布
阅读量275 收藏 1
点赞数 1
分类专栏： C++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_37964071/article/details/79332228
版权

一、红黑树的性质

红黑树也是二叉搜索树，它的每个节点增加了一个单位用来表示颜色，可以是Red也可以是Black，通过对任意一条根到叶子节点的颜色来约束，红黑树保证最长路径是最短路径的两倍，因此近似平衡。
红黑树的性质：
1、每个节点不是红色就是黑色
2、树的根节点是黑色
3、如果一个节点是红色，则它的两个孩子节点是黑色的（没有连续的红色）
4、 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点(每条路径上黑色结点的数量相等）
看一下红黑树的节点结构： 
enum COLOR
{
	BLACK,
	RED
};

template<class K, class V>
struct RBTreeNode
{
	RBTreeNode(const K& key, const V& value, COLOR color = RED)
	:_pLeft(NULL)
	, _pRight(NULL)
	, _pParent(NULL)
	, _key(key)
	, _value(value)
	, _color(color)
	{}

	RBTreeNode<K, V> *_pLeft;
	RBTreeNode<K, V> *_pRight;
	RBTreeNode<K, V> *_pParent;

	K _key;
	V _value;
	COLOR _color;
};

二、插入节点后分析
1、插入的位置若为根节点，根据性质可知调整为黑色。
2、插入节点后，违反了性质，需要做调整，可能遇到下面三种情况：
注：cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点

情况一：
cur为红，p为红，g为黑，u存在且为红，如下图：

不能将p直接改为黑色，这样会改变某路径黑色节点的个数。
情况二：

cur为红，p为红，g为黑，u不存在/u为黑，如下图，对树g右旋：

 上图，p为g的左孩子，cur为p的左孩子，则进行右单旋转；同理，p为g的右孩子，cur 为p的右孩子，则进行左单旋转。
注：左旋及右旋的具体过程和AVL树很像，只有少了平衡因子的更新，但是多了变色处理。具体可以参考上篇AVL树。
情况三：

cur为红，p为红，g为黑，u不存在/u为黑，如下图，对树cur左旋：
转化为情况二，对g进行右旋。

上图，p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；同理，p为g的右孩子， cur为p的左孩子，则针对p做右单旋转。
插入算法代码如下： 
	bool Insert(const K& key, const V& value)
	{
		if (NULL == _pRoot)
		{
			_pRoot = new Node(key, value, BLACK);   //根节点为黑色
			return true;
		}

		//找插入位置
		pNode pCur = _pRoot;
		pNode pParent = NULL;

		while (pCur)
		{
			if (key < pCur->_key)
			{
				pParent = pCur;
				pCur = pCur->_pLeft;
			}
			else if (key > pCur->_key)
			{
				pParent = pCur;
				pCur = pCur->_pRight;
			}
			else
			{
				return false;
			}
		}

		pCur = new Node(key, value);
		if (key < pParent->_key)
			pParent->_pLeft = pCur;
		else
			pParent->_pRight = pCur;

		pCur->_pParent = pParent;

		//有可能会违反红黑树的性质---3
		while (pParent&&pParent->_color == RED)
		{
			pNode grandParent = pParent->_pParent;
			if (pParent == grandParent->_pLeft)
			{
				pNode uncle = grandParent->_pRight;
				//情况一，叔叔节点存在且为红
				if (uncle&&uncle->_color == RED)
				{
					pParent->_color = BLACK;
					uncle->_color = BLACK;
					grandParent->_color = RED;

					pCur = grandParent;   //继续向上调整
					pParent = pCur->_pParent;
				}

				//叔叔不存在或者存在且为黑
				else
				{
					//若是第三种情况转化为第二种
					if (pCur == pParent->_pRight)
					{
						RotateL(pParent);
						swap(pParent, pCur);
					}

					RotateR(grandParent);
					pParent->_color = BLACK;
					grandParent->_color = RED;
					break;
				}
			}
			//父亲节点为双亲的右节点
			else
			{
				pNode uncle = grandParent->_pLeft;
				//情况一，叔叔节点存在且为红
				if (uncle&&uncle->_color == RED)
				{
					pParent->_color = BLACK;
					uncle->_color = BLACK;
					grandParent->_color = RED;

					pCur = grandParent;   //继续向上调整
					pParent = pCur->_pParent;
				}

				//叔叔不存在或者存在且为黑
				else
				{
					//若是第三种情况转化为第二种
					if (pCur == pParent->_pLeft)
					{
						RotateR(pParent);
						swap(pParent, pCur);
					}

					RotateL(grandParent);
					pParent->_color = BLACK;
					grandParent->_color = RED;
				}
			}
		}
		_pRoot->_color = BLACK;
		return true;
	}

三、判断是否为红黑树
根据红黑树的性质，根节点为黑色；要满足任何一个路径黑色节点的个数相等， 我们可以分别统计每条黑色节点的个数，当相等时就判断是不是红黑树 ；以及有没有相邻的红色节点。 

bool IsRBTree()
	{
		if (_pRoot == NULL)
			return true;
		if (_pRoot->_color == RED)  //根节点为红色
			return false;

		int blackNum = 0;  //黑色节点的个数
		int num = 0;     //任意路径的黑色节点个数
		pNode pCur = _pRoot;
		while (pCur)
		{
			if (pCur->_color == BLACK)
			{
				blackNum++;
			}
			pCur = pCur->_pLeft;
		}

		return _IsRBTree(_pRoot, blackNum, num);
	}
bool _IsRBTree(pNode pRoot, const int blackNum, int num)
	{
		if (NULL == pRoot)  //一条路径结束
		{
			if (num != blackNum)
			{
				return false;
			}
			else
			{
				return true;
			}
		}
		if (pRoot->_color == BLACK)
		{
			++num;
		}
		//两个相邻的红色节点
		if ((pRoot->_color == RED) && (pRoot->_pParent->_color == RED))
		{
			return false;
		}
		return _IsRBTree(pRoot->_pLeft, blackNum, num) && _IsRBTree(pRoot->_pRight, blackNum, num);
	}

完整代码如下： 
#pragma once

enum COLOR
{
	BLACK,
	RED
};

template<class K, class V>
struct RBTreeNode
{
	RBTreeNode(const K& key, const V& value, COLOR color = RED)
	:_pLeft(NULL)
	, _pRight(NULL)
	, _pParent(NULL)
	, _key(key)
	, _value(value)
	, _color(color)
	{}

	RBTreeNode<K, V> *_pLeft;
	RBTreeNode<K, V> *_pRight;
	RBTreeNode<K, V> *_pParent;

	K _key;
	V _value;
	COLOR _color;
};

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
	typedef Node* pNode;
public:
	RBTree()
		:_pRoot(NULL)
	{}

	bool Insert(const K& key, const V& value)
	{
		if (NULL == _pRoot)
		{
			_pRoot = new Node(key, value, BLACK);   //根节点为黑色
			return true;
		}

		//找插入位置
		pNode pCur = _pRoot;
		pNode pParent = NULL;

		while (pCur)
		{
			if (key < pCur->_key)
			{
				pParent = pCur;
				pCur = pCur->_pLeft;
			}
			else if (key > pCur->_key)
			{
				pParent = pCur;
				pCur = pCur->_pRight;
			}
			else
			{
				return false;
			}
		}

		pCur = new Node(key, value);
		if (key < pParent->_key)
			pParent->_pLeft = pCur;
		else
			pParent->_pRight = pCur;

		pCur->_pParent = pParent;

		//有可能会违反红黑树的性质---3
		while (pParent&&pParent->_color == RED)
		{
			pNode grandParent = pParent->_pParent;
			if (pParent == grandParent->_pLeft)
			{
				pNode uncle = grandParent->_pRight;
				//情况一，叔叔节点存在且为红
				if (uncle&&uncle->_color == RED)
				{
					pParent->_color = BLACK;
					uncle->_color = BLACK;
					grandParent->_color = RED;

					pCur = grandParent;   //继续向上调整
					pParent = pCur->_pParent;
				}

				//叔叔不存在或者存在且为黑
				else
				{
					//若是第三种情况转化为第二种
					if (pCur == pParent->_pRight)
					{
						RotateL(pParent);
						swap(pParent, pCur);
					}

					RotateR(grandParent);
					pParent->_color = BLACK;
					grandParent->_color = RED;
					break;
				}
			}
			//父亲节点为双亲的右节点
			else
			{
				pNode uncle = grandParent->_pLeft;
				//情况一，叔叔节点存在且为红
				if (uncle&&uncle->_color == RED)
				{
					pParent->_color = BLACK;
					uncle->_color = BLACK;
					grandParent->_color = RED;

					pCur = grandParent;   //继续向上调整
					pParent = pCur->_pParent;
				}

				//叔叔不存在或者存在且为黑
				else
				{
					//若是第三种情况转化为第二种
					if (pCur == pParent->_pLeft)
					{
						RotateR(pParent);
						swap(pParent, pCur);
					}

					RotateL(grandParent);
					pParent->_color = BLACK;
					grandParent->_color = RED;
				}
			}
		}
		_pRoot->_color = BLACK;
		return true;
	}

	bool IsRBTree()
	{
		if (_pRoot == NULL)
			return true;
		if (_pRoot->_color == RED)  //根节点为红色
			return false;

		int blackNum = 0;  //黑色节点的个数
		int num = 0;     //任意路径的黑色节点个数
		pNode pCur = _pRoot;
		while (pCur)
		{
			if (pCur->_color == BLACK)
			{
				blackNum++;
			}
			pCur = pCur->_pLeft;
		}

		return _IsRBTree(_pRoot, blackNum, num);
	}
	void InOrder()
	{
		if (NULL == _pRoot)
			return;
		_InOrder(_pRoot);
	}
private:
	bool _IsRBTree(pNode pRoot, const int blackNum, int num)
	{
		if (NULL == pRoot)  //一条路径结束
		{
			if (num != blackNum)
			{
				return false;
			}
			else
			{
				return true;
			}
		}
		if (pRoot->_color == BLACK)
		{
			++num;
		}
		//两个相邻的红色节点
		if ((pRoot->_color == RED) && (pRoot->_pParent->_color == RED))
		{
			return false;
		}
		return _IsRBTree(pRoot->_pLeft, blackNum, num) && _IsRBTree(pRoot->_pRight, blackNum, num);
	}
	//左单旋
	void RotateL(pNode pParent)
	{
		pNode pSubR = pParent->_pRight;
		pNode pSubRL = pSubR->_pLeft;

		//处理pSubR
		pParent->_pRight = pSubRL;
		if (pSubRL)
			pSubRL->_pParent = pParent;

		pSubR->_pLeft = pParent;
		pNode pPParent = pParent->_pParent;
		pSubR->_pParent = pPParent;
		pParent->_pParent = pSubR;

		//判断是否为根
		if (pParent == _pRoot)
			_pRoot = pSubR;
		//判断是左子树还是右子树
		else
		{
			if (pPParent->_pLeft == pParent)
				pPParent->_pLeft = pSubR;
			else
				pPParent->_pRight = pSubR;
		}
	}

	//右单旋
	void RotateR(pNode pParent)
	{
		pNode pSubL = pParent->_pLeft;
		pNode pSubLR = pSubL->_pRight;

		//处理pSubR
		pParent->_pLeft = pSubLR;
		if (pSubLR)
			pSubLR->_pParent = pParent;

		pSubL->_pRight = pParent;
		pNode pPParent = pParent->_pParent;
		pSubL->_pParent = pPParent;
		pParent->_pParent = pSubL;

		//判断是否为根
		if (pParent == _pRoot)
			_pRoot = pSubL;
		//判断是左子树还是右子树
		else
		{
			if (pPParent->_pLeft == pParent)
				pPParent->_pLeft = pSubL;
			else
				pPParent->_pRight = pSubL;
		}
	}

	void _InOrder(pNode pRoot)
	{
		if (pRoot)
		{
			_InOrder(pRoot->_pLeft);
			cout << "<" << pRoot->_key << "," << pRoot->_color << ">" << endl;
			_InOrder(pRoot->_pRight);
		}
	}
private:
	pNode _pRoot;
};

void RBTreeTest()
{
	int array[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	RBTree<int, int> t;
	for (size_t i = 0; i < sizeof(array) / sizeof(array[0]); i++)
	{
		t.Insert(array[i], i);
	}
	t.InOrder();

	if (t.IsRBTree())
		cout << "是红黑树" << endl;
	else
		cout << "不是红黑树" << endl;
}

c++——红黑树
蜗@牛的博客
07-10 304
一、红黑树的概念 红黑树是一种二叉搜索树，但是每个结点都有表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出2倍，因而是接近平衡的二叉搜索树。 二、红黑树的特性 1、每个节点要么是黑色，要么是红色。 2、根节点是黑色。 3、每个叶子节点（NIL）是黑色。 4、每个红色结点的两个子结点一定都是黑色。 5、任意一结点到每个叶子结点的路径都包含数量相同的黑结点。 三、红黑树的实现 1、红黑树的插入 （1）根节点为空，则直接插入
【C++】红黑树
最新发布
2303_80828380的博客
10-06 916
认识红黑树
红黑树（C++实现）
热门推荐
2021dragon的博客
12-06 1万+
红黑树（C++实现）
C++实现红黑树模板类
"这是一个C++实现的红黑树模板类，包含插入、删除和查找操作，以及旋转函数。" 红黑树是一种自平衡的二叉查找树（BST），它在进行插入和删除操作后能保持相对较好的平衡性，从而提供高效的查找、插入和删除性能。在...
C++简单实现红黑树的插入
06-06
总的来说，C++实现红黑树的插入操作涉及到对红黑树特性的深入理解、节点结构体的设计、颜色调整规则的编码以及旋转操作的实现。这是一项既挑战性又富有成就感的任务，能帮助开发者更好地掌握数据结构和算法。
C++实现红黑树插入操作详解
本实验的目的是实现红黑树的插入操作，主要依据《算法导论》中的描述和伪代码，使用C++编程语言。 首先，我们定义了红黑树节点`RBNode`的结构体，包括节点的颜色、键值、左右子节点以及父节点的指针。同时，定义了...
红黑树-基于C++实现的红黑树数据结构.zip
03-21
在C++中实现红黑树时，通常会定义一个名为`RBTree`的类，包含私有成员变量（如根节点指针）和公共成员函数（如`insert`, `delete`, `search`等）。类的构造函数初始化空树，而析构函数则负责释放所有节点。为了确保...
C++ 简单实现红黑树的插入
sy1227081317的博客
06-14 394
文章目录红黑树简介红黑树的特点红黑树的插入 红黑树简介 红黑树是在AVL树的基础上做出一些改变。都是在插入和删除时，对二叉树进行旋转来保证二叉树的平衡。从而保证高效的查找效率。 红黑树是在1972年由Rudolf Bayer发明的，当时被称为平衡二叉B树。后来才被修改为如今的“红黑树”。 红黑树不必严格遵守高度差为1， 红黑树可以容许最高高度不超过最低高度的二倍。 这样即使我们需要搜索一个最坏的情况。也只需要搜索"二倍的以二为底n的对数"次 ， n为二叉树的节点个数。 红黑树的特点 红黑树节点分为两个颜色
红黑树C++实现
01-27
红黑树的C++完整实现代码
C++:红黑树
zhang_si_hang的博客
08-21 1918
1.红黑树的概念红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。（最长的路径不超过最短路径的2倍，近似平衡）2.红黑树的性质1.每个结点不是红色就是黑色2.根节点是黑色的3. 如果一个节点是红色的，则它的两个孩子结点是黑色的(没有连续的红色节点)
C++之红黑树
cls的博客
05-23 2183
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 4.2.2 红黑树的性质 1. 每个结点不是红色就是黑色 2. 根节点是黑色的 3. 如果一个节点是红色的，则它的两个孩子结点是黑色的，但是没有连续的红节点 4. 对于每个结点，从该结点到其所有后代叶结点的简单路径...
C++【红黑树】
芊樱烛渊的博客
11-05 1097
AVLTree：要求左右高度差不超过1红黑树：AVLTree过分严格，可能会导致过分的旋转，那能不能不要那么严格呢？需要达到的目的，最长路径不超过最短路径的二倍。也就是说，我们的AVLTree是严格平衡，我们的红黑树是不严格平衡，而是近似平衡结果：相对而言，插入同样的数据，AVL树的旋转更多，红黑树的旋转次数更少假设N是100w，AVL树为logN的高度，也就是大概20左右但是我们的红黑树的话，最短的高度大概是logN也就是20左右，最深的应该为2*logN，为40次左右。
C++ 红黑树的实现
夜空的流星的专栏
03-09 7076
红黑树性质及实现详细介绍： http://zh.wikipedia.org/zh/%E7%BA%A2%E9%BB%91%E6%A0%91 代码部分：  头文件 // RBTree.h: interface for the CRBTree class. // /////////////////////////////////////////////////////////////////
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值