C++ 红黑树的实现

最新推荐文章于 2024-08-11 12:35:26 发布
最新推荐文章于 2024-08-11 12:35:26 发布
阅读量7k 收藏 10
点赞数 1
分类专栏： 数据结构算法 C/C++/C# 逻辑算法 文章标签： c++ insert delete null tree interface
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xgx198831/article/details/7335194
版权

红黑树性质及实现详细介绍：

http://zh.wikipedia.org/zh/%E7%BA%A2%E9%BB%91%E6%A0%91

代码部分：

 头文件

// RBTree.h: interface for the CRBTree class.
//
//

#if !defined(AFX_RBTREE_H__9C701E48_A116_4AE0_8736_B5F45F530AF5__INCLUDED_)
#define AFX_RBTREE_H__9C701E48_A116_4AE0_8736_B5F45F530AF5__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#define BLACK 0
#define RED   1
#define NULL  0
typedef int BOOL;

typedef struct RBTreeNode
{
	int key;
	int color;
	struct RBTreeNode *parent, *left, *right;
	RBTreeNode(){}
	RBTreeNode(int k):key(k){  // 创建新结点默认颜色为红色
		color = RED;
		parent = NULL;
		left = NULL;
		right = NULL;}
}RBTree, RBTreeNode;


class CRBTree  
{
public:
	CRBTree();
	virtual ~CRBTree();

	void RB_InitLeafNode();
	BOOL RB_Insert(int keyVal);
	BOOL RB_Delete(int keyVal);
	RBTreeNode *RB_Find(int keyVal);
	void RB_Print();
	int RB_GetSize()const { return m_Size; }
private:
	void RB_Insert_FixedUp(RBTreeNode *&pNode);
	void RB_Del_FixedUp(RBTreeNode *&pNode);
	void RB_Left_Rotate(RBTreeNode *&pNode);
	void RB_Right_Rotate(RBTreeNode *&pNode);
	void RB_Print(RBTreeNode *&pNode);
	void RB_SwapTwoNodes(RBTreeNode *&pNode1, RBTreeNode *&pNode2);
	void RB_EmptyTree(RBTreeNode *&pNode);
private:
	RBTree *m_root;  //根结点
	RBTreeNode *m_NIL; // 空结点
	int m_Size;
};

#endif // !defined(AFX_RBTREE_H__9C701E48_A116_4AE0_8736_B5F45F530AF5__INCLUDED_)


 

实现文件

// RBTree.cpp: implementation of the CRBTree class.
//
//
#include <iostream>
#include "RBTree.h"
using namespace std;

//
// Construction/Destruction
//
// 构造函数
CRBTree::CRBTree()
{
	m_root = m_NIL = NULL;
	m_Size = 0;
}

// 析构函数
CRBTree::~CRBTree()
{
	RB_EmptyTree(m_root);
	delete m_NIL;
	m_root = m_NIL = NULL;
	cout << "Empty the tree!\n";
}

// 初始化叶子结点
void CRBTree::RB_InitLeafNode()
{
	m_root = new RBTree(-1);
	m_NIL = new RBTreeNode(-1);
	m_NIL->color = BLACK;  // 叶子结点颜色都为黑色
	m_NIL->parent = NULL;
	m_NIL->left = m_NIL->right = NULL;
	m_root = m_NIL;
	m_root->parent = m_NIL;
}

