C++实现红黑树

于 2024-09-26 14:58:52 发布
阅读量70 收藏
点赞数 2
文章标签： c++ 算法和数据结构 红黑树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43698578/article/details/142555791
版权 
//MyRbTree.h
#pragma once
#include <iostream>
const int RED = 0;
const int BLACK = 1;

struct SubRBTree
{
	SubRBTree* left;
	SubRBTree* right;
	SubRBTree* parent;
	int nData;
	int color;//RED=0,BLACK=1
	SubRBTree()//默认构造nil节点
	{
		left = NULL;
		right = NULL;
		parent = NULL;
		nData = 0;
		color = BLACK;
	}

	SubRBTree(int nData,SubRBTree*nil):nData(nData)//普通构造为红色节点
	{
		left = nil;
		right = nil;
		parent = nil;
		color = RED;
	}

//左旋
	SubRBTree* RotateLeft(SubRBTree**pRoot,SubRBTree*nil)
	{
		SubRBTree* R = right;
		right = right -> left;

		if (R->left != nil)
			R->left->parent = this;	
		
		if (this->parent == nil)
			*pRoot = R;
		else
		{
			if (this->parent->left == this)
				this->parent->left = R;
			else
				this->parent->right = R;	
		}

		R->parent = this->parent;
		this->parent = R;
		R->left = this;

		return R;
	}
//右旋
	SubRBTree* RotateRight(SubRBTree** pRoot, SubRBTree* nil)
	{
		SubRBTree* L = left;
		left = left->right;

		if (L->right != nil)
			L->right->parent = this;
	
		if (this->parent == nil)
			*pRoot = L;
		else
		{
			if (this->parent->left == this)
				this->parent->left = L;
			else
				this->parent->right = L;
		}

		L->parent = this->parent;
		this->parent = L;
		L->right = this;

		return L;
	}
};

class RBTree
{

public:
	RBTree();
	~RBTree();
public:
	bool Insert(const int nData);
	void InsertEx(const int nData);
	bool Delete(const int nData);
	void Display()
	{
		PrintTree(root,0,-1);
	}
private:

	void InsertFixup(SubRBTree* pNode);
	void InsertFixupEx(SubRBTree* pNode);
	void DeleteFixup(SubRBTree* pNode);

	SubRBTree* CreateNode(int nData);
	void DeleteNode(SubRBTree* pNode);
	SubRBTree* FindNode(const int nData);
	SubRBTree* Maximum(SubRBTree* pNode);
	SubRBTree* Minimum(SubRBTree* pNode);
//	SubRBTree* Successor(SubRBTree* pNode);

	void DeleteTree(SubRBTree* pNode);
	void PrintTree(SubRBTree* pNode,int nDepth,int state) const;

private:
	SubRBTree* root;
	SubRBTree* nil;
	int    node_count;
};

RBTree::RBTree()
{
	nil = new SubRBTree;
	root = nil;
	node_count = 0;
}

RBTree::~RBTree()
{
	DeleteTree(root);
	delete nil;
	root = NULL;
	nil = NULL;
}

SubRBTree* RBTree::CreateNode(int nData)
{
	return new SubRBTree(nData, nil);
}

void RBTree::DeleteTree(SubRBTree* pNode)
{
	if (pNode == nil)
		return;

	DeleteTree(pNode->left);
	DeleteTree(pNode->right);

	delete pNode;
	pNode = NULL;
}



SubRBTree* RBTree::Maximum(SubRBTree* pNode)
{
	while (pNode->right != nil)
		pNode = pNode->right;

	return pNode;
}

SubRBTree* RBTree::Minimum(SubRBTree* pNode)
{
	while (pNode->left != nil)
		pNode = pNode->left;

	return pNode;
}

//SubRBTree* RBTree::Successor(SubRBTree* pNode)
//{
//	if (pNode->right != nil)
//		return Minimum(pNode->right);//找后继节点
//
//	SubRBTree* pPNode = pNode->parent;
//	while (pPNode != nil && pNode == pPNode->right)
//	{
//		pNode = pPNode;
//		pPNode = pNode->parent;
//	}
//
//	return pPNode;
//}