// 插入树结点
BOOL CRBTree::RB_Insert( int keyVal )
{
	RBTreeNode *pNewNode = new RBTreeNode(keyVal);
	pNewNode->left = m_NIL;
	pNewNode->right = m_NIL;
	RBTreeNode *pNode = m_root;
	RBTreeNode *pPreNode = m_NIL;
	while(pNode != m_NIL)  // 树不为空
	{
		pPreNode = pNode;
		if (keyVal < pNode->key)
		{
			pNode = pNode->left;
		}
		else if (keyVal > pNode->key)
		{
			pNode = pNode->right;
		}
		else{
			delete pNewNode;
			return 0;
		}
	}
	pNewNode->parent = pPreNode;
	if (pPreNode == m_NIL)  // 树为空
	{
		pNewNode->color = BLACK;
		m_root = pNewNode;
	}
	else
	{
		if (keyVal < pPreNode->key)
		{
			pPreNode->left = pNewNode;
		}
		else
			pPreNode->right = pNewNode;
	}
	m_Size++;
	cout << "Insert "<< m_Size << " node: " << keyVal << " succeeded!\n";
	RB_Insert_FixedUp(pNewNode);
	return 1;
}

// 删除树结点
BOOL CRBTree::RB_Delete( int keyVal )
{
	RBTreeNode *pDelNode, *pPreNode = m_NIL;
	if (m_root == m_NIL)
	{
		return 0;
	}
// 	pDelNode = m_root;
// 	while(pDelNode != m_NIL)
// 	{
// 		if (keyVal < pDelNode->key)
// 		{
// 			pPreNode = pDelNode;
// 			pDelNode = pDelNode->left;
// 		}
// 		else if (keyVal > pDelNode->key)
// 		{
// 			pPreNode = pDelNode;
// 			pDelNode = pDelNode->right;
// 		}
// 		else
// 			break;
// 	}
	pDelNode = RB_Find(keyVal);
	if (pDelNode == NULL)
	{
		return 0; // 没有此结点
	}
	pPreNode = pDelNode->parent;
	//从该结点的左子树找出最大的结点或从右子树找出最小的结点， 两者的值进行替换
	RBTreeNode *pTemp;
	RBTreeNode *pDelChild;
	if (pDelNode->left != m_NIL && pDelNode->right != m_NIL)
	{ // 有两个子结点，查找左子树
		pTemp = pDelNode->left;
		while(pTemp->right != m_NIL)
		{
			pTemp = pTemp->right;
		}

		RB_SwapTwoNodes(pTemp, pDelNode);
	
		pDelChild = pTemp->left;
		pDelChild->parent = pTemp->parent;
		if (pTemp->parent->left == pTemp)
		{
			pTemp->parent->left = pDelChild;
		}
		else
			pTemp->parent->right = pDelChild;
	}
	else if (pDelNode->left == m_NIL && pDelNode->right == m_NIL)
	{ // 要删除的结点是叶子结点
		if (pPreNode == m_NIL)
		{
			delete m_root;
			m_root = m_NIL;
			m_Size--;
			return 1;
		}
		else
		{
			if (pDelNode == pDelNode->parent->left)
			{
				pPreNode->left = m_NIL;
			}
			else
				pPreNode->right = m_NIL;
			pDelChild = m_NIL;
			pDelChild->parent = pDelNode->parent;
			pTemp = pDelNode;
		}
	}
	else // 有一个子结点
	{ 
		if (pDelNode->left != m_NIL)
		{
			pDelChild = pDelNode->left;
		}
		else 
		{
			pDelChild = pDelNode->right;
		}
		if (pDelChild == pPreNode->left)
		{
			pDelChild->parent = pPreNode;
			pPreNode->left = pDelChild;
		}
		else
		{
			pDelChild->parent = pPreNode;
			pPreNode->right = pDelChild;
		}
		pTemp = pDelNode;	
	}
	if (pTemp->color == BLACK)
	{
		RB_Del_FixedUp(pDelChild);
	}
	cout << "Deleted node: " << pTemp->key << endl;
	delete pTemp;
	m_Size--;
	return 1;
}

// 查找指定结点，成功 放回该结点，否则返回NULL
RBTreeNode * CRBTree::RB_Find( int keyVal )
{
	RBTreeNode *pNode;
	if (m_root == m_NIL)
	{
		return NULL;
	}
	pNode = m_root;
	while(pNode != m_NIL)
	{
		if (keyVal < pNode->key)
		{
			pNode = pNode->left;
		}
		else if (keyVal > pNode->key)
		{
			pNode = pNode->right;
		}
		else{
			cout << "Find node: " << keyVal << "succeeded!\n";
			return pNode;
		}
	}
	return NULL;
}

// 插入结点后形成的新结构不满足红黑树性质和对其进行处理
void CRBTree::RB_Insert_FixedUp( RBTreeNode *&pNode )
{
	while (pNode->parent->color == RED)
	{
		RBTreeNode *pNodeParent = pNode->parent;
		RBTreeNode *pNodePaBro;
		if (pNodeParent->parent->left == pNodeParent) 
			pNodePaBro = pNodeParent->parent->right;
		else
			pNodePaBro = pNodeParent->parent->left;
		if (pNodePaBro->color == RED)
		{  // 父结点和叔结点都是红色 ==>> 父--黑  叔--黑  祖父--红
			pNodeParent->color = BLACK;
			pNodePaBro->color = BLACK;
			pNodeParent->parent->color = RED;
			pNode = pNode->parent->parent;
			if (pNode == m_NIL)
			{
				m_root->color = BLACK;
				return ;
			}
		}
		/// 红父 黑叔结点 或者没有叔结点
		else if(pNodeParent->parent->left == pNodeParent && pNodeParent->left == pNode)
		{
			pNodeParent->color = BLACK;
			pNodeParent->parent->color = RED;
			RB_Right_Rotate(pNode->parent->parent);
			break;
		}
		else if (pNodeParent->parent->left == pNodeParent && pNodeParent->right == pNode)
		{
			pNode = pNode->parent;
			RB_Left_Rotate(pNode);
		}
		else if (pNodeParent->parent->right == pNodeParent && pNodeParent->left == pNode)
		{
			pNode = pNode->parent;
			RB_Right_Rotate(pNode);
		}
		else 
		{
			pNodeParent->color = BLACK;
			pNodeParent->parent->color = RED;
			RB_Left_Rotate(pNode->parent->parent);
			break;
		}
	}// while
	m_root->color = BLACK;
}

// 删除结点后形成的新结构不满足红黑树性质和对其进行处理
void CRBTree::RB_Del_FixedUp( RBTreeNode *&pNode )
{
	int nLRFlag;
	RBTreeNode *pBroNode;
	while(pNode != m_root && pNode->color == BLACK)
	{
		if (pNode->parent->left == pNode)
		{
			nLRFlag = 0;
			pBroNode = pNode->parent->right;
		}
		else 
		{
			nLRFlag = 1;
			pBroNode = pNode->parent->left;
		}
		
		//1 父-red  无兄 子-red  ==>> 子-black
		//2 父-black  兄-red  ==>> 父-red 兄-black 旋转父结点 
		if (pBroNode->color == RED)
		{
			pNode->parent->color = BLACK;
			pBroNode->color = BLACK;
			if (nLRFlag == 0)
			{
				RB_Left_Rotate(pNode->parent);
			}
			else
				RB_Right_Rotate(pNode->parent);
		}
		//3 兄-black  两黑侄  ==>>	兄=红 子=黑 红父=黑 往上遍历(黑父)
		else if (pBroNode->left->color == BLACK && pBroNode->right->color == BLACK)
		{
			pNode->color = BLACK;
			pBroNode->color = RED;
			pNode->parent->color = BLACK;
			pNode = pNode->parent;  // 往上遍历
		}
		//4 兄-black  左黑侄右红侄  ==>> 兄=父色 父=黑 侄=黑 (子=黑) 左旋转父节点
		else if (pBroNode->left->color == BLACK && pBroNode->right->color == RED)
		{
			if (nLRFlag == 0)
			{
				pBroNode->color = pNode->parent->color;
				pNode->parent->color = BLACK;
				pNode->color = BLACK;
				pBroNode->right->color = BLACK;				
				RB_Left_Rotate(pNode->parent);
				break;
			}
			else 
			{
				RBTreeNode *pPa = pNode->parent;
				pBroNode->left->color = pNode->parent->color;
				pNode->parent->color = BLACK;
				RB_Left_Rotate(pBroNode);
				RB_Right_Rotate(pPa);
				break;
			}	
		}
		//5	兄-black  左红侄右黑侄  ==>> 侄=父色 父=黑 右旋转兄 左旋转父
		else if (pBroNode->left->color == RED && pBroNode->right->color == BLACK)
		{
			
			if (nLRFlag == 0)
			{
				RBTreeNode *pPa = pNode->parent;
				pBroNode->left->color = pNode->parent->color;
				pNode->parent->color = BLACK;
				RB_Right_Rotate(pBroNode);
				RB_Left_Rotate(pPa);
				break;
			}
			else 
			{
				pBroNode->color = pNode->parent->color;
				pNode->parent->color = BLACK;
				pNode->color = BLACK;
				pBroNode->right->color = BLACK;				
				RB_Right_Rotate(pNode->parent);
				break;
			}	
		}
		else  //两红侄的情况 转换成一黑一红的情况
		{
			if (nLRFlag == 0)
			{
				pBroNode->left->color = BLACK;
			}
			else
			{
				pBroNode->right->color = BLACK;
			}	
		}
	}
	pNode->color = BLACK;  //子 ==> black
	return;
}