void RBTree::InsertEx(const int nData)
{
	SubRBTree* pNewNode = CreateNode(nData);
	SubRBTree* pPNewNode = nil;
	SubRBTree* pTemp = root;

	while (pTemp != nil)
	{
		pPNewNode = pTemp;
		if (nData < pTemp->nData)
			pTemp = pTemp->left;
		else
			pTemp = pTemp->right;
	}

	//空树
	if (pPNewNode == nil)
		root = pNewNode;
	if (nData < pPNewNode->nData)
		pPNewNode->left = pNewNode;
	else
		pPNewNode->right = pNewNode;

	pNewNode->parent = pPNewNode;

	InsertFixupEx(pNewNode);

}

bool RBTree::Insert(const int nData)
{
	SubRBTree* pNewNode = CreateNode(nData);
	SubRBTree* pPNewNode = nil;
	SubRBTree* pTemp = root;

	//查找直接插入时，插入的位置，先按照正常搜索树查找
	while (pTemp != nil)
	{
		pPNewNode = pTemp;

		if (nData < pTemp->nData)
			pTemp = pTemp->left;
		else
			pTemp = pTemp->right;
	}

	pNewNode->parent = pPNewNode;

	if (pPNewNode == nil)
		root = pNewNode;
	else if (nData < pPNewNode->nData)
		pPNewNode->left = pNewNode;
	else
		pPNewNode->right = pNewNode;

	//再调整到红黑树的性质
	InsertFixup(pNewNode);

	return true;
}

void RBTree::InsertFixup(SubRBTree* pNode)
{
	while (pNode->parent->color == RED)
	{
		//pNode的父节点是其父节点的左子节点
		if (pNode->parent == pNode->parent->parent->left)
		{
			SubRBTree* pUNode = pNode->parent->parent->right;//pNode的叔父节点

			if (pUNode->color == RED)//情况三
			{
				pNode->parent->color = BLACK;
				pUNode->color = BLACK;
				pNode->parent->parent->color = RED;

				pNode = pNode->parent->parent;//变色处理，下一个要调整的节点是其祖父节点【变色是向上破坏的，而祖父节点对应的子树已经在此变换中平衡】【所以继续调整的是以其祖父节点开始】
			}
			else if (pNode == pNode->parent->right)//情况四
			{
				pNode = pNode->parent;//以父节点旋转，旋转后父节点变为子节点，再继续从这个"父"节点调整【画图理解】
				pNode->RotateLeft(&root, nil);
				//RotateLeft(pNode);
			}
			else//情况五
			{
				//调整后，继续调整时依然以这个节点开始调整
				pNode->parent->color = BLACK;
				pNode->parent->parent->color = RED;
				pNode->parent->parent->RotateRight(&root, nil);
				//RotateRight(pNode->parent->parent);
			}
		}
		else//pNode的父节点是其父节点的右子节点
		{
			SubRBTree* pUNode = pNode->parent->parent->left;//pNode的叔父节点

			if (pUNode->color == RED)//情况三
			{
				pNode->parent->color = BLACK;
				pUNode->color = BLACK;
				pNode->parent->parent->color = RED;

				pNode = pNode->parent->parent;
			}
			else if (pNode == pNode->parent->left)//情况四
			{
				pNode = pNode->parent;
				pNode->RotateRight(&root, nil);
				//RotateRight(pNode);
			}
			else情况五
			{
				pNode->parent->color = BLACK;
				pNode->parent->parent->color = RED;
				pNode->parent->parent->RotateLeft(&root, nil);
				//RotateLeft(pNode->parent->parent);
			}
		}
	}

	root->color = BLACK;//这里处理了情况一
	//情况二不用处理，自动满足红黑树性质
}