// 左旋处理
void CRBTree::RB_Left_Rotate( RBTreeNode *&pNode )
{
	RBTreeNode *pNodeA = pNode->parent;
	RBTreeNode *pNodeB = pNode->right;
	pNode->right = pNodeB->left;
	pNodeB->left->parent = pNode;
	pNodeB->left = pNode;
	pNode->parent = pNodeB;

	if (pNode == pNodeA->left)
	{  // 父子不同边
		pNodeA->left = pNodeB;
		pNodeB->parent = pNodeA;
	}
	else if (pNode = pNodeA->right)
	{
		pNodeA->right = pNodeB;
		pNodeB->parent = pNodeA;
	}
	else // m_root == m_NIL
	{
		if (pNodeA == m_NIL)
		{  // pNode 原本为根结点
			pNodeB->parent = m_NIL;
			m_root = pNodeB;
		}
	}
	cout << "RB_Left_Rotate()\n";
}

// 右旋处理函数
void CRBTree::RB_Right_Rotate( RBTreeNode *&pNode )
{
	RBTreeNode *pNodeA = pNode->parent;
	RBTreeNode *pNodeB = pNode->left;
	pNode->left = pNodeB->right;
	pNodeB->right->parent = pNode;
	pNodeB->right = pNode;
	pNode->parent = pNodeB;
	
	if (pNode == pNodeA->right)
	{  // 父子不同边
		pNodeA->right = pNodeB;
		pNodeB->parent = pNodeA;
	}
	else if (pNode = pNodeA->left)
	{
		pNodeA->left = pNodeB;
		pNodeB->parent = pNodeA;
	}
	else // m_root == m_NIL
	{
		if (pNodeA == m_NIL)
		{  // pNodeA 原本为父结点
			pNodeB->parent = m_NIL;
			m_root = pNodeB;
		}
	}
	cout << "RB_Right_Rotate()\n";
}

void CRBTree::RB_Print()
{
	if (m_root == m_NIL)
	{
		cout << "树为空！\n";
		return ;
	}
	RB_Print(m_root);
	cout << endl;
}

void CRBTree::RB_Print( RBTreeNode *&pNode )
{
	if (pNode != m_NIL)
	{
		cout << pNode->key << "(" << pNode->color << ")  ";
		RB_Print(pNode->left);
		RB_Print(pNode->right);
	}
}

void CRBTree::RB_SwapTwoNodes( RBTreeNode *&pNode1, RBTreeNode *&pNode2 )
{
	int t = pNode1->key;
	pNode1->key = pNode2->key;
	pNode2->key = t;
}