void RBTree::InsertFixupEx(SubRBTree* pNode)
{
	while (pNode->parent->color==RED)
	{
		//父节点是其祖父节点的左节点
		if (pNode->parent==pNode->parent->parent->left) {
			SubRBTree* pUNode = pNode->parent->parent->right;//pNode的叔父节点
			if (pUNode->color == RED)//情况三
			{
				pNode->parent->color = BLACK;
				pUNode->color = BLACK;
				pNode->parent->parent->color = RED;

				pNode = pNode->parent->parent;
			}
			else if(pNode==pNode->parent->right)//情况四
			{
				pNode = pNode->parent;
				pNode->RotateLeft(&root, nil);
			}
			else//情况五
			{
				pNode->parent->color = BLACK;
				pNode->parent->parent->color = RED;
				pNode->parent->parent->RotateRight(&root, nil);
			}
		}
		else
		{
			//父节点是其祖父节点的右节点
			SubRBTree* pUNode = pNode->parent->parent->left;//pNode的叔父节点
			if (pUNode->color == RED)
			{
				pNode->parent->color = BLACK;
				pUNode->color = BLACK;

				pNode->parent->parent->color = RED;

				pNode= pNode->parent->parent;
			}
			else if (pNode == pNode->parent->left)
			{
				pNode = pNode->parent;
				pNode->RotateRight(&root, nil);
			}
			else
			{
				pNode->parent->color = BLACK;
				pNode->parent->parent->color = RED;
				pNode->parent->parent->RotateLeft(&root, nil);
			}

		}
	}
	root->color = BLACK;
}

bool RBTree::Delete(const int nData)
{
	//查找要删除的节点
	SubRBTree* pDeleteNode = FindNode(nData);

	if (pDeleteNode == nil)
	{
		std::cout << "no Find" << std::endl;
		return false;
	}

	DeleteNode(pDeleteNode);

	return true;
}

SubRBTree* RBTree::FindNode(const int nData)
{
	SubRBTree* pTemp = root;

	while (pTemp != nil)
	{
		if (nData < pTemp->nData)
			pTemp = pTemp->left;
		else if (nData > pTemp->nData)
			pTemp = pTemp->right;
		else
			return pTemp;
	}

	return nil;
}

void RBTree::DeleteNode(SubRBTree* pNode)
{
	if (pNode->left != nil && pNode->right != nil)
	{
		//删除节点有二个子节点,除非删除的情况三
		SubRBTree*pNextNode=Minimum(pNode->right);//找后继节点
		pNode->nData=pNextNode->nData;
		pNode = pNextNode;
	}

	if (pNode->left != nil)
	{
		//删除节点只有一个节点，触发删除的情况二
		if (pNode->parent->left == pNode)
			pNode->parent->left = pNode->left;
		else		
			pNode->parent->right = pNode->left;
		
		pNode->left->parent = pNode->parent;
		pNode->left->color = BLACK;
		delete pNode;
	}
	else if (pNode->right != nil)
	{
		//删除节点只有一个节点，触发删除的情况二

		if (pNode->parent->left == pNode)
			pNode->parent->left = pNode->right;
		else
			pNode->parent->right = pNode->right;

		pNode->right->parent = pNode->parent;
		pNode->right->color = BLACK;
		delete pNode;
	}
	else
	{
		//删除节点 没有子节点，触发删除情况一

		if (pNode->color == RED)//删除情况1.1
		{
			if (pNode->parent->left == pNode)
				pNode->parent->left = nil;
			else
				pNode->parent->right = nil;
			delete pNode;
		}
		else//删除情况1.2
		{
			//先调整再删除，调整过程中删除节点挂在树上，最后调整完再删除;整个调整过程中(旋转，变色操作)不会让删除节点(这里指真正要删除的节点，而不是每次观察时化身的节点)获得子节点
			DeleteFixup(pNode);

			if (pNode == root)
				root = nil;
			if (pNode == pNode->parent->left)
				pNode->parent->left = nil;
			else
				pNode->parent->right = nil;

			delete pNode;
		}
			
	}
	return ;
}

void RBTree::DeleteFixup(SubRBTree* pNode)
{
	while (pNode != root && pNode->color == BLACK)//触发调整情况二，三
	{
		if (pNode == pNode->parent->left)
		{
			SubRBTree* pBNode = pNode->parent->right;//pNode的兄弟节点

			if (pBNode->color = RED)//右兄红，触发调整情况三
			{
				//变色
				pBNode->color = BLACK;
				pNode->parent->color = RED;
				
				pNode->parent->RotateLeft(&root, nil);
				//RotateLeft(pNode->parent);
				pBNode = pNode->parent->right;//重新观察，pNode删除节点不变，兄弟节点观察更新=>依然是右兄，且颜色是黑色【根据红黑树性质】
			}

			if (pBNode->left->color == BLACK && pBNode->right->color == BLACK)//触发调整情况2.1;兄黑且兄子节点全黑
			{
				//处理情况2.1.1/2.1.2
				pBNode->color = RED;//将兄节点涂红
				pNode = pNode->parent;//将pNode节点视为pNode的父节点进行观察,如果此时父节点是红色=>收敛，否则继续递归向上处理平衡操作
			}
			else if (pBNode->right->color == BLACK)//处理情况2.2
			{
				//情况2.2.2
				pBNode->left->color = BLACK;
				pBNode->color = RED;

				pBNode->RotateRight(&root, nil);
				//RotateRight(pBNode);
				pBNode = pNode->parent->right;//重新观察pNode不变，兄节点更新
			}
			else
			{
				//触发情况2.2.1
				//交换父节点和兄节点颜色，并将兄节点的右子节点涂黑
				pBNode->color = pNode->parent->color;
				pNode->parent->color = BLACK;
				pBNode->right->color = BLACK;

				pNode->parent->RotateLeft(&root, nil);
				//RotateLeft(pNode->parent);
				pNode = root;//收敛，平衡调整结束【结束后可以直接删除最开始的删除节点】
			}
		}
		else
		{
			SubRBTree* pBNode = pNode->parent->left;//pNode的兄弟节点，左兄

			if (pBNode->color = RED)//左兄红，触发调整情况三
			{
				pBNode->color = BLACK;
				pNode->parent->color = RED;

				pNode->parent->RotateRight(&root, nil);
				//RotateRight(pNode->parent);
				pBNode = pNode->parent->left;
			}

			if (pBNode->left->color == BLACK && pBNode->right->color == BLACK)//触发调整情况2.1;兄黑且兄子节点全黑
			{
				//处理情况2.1.1/2.1.2
				pBNode->color = RED;
				pNode = pNode->parent;
			}
			else if (pBNode->left->color == BLACK)//处理情况2.2
			{
				//情况2.2.2
				pBNode->right->color = BLACK;
				pBNode->color = RED;

				pBNode->RotateLeft(&root, nil);
				//RotateLeft(pBNode);
				pBNode = pNode->parent->left;
			}
			else
			{
				//触发情况2.2.1
				pBNode->color = pNode->parent->color;
				pNode->parent->color = BLACK;
				pBNode->left->color = BLACK;

				pNode->parent->RotateRight(&root, nil);
				//RotateRight(pNode->parent);
				pNode = root;
			}
		}
	}

	pNode->color = BLACK;//处理调整平衡情况2.1.2=>收敛；【收敛;需要删除的是最开始的删除节点，不一定是此时的pNode指向的节点】

	//情况一无需调整
}

void RBTree::PrintTree(SubRBTree* pNode,int nDepth,int state) const
{
	if (nil == pNode)
		return;
	
	PrintTree(pNode->left, nDepth + 1, 1);
	
	for (int i = 0; i < nDepth; i++)
		printf("     ");
	if (state == 1) // left
		printf("┌───");
	else if (state == 0)  // right
		printf("└───");

	std::cout << "[" << (pNode->color==RED ? "红:":"黑:") << pNode->nData << "]" << std::endl;
	
	PrintTree(pNode->right, nDepth + 1, 0);
}



//cpp
#include "MyRbTree.h"
#include <exception>