void CRBTree::RB_EmptyTree( RBTreeNode *&pNode )
{
	if (pNode != m_NIL)
	{
		RB_EmptyTree(pNode->left);
		RB_EmptyTree(pNode->right);
		delete pNode;
	}
}


 

测试文件

//
//
#include <iostream>
#include "RBTree.h"
#include <Windows.h>
#include <ctime>
using namespace std;

void time_Test();
void Fun_Test();
int main()
{
	cout << "红黑树RBTree测试程序 !\n";
	Fun_Test();
	return 0;
}

void Fun_Test()
{
	CRBTree tree;
	tree.RB_InitLeafNode();
 	tree.RB_Insert(10);
 	tree.RB_Insert(14);
 	tree.RB_Insert(4);
 	tree.RB_Insert(12);
	tree.RB_Insert(11);
	tree.RB_Insert(13);
 	tree.RB_Insert(7);
 	tree.RB_Insert(16);
 	tree.RB_Print();
 	tree.RB_Delete(14);
 	tree.RB_Delete(10);
 	Sleep(1000);
	tree.RB_Print();
}

void time_Test()
{
	CRBTree tree;
	clock_t t_insert, t_print, t_find;
	int nArrNodes[50000];
	tree.RB_InitLeafNode();
	srand((unsigned)time(NULL));
//	srand(0);
	t_insert = clock();
	for (int i = 0; i < 50000; i++)
	{
		nArrNodes[i] = rand()%10000000 +1;
		while (1)
		{
			if (tree.RB_Find(nArrNodes[i]) == NULL)
			{
				tree.RB_Insert(nArrNodes[i]);
				break;
			}
			else
				nArrNodes[i] = rand()%10000000 +1;
		}
	}
	t_insert = clock() - t_insert;
	t_print = clock();
	
	tree.RB_Print();
	t_print = clock() - t_print;
	t_find = clock();
	tree.RB_Find(32725);
	t_find = clock() - t_find;
	cout << "The tree nodes count is: " << tree.RB_GetSize() << endl;
	cout << "Insert data need time: " << t_insert << "ms." << endl;
	cout << "Print data need time: " << t_print << "ms." << endl;
	cout << "Find one data need time: " << t_find << "ms." << endl;
}


 

夜空划过的流星
关注
专栏目录
红-黑树——C++实现
Mind_V的博客
05-27 766
一、红-黑树基本概念红-黑树(Red-Black tree)是一种特殊的二叉查找树，因此具有二叉查找树的特征：任意一个节点所包含的关键字，大于左孩子的关键字，小于右孩子的关键字。树中每一个节点的颜色或者是黑色或者是红色，和AVL树一样具有平衡性。每一个空指针用一个外部结点来替代，红-黑树的性质可以描述为：RB1：根节点和外部节点都是黑色。 RB2：在根至外部节点路径上，没有连续两个节点是红色。
红黑树C++实现
01-27
红黑树的C++完整实现代码
C++——红黑树（图片+动图详解）
最新发布
2301_80687320的博客
08-11 832
在了解完平衡搜索二叉树的优势和应用后，我们学习了AVL树这种方案来实现它，但在前人们的不断使用和开辟，另一种更优的方案横空出世——红黑树。一、红黑树是什么？红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路 径会比其他路径长出俩倍，因而是接近平衡的。通过图片的观察，我们发红黑树有一下几个性质1、每个结点不是红色就是黑色；2、根节点是黑色；3、红色节点不能是连续两个；
【C++】——红黑树（手撕红黑树，彻底弄懂红黑树）
m0_74092462的博客
07-26 1351
我们之前都学过ALV树，AVL树的本质就是一颗平衡二叉树，它的作用就是查找，插入和删除节点，最坏的时间复杂度都是O(logn)的，同时维护的高度差都是小于等于1的，但是也就是因为这个原因才被红黑树所替代红黑树是一种自平衡的二叉查找树，是一种高效的查找树。它是由 Rudolf Bayer 于1978年发明，在当时被称为平衡二叉 B 树(symmetric binary B-trees)。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的红黑树。
[C++] 红黑树（Red-Black Tree）详解
方歧的博客
08-11 405
红黑树是一种自平衡的二叉搜索树，具有对数时间复杂度的插入、删除和查找操作。它通过特定的节点颜色和旋转操作来保持平衡。C++ 标准库中的std::map和std::set就是基于红黑树实现的。上述示例展示了红黑树的基本实现，包括节点插入和树的平衡维护。了解红黑树的基本操作和实现细节对优化数据结构和提高程序效率非常重要。
红黑树（C++实现）
热门推荐
2021dragon的博客
12-06 1万+
红黑树（C++实现）
红黑树的模拟实现
qq_56663697的博客
02-28 675
文章目录红黑树的概念红黑树的性质红黑树节点的定义红黑树的插入操作按照二叉搜索的树规则插入新节点调整红黑树红黑树的验证红黑树与AVL树的比较 红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 红黑树的性质 每个结点不是红色就是黑色。 根节点是黑色的。 如果一个节点是红色的，则它的两个孩子结点是黑色的。 对于每个结点，从该结点到
c++实现红黑树
weixin_40604198的博客
11-27 212
红黑树不止5个性质 因为插入时默认红色节点插入导致了其他性质 黑单黑没有 红单黑没有 左旋右旋要选定旋点 代码重复严重 #ifndef _TREE_ #define _TREE_ #include&lt;string&gt; #include&lt;vector&gt; using std::string; using std::vector; template&lt;c...
C++实现红黑树
weixin_53064820的博客
08-30 415
5.从根节点出发到叶子节点，每一条路径的黑色节点数量是相同的。红黑树是一个平衡二叉树（左子节点比当前节点小，右子节点比当前节点大）。3.红色节点的子节点必须是黑色节点。（红色节点被黑色节点隔开）2.一个节点要么是黑色，要么是红色。4.叶子节点的颜色是黑色的。1.根节点的颜色是黑色的。...
C++红黑树实现过程
09-15
在C++中实现红黑树，需要理解并遵循红黑树的五个性质： 1. 每个节点要么是红色，要么是黑色。 2. 根节点是黑色。 3. 所有叶子节点（NIL或空节点）是黑色。 4. 如果一个节点是红色，则它的两个子节点都是黑色。 5. ...
红黑树-基于C++实现的红黑树数据结构.zip
03-21
例如，在C++标准模板库(STL)中，`std::set`和`std::map`就是基于红黑树实现的。 在C++中实现红黑树时，通常会定义一个名为`RBTree`的类，包含私有成员变量（如根节点指针）和公共成员函数（如`insert`, `delete`, `...
基于C++红黑树与哈希表的实现
05-08
`Red_black_tree-code`可能是包含红黑树实现的源代码文件，可以参考其中的实现细节，学习如何在C++中构建和操作自定义数据结构。 总的来说，掌握红黑树和哈希表的原理和C++实现对于提升编程技能和解决复杂问题具有...
C++简单实现红黑树的插入
06-06
总的来说，C++实现红黑树的插入操作涉及到对红黑树特性的深入理解、节点结构体的设计、颜色调整规则的编码以及旋转操作的实现。这是一项既挑战性又富有成就感的任务，能帮助开发者更好地掌握数据结构和算法。
C++红黑树
zhao19971014的博客
11-09 605
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的
c++——红黑树
Britney_dark的博客
11-13 4738
愿你终将与重要的人重逢！
红黑树详解
qq_57283958的博客
05-16 499
红黑树 红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过 对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩 倍，因而是接近平衡的。 红黑树的性质 1. 每个结点不是红色就是黑色 2. 根节点是黑色的 3. 如果一个节点是红色的，则它的两个孩子结点是黑色的 4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点 5. 每个叶子结点...
C++红黑树实现Map
07-28
当然，我可以帮你实现一个基于红黑树的Map数据结构。下面是一个简单的C++代码示例： ```cpp #include <iostream> enum Color { RED, BLACK }; template <typename K, typename V> struct Node { K key; V value; Color color; Node* left; Node* right; Node* parent; // 构造函数 Node(const K& k, const V& v, Color c = RED) : key(k), value(v), color(c), left(nullptr), right(nullptr), parent(nullptr) {} }; template <typename K, typename V> class RBTreeMap { public: RBTreeMap() : root(nullptr) {} // 向红黑树中插入键值对 void insert(const K& key, const V& value) { Node<K, V>* node = new Node<K, V>(key, value); if (root == nullptr) { root = node; node->color = BLACK; } else { Node<K, V>* curr = root; Node<K, V>* parent = nullptr; while (curr != nullptr) { parent = curr; if (key < curr->key) curr = curr->left; else if (key > curr->key) curr = curr->right; else { curr->value = value; // 更新值 return; } } node->parent = parent; if (key < parent->key) parent->left = node; else parent->right = node; insertFixup(node); } } // 查找指定键的值 V find(const K& key) const { Node<K, V>* curr = root; while (curr != nullptr) { if (key < curr->key) curr = curr->left; else if (key > curr->key) curr = curr->right; else return curr->value; } return V(); // 未找到，返回默认值 } private: Node<K, V>* root; // 对红黑树进行修复以维持红黑树的性质 void insertFixup(Node<K, V>* node) { while (node->parent != nullptr && node->parent->color == RED) { if (node->parent == node->parent->parent->left) { Node<K, V>* uncle = node->parent->parent->right; if (uncle != nullptr && uncle->color == RED) { node->parent->color = BLACK; uncle->color = BLACK; node->parent->parent->color = RED; node = node->parent->parent; } else { if (node == node->parent->right) { node = node->parent; rotateLeft(node); } node->parent->color = BLACK; node->parent->parent->color = RED; rotateRight(node->parent->parent); } } else { Node<K, V>* uncle = node->parent->parent->left; if (uncle != nullptr && uncle->color == RED) { node->parent->color = BLACK; uncle->color = BLACK; node->parent->parent->color = RED; node = node->parent->parent; } else { if (node == node->parent->left) { node = node->parent; rotateRight(node); } node->parent->color = BLACK; node->parent->parent->color = RED; rotateLeft(node->parent->parent); } } } root->color = BLACK; } // 左旋 void rotateLeft(Node<K, V>* node) { Node<K, V>* rightChild = node->right; node->right = rightChild->left; if (rightChild->left != nullptr) rightChild->left->parent = node; rightChild->parent = node->parent; if (node->parent == nullptr) root = rightChild; else if (node == node->parent->left) node->parent->left = rightChild; else node->parent->right = rightChild; rightChild->left = node; node->parent = rightChild; } // 右旋 void rotateRight(Node<K, V>* node) { Node<K, V>* leftChild = node->left; node->left = leftChild->right; if (leftChild->right != nullptr) leftChild->right->parent = node; leftChild->parent = node->parent; if (node->parent == nullptr) root = leftChild; else if (node == node->parent->left) node->parent->left = leftChild; else node->parent->right = leftChild; leftChild->right = node; node->parent = leftChild; } }; int main() { RBTreeMap<int, std::string> map; map.insert(1, "one"); map.insert(2, "two"); map.insert(3, "three"); map.insert(4, "four"); std::cout << map.find(2) << std::endl; // 输出: two std::cout << map.find(5) << std::endl; // 输出: 空字符串（默认值） return 0; } ``` 这个示例使用红黑树实现了一个简单的Map数据结构。你可以使用`insert`方法向Map中插入键值对，使用`find`方法查找指定键的值。注意，这只是一个简单的实现，还可以根据需要进行扩展和优化。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值