int main()
{
	try
	{
		RBTree rbt;
		for (int i = 1; i < 100; i++)
		{
			rbt.Insert(i);
		}
		rbt.Delete(4);
		rbt.Display();
	}
	catch (std::exception& e)
	{
		std::cout << e.what() << std::endl;
	}
	return 0;
}
小小bugbug
关注
C++简单实现红黑树的插入
06-06
总的来说，C++实现红黑树的插入操作涉及到对红黑树特性的深入理解、节点结构体的设计、颜色调整规则的编码以及旋转操作的实现。这是一项既挑战性又富有成就感的任务，能帮助开发者更好地掌握数据结构和算法。
红黑树-基于C++实现的红黑树数据结构.zip
03-21
在C++中实现红黑树时，通常会定义一个名为`RBTree`的类，包含私有成员变量（如根节点指针）和公共成员函数（如`insert`, `delete`, `search`等）。类的构造函数初始化空树，而析构函数则负责释放所有节点。为了确保...
C++实现红黑树（含完整代码+图）
weixin_44628585的博客
08-09 2453
此文主要记录红黑树的操作，即节点的添加删除操作，并且有完整代码可供学习。欢迎大家阅读，如有问题，麻烦大家指出。
【C++进阶06】红黑树图文详解及C++模拟实现红黑树
2302_76421042的博客
01-12 3548
红黑树详解、模拟实现
C++实现红黑树的插入与删除
apple_51693367的博客
02-10 1066
基于c++所写的红黑树，包括红黑树最主要的插入和删除算法，并有最终的测试示例
红黑树（C++实现）
2202_75331338的博客
07-22 1080
◉ 如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的，现在看到红色的原因是因为cur的子树在调整的过程中将cur节点的颜色由黑色改成红色。◉ 如果u节点不存在，则cur一定是新插入节点，因为如果cur不是新插入节点，则cur和p一定有一个节点的颜色是黑色，就不满足性质4：每条路径黑色节点个数相同。p为g的左孩子，cur为p的右孩子，则对p先进行左单旋，回到情况二 再对g进行右单旋。p为g的右孩子，cur为p的左孩子，则对p先进行右单旋，回到情况二 再对g进行左单旋。
C++红黑树
~
03-26 6702
C++红黑树零、前言一、红黑树的概念及性质二、红黑树结点的定义三、红黑树的插入操作1、变色处理2、单旋+变色3、双旋+变色4、插入实现四、红黑树的验证五、红黑树的删除六、红黑树与**AVL**树的比较 零、前言 本章继AVL树后继续讲解学习C++中另一个二叉搜索树–红黑树 一、红黑树的概念及性质 概念： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长
C++实现——红黑树
sqm_C的博客
08-20 776
我们将红色与黑色设置成枚举类型，使代码看起来更加规范，我们定义节点采用类模板的方式，内部成员分别是左节点指针，右节点指针，父亲节点指针，pair结构体类型的变量，然后就是代表我们颜色的变量。我们再对它们进行初始化列表就可以了，我们的每个节点初始颜色都得设置成红色，不然就无法满足我们上面给的5条红黑树的性质。
红黑树C++实现
Brant_zero的博客
11-24 1464
红黑树c++实现，平衡二叉搜索树。插入、查找、平衡调整、平衡判定、高度检测、升序遍历(中序遍历)
c++——红黑树
Britney_dark的博客
11-13 4743
愿你终将与重要的人重逢！
C++之红黑树
qq_74732628的博客
04-28 865
文章讲解了红黑树的原理和操作
红黑树的C++实现（只实现插入操作）
11-04
C++实现红黑树的难点在于理解和实现上述旋转和颜色调整策略，以确保每次插入后都能保持红黑树的性质。虽然删除操作更为复杂，涉及到更多的边界条件和旋转，但掌握插入操作是理解红黑树的基础。 总的来说，红黑树在...
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 968
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 988
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 856
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
Codeforces Round 973 (Div. 2) C. Password Cracking
puzhaoyu的博客
09-21 664
说明已经构建到了最右边，那么开始向左边构建。（写这题的时候一直不对，后来发现是忘记cin >> t了，归根结底还是不熟悉交互式编程的输入输出方式）猜一串二进制密码，每次可询问某串字符是否是密码的子串。从左到右不断构建ans字符串，每次不是加。，这可以通过询问得到。
C++ 知识要点：对象内存模型
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-21 665
在C++中，通过和->访问对象成员的主要区别在于它们的访问方式和语法。用于直接对象，而->用于通过指针间接访问对象。尽管在底层实现和性能上可能存在微小的差异，但这些差异通常被现代编译器的优化所掩盖。更重要的是要考虑代码的可读性、维护性和安全性。在实际的C++实现中，不同的编译器可能会采用不同的策略来记录虚基类子对象的偏移信息。一些编译器可能会选择将偏移信息嵌入到虚函数表中，而另一些则可能会使用额外的指针。这些选择通常取决于编译器的设计目标、性能考虑以及与其他特性的兼容性。
简易STL实现 | Set 的实现
最新发布
AsherGu的博客
09-26 276
如何使用；代码实现及其他（包括之前红黑树可以运行实现）
C++实现红黑树模板类
"这是一个C++实现的红黑树模板类，包含插入、删除和查找操作，以及旋转函数。" 红黑树是一种自平衡的二叉查找树（BST），它在进行插入和删除操作后能保持相对较好的平衡性，从而提供高效的查找、插入和删除性能。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值