红黑树c++

最新推荐文章于 2024-08-08 15:12:59 发布
最新推荐文章于 2024-08-08 15:12:59 发布
阅读量21 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74081037/article/details/134758925
版权

1.红黑树的概念

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

2.红黑树的性质

1. 每个结点不是红色就是黑色。

2. 根节点是黑色的 。

3. 如果一个节点是红色的，则它的两个孩子结点是黑色的。  

4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点 。

5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)。

3.红黑树节点的定义

enum Colour
{
	RED,
	BLACK
};

template<class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	T _value;
	Colour _col;

	RBTreeNode(const T&value=T(),Colour col=RED)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _value(value)
		, _col(col)
	{}
};

4.红黑树的结构

为了后续实现关联式容器简单，红黑树的实现中增加一个头结点，因为跟节点必须为黑色，为了 与根节点进行区分，将头结点给成黑色，并且让头结点的 pParent 域指向红黑树的根节点，pLeft 域指向红黑树中最小的节点，_pRight域指向红黑树中最大的节点，如下：

5.红黑树的插入

bool Insert(const T& data)
	{
		Node*& root = GetRoot();
		if (root == nullptr)
		{
			root = new Node(data);
			root->_col = BLACK;
			root->_parent = _pHead;
			_pHead->_left = LeftMost();
			_pHead->_right = RightMost();
			return true;
		}
		Node* cur = root;
		Node* parent = nullptr;
		while (cur)
		{
			if (data > cur->_value)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if(data<cur->_value)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(data);
		if (data > parent->_value)
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		while (parent!=_pHead&&parent->_col==RED)
		{
				Node* grandparent = parent->_parent;
				if (parent == grandparent->_left)
				{
					Node* uncle = grandparent->_right;
					//情况一
					if (uncle && uncle->_col == RED)//uncle存在且为红
					{
						uncle->_col = parent->_col = BLACK;
						grandparent->_col = RED;
						cur = grandparent;
						parent = cur->_parent;
					}
					else//uncle不存在
					{
						//情况三后转为情况二
						if (cur == parent->_right)
						{
							RotateL(parent);
							swap(parent, cur);
						}
						//情况二
						RotateR(grandparent);
						parent->_col = BLACK;
						grandparent->_col = RED; 
					}
				}
				else if (parent == grandparent->_right)
				{
					Node* uncle = grandparent->_left;
					//情况一
					if (uncle && uncle->_col == RED)//uncle存在且为红
					{
						uncle->_col = parent->_col = BLACK;
						grandparent->_col = RED;
						cur = grandparent;
						parent = cur->_parent;
					}
					else//uncle不存在
					{
						//情况三后转为情况二
						if (cur == parent->_left)
						{
							RotateR(parent);
							swap(parent, cur);
						}
						//情况二
						RotateL(grandparent);
						parent->_col = BLACK;
						grandparent->_col = RED;
					}
				}
		}
		root->_col = BLACK;
		_pHead->_left = LeftMost();
		_pHead->_right = RightMost();
		return true;
	}

	// 右单旋
	void RotateR(Node* pParent)
	{
		Node* root = GetRoot();
		Node* subL = pParent->_left;
		Node* subLR = subL->_right;
		Node* grandparent = pParent->_parent;
		pParent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = pParent;
		}
		subL->_right = pParent;
		pParent->_parent = subL;

		if (root == pParent)
		{
			root = subL;
			subL->_parent = _pHead;
			_pHead->_parent = root;
		}
		else
		{
			if (pParent == grandparent->_left)
			{
				grandparent->_left = subL;
			}
			else
			{
				grandparent->_right = subL;
			}
			subL->_parent = grandparent;
		}
	}

	// 左单旋
	void RotateL(Node* pParent)
	{
		Node* root = GetRoot();
		Node* subR = pParent->_right;
		Node* subRL = subR->_left;
		Node* grandparent = pParent->_parent;
		pParent->_right = subRL;
		if (subRL)
		{
			subRL->_parent = pParent;
		}
		subR->_left = pParent;
		pParent->_parent = subR;
		if (root == pParent)
		{
			root = subR;
			subR->_parent = _pHead;
			_pHead->_parent = root;
		}
		else
		{
			if (pParent == grandparent->_left)
			{
				grandparent->_left = subR;
			}
			else
			{
				grandparent->_right = subR;
			}
			subR->_parent = grandparent;
		}
	}
// 获取红黑树最左侧节点
	Node* LeftMost()
	{
		Node* cur = GetRoot();
		if (!cur) return _pHead;
		Node* parent = nullptr;
		while (cur)
		{
			parent = cur;
			cur = cur->_left;
		}
		return parent;
	}

	// 获取红黑树最右侧节点
	Node* RightMost()
	{
		Node* cur = GetRoot();
		if (!cur) return _pHead;
		Node* parent = nullptr;
		while (cur)
		{
			parent = cur;
			cur = cur->_right;
		}
		return parent;
	}

6.红黑树的验证

红黑树的检测分为两步：

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

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

void InOrder()
	{
		_InOrder(GetRoot());
		cout << endl;
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_value << " ";
		_InOrder(root->_right);
	}
// 检测红黑树是否为有效的红黑树，注意：其内部主要依靠_IsValidRBTRee函数检测
	bool IsValidRBTRee()
	{
		Node* root = GetRoot();
		if (root == nullptr)
		{
			return true;
		}
		if (root->_col != BLACK)
		{
			cout << "违反性质二：根节点是黑色" << endl;
		}
		//一条路径的黑色节点个数
		size_t pathBlack = 0;
		Node* cur = root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				pathBlack++;
			}
			cur = cur->_left;
		}
		size_t blackCount = 0;
		
		return _IsValidRBTRee(GetRoot(), blackCount, pathBlack);
	}
private:
	//根节点，黑色节点个数，路径中黑色节点个数
	bool _IsValidRBTRee(Node* pRoot, size_t blackCount,const size_t pathBlack)
	{
		if (pRoot == nullptr)
		{
			if (blackCount != pathBlack)
			{
				cout << "pathBlack:" << pathBlack << endl;
				cout << "blackCount:" << blackCount << endl;
				cout << "违反性质四：每条路径都包含相同的黑色节点" << endl;
				return false;
			}
			return true;
		}
		if (pRoot->_col == BLACK)
			blackCount++;
		Node* parent = pRoot->_parent;
		if (pRoot->_col == RED)
		{
			if (parent&&parent->_col==RED)
			{
				cout << "违反性质三：不能有连续的红色节点" << endl;
				return false;
			}
		}
		return _IsValidRBTRee(pRoot->_left, blackCount, pathBlack) &&
			_IsValidRBTRee(pRoot->_right, blackCount, pathBlack);
	}
	// 为了操作树简单起见：获取根节点
	Node*& GetRoot()
	{
		return _pHead->_parent;
	}

完整代码如下：

#pragma once
#include<iostream>
using namespace std;

enum Colour
{
	RED,
	BLACK
};

template<class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	T _value;
	Colour _col;

	RBTreeNode(const T&value=T(),Colour col=RED)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _value(value)
		, _col(col)
	{}
};



// 请模拟实现红黑树的插入--注意：为了后序封装map和set，本文在实现时给红黑树多增加了一个头结点
template<class T>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	RBTree()
	{
		_pHead = new Node;
		_pHead->_left = _pHead;
		_pHead->_right = _pHead;
	}

	// 在红黑树中插入值为data的节点，插入成功返回true，否则返回false
	// 注意：为了简单起见，本次实现红黑树不存储重复性元素
	bool Insert(const T& data)
	{
		Node*& root = GetRoot();
		if (root == nullptr)
		{
			root = new Node(data);
			root->_col = BLACK;
			root->_parent = _pHead;
			_pHead->_left = LeftMost();
			_pHead->_right = RightMost();
			return true;
		}
		Node* cur = root;
		Node* parent = nullptr;
		while (cur)
		{
			if (data > cur->_value)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if(data<cur->_value)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(data);
		if (data > parent->_value)
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		while (parent!=_pHead&&parent->_col==RED)
		{
				Node* grandparent = parent->_parent;
				if (parent == grandparent->_left)
				{
					Node* uncle = grandparent->_right;
					//情况一
					if (uncle && uncle->_col == RED)//uncle存在且为红
					{
						uncle->_col = parent->_col = BLACK;
						grandparent->_col = RED;
						cur = grandparent;
						parent = cur->_parent;
					}
					else//uncle不存在
					{
						//情况三后转为情况二
						if (cur == parent->_right)
						{
							RotateL(parent);
							swap(parent, cur);
						}
						//情况二
						RotateR(grandparent);
						parent->_col = BLACK;
						grandparent->_col = RED; 
					}
				}
				else if (parent == grandparent->_right)
				{
					Node* uncle = grandparent->_left;
					//情况一
					if (uncle && uncle->_col == RED)//uncle存在且为红
					{
						uncle->_col = parent->_col = BLACK;
						grandparent->_col = RED;
						cur = grandparent;
						parent = cur->_parent;
					}
					else//uncle不存在
					{
						//情况三后转为情况二
						if (cur == parent->_left)
						{
							RotateR(parent);
							swap(parent, cur);
						}
						//情况二
						RotateL(grandparent);
						parent->_col = BLACK;
						grandparent->_col = RED;
					}
				}
		}
		root->_col = BLACK;
		_pHead->_left = LeftMost();
		_pHead->_right = RightMost();
		return true;
	}

	// 右单旋
	void RotateR(Node* pParent)
	{
		Node* root = GetRoot();
		Node* subL = pParent->_left;
		Node* subLR = subL->_right;
		Node* grandparent = pParent->_parent;
		pParent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = pParent;
		}
		subL->_right = pParent;
		pParent->_parent = subL;

		if (root == pParent)
		{
			root = subL;
			subL->_parent = _pHead;
			_pHead->_parent = root;
		}
		else
		{
			if (pParent == grandparent->_left)
			{
				grandparent->_left = subL;
			}
			else
			{
				grandparent->_right = subL;
			}
			subL->_parent = grandparent;
		}
	}

	// 左单旋
	void RotateL(Node* pParent)
	{
		Node* root = GetRoot();
		Node* subR = pParent->_right;
		Node* subRL = subR->_left;
		Node* grandparent = pParent->_parent;
		pParent->_right = subRL;
		if (subRL)
		{
			subRL->_parent = pParent;
		}
		subR->_left = pParent;
		pParent->_parent = subR;
		if (root == pParent)
		{
			root = subR;
			subR->_parent = _pHead;
			_pHead->_parent = root;
		}
		else
		{
			if (pParent == grandparent->_left)
			{
				grandparent->_left = subR;
			}
			else
			{
				grandparent->_right = subR;
			}
			subR->_parent = grandparent;
		}
	}


	// 检测红黑树中是否存在值为data的节点，存在返回该节点的地址，否则返回nullptr
	Node* Find(const T& data)
	{
		if (GetRoot() == nullptr) return nullptr;
		Node* cur = GetRoot();
		while (cur)
		{
			if (cur->_value > data)
			{
				cur = cur->_left;
			}
			else if (cur->_value < data)
			{
				cur = cur->_right;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}

	void InOrder()
	{
		_InOrder(GetRoot());
		cout << endl;
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_value << " ";
		_InOrder(root->_right);
	}

	// 获取红黑树最左侧节点
	Node* LeftMost()
	{
		Node* cur = GetRoot();
		if (!cur) return _pHead;
		Node* parent = nullptr;
		while (cur)
		{
			parent = cur;
			cur = cur->_left;
		}
		return parent;
	}

	// 获取红黑树最右侧节点
	Node* RightMost()
	{
		Node* cur = GetRoot();
		if (!cur) return _pHead;
		Node* parent = nullptr;
		while (cur)
		{
			parent = cur;
			cur = cur->_right;
		}
		return parent;
	}

	// 检测红黑树是否为有效的红黑树，注意：其内部主要依靠_IsValidRBTRee函数检测
	bool IsValidRBTRee()
	{
		Node* root = GetRoot();
		if (root == nullptr)
		{
			return true;
		}
		if (root->_col != BLACK)
		{
			cout << "违反性质二：根节点是黑色" << endl;
		}
		//一条路径的黑色节点个数
		size_t pathBlack = 0;
		Node* cur = root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				pathBlack++;
			}
			cur = cur->_left;
		}
		size_t blackCount = 0;
		
		return _IsValidRBTRee(GetRoot(), blackCount, pathBlack);
	}
private:
	//根节点，黑色节点个数，路径中黑色节点个数
	bool _IsValidRBTRee(Node* pRoot, size_t blackCount,const size_t pathBlack)
	{
		if (pRoot == nullptr)
		{
			if (blackCount != pathBlack)
			{
				cout << "pathBlack:" << pathBlack << endl;
				cout << "blackCount:" << blackCount << endl;
				cout << "违反性质四：每条路径都包含相同的黑色节点" << endl;
				return false;
			}
			return true;
		}
		if (pRoot->_col == BLACK)
			blackCount++;
		Node* parent = pRoot->_parent;
		if (pRoot->_col == RED)
		{
			if (parent&&parent->_col==RED)
			{
				cout << "违反性质三：不能有连续的红色节点" << endl;
				return false;
			}
		}
		return _IsValidRBTRee(pRoot->_left, blackCount, pathBlack) &&
			_IsValidRBTRee(pRoot->_right, blackCount, pathBlack);
	}
	// 为了操作树简单起见：获取根节点
	Node*& GetRoot()
	{
		return _pHead->_parent;
	}
private:
	//_pHead与root互为parent节点，并且_pHead左右指向最左右两端的节点
	Node* _pHead;
};

Sakura＆NANA
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
红黑树C++实现
01-27
在C++中实现红黑树，通常会定义一个节点结构体，包含键值、颜色、左子节点、右子节点以及父节点等成员。然后，我们需要实现以下关键操作： 1. 插入节点：插入新节点时，首先将其标记为红色，然后通过一系列旋转和...
（模板类）红黑树c++实现
10-02
红黑树的c++实现，代码注释详尽，另外在POJ上找了一个关于红黑树的题，A了，可以保证是正确的实现。 分多的小伙伴们送点分给我吧····哥另外的资源下载了500+次，但是CSDN设置每个资源分封底为100，导致现在我...
C++红黑树
~
03-26 6506
C++红黑树零、前言一、红黑树的概念及性质二、红黑树结点的定义三、红黑树的插入操作1、变色处理2、单旋+变色3、双旋+变色4、插入实现四、红黑树的验证五、红黑树的删除六、红黑树与**AVL**树的比较 零、前言 本章继AVL树后继续讲解学习C++中另一个二叉搜索树–红黑树 一、红黑树的概念及性质 概念： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长
C++之红黑树
qq_74732628的博客
04-28 797
文章讲解了红黑树的原理和操作
C++ 红黑树 详细讲解
foodsx的博客
06-07 1041
C++ 红黑树 详细讲解
【C++进阶06】红黑树图文详解及C++模拟实现红黑树
2302_76421042的博客
01-12 3476
红黑树详解、模拟实现
C++实现红黑树
hdsHDS6的博客
06-28 1605
C++实现红黑树，插入和删除思路
C++ 红黑树
weixin_53946312的博客
01-28 1494
红黑树
红黑树（C++实现）
热门推荐
2021dragon的博客
12-06 1万+
红黑树（C++实现）
【C++】红黑树
qq_62939852的博客
05-13 867
使用枚举来记录红色与黑色，用_col表示当前节点颜色但是在构造函数中为什么默认是红色呢？为什么不能是黑色呢？
C++:红黑树
zhang_si_hang的博客
08-21 1610
1.红黑树的概念红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。（最长的路径不超过最短路径的2倍，近似平衡）2.红黑树的性质1.每个结点不是红色就是黑色2.根节点是黑色的3. 如果一个节点是红色的，则它的两个孩子结点是黑色的(没有连续的红色节点)
红黑树精短C++代码
04-13
红黑树实现前去后继排名的查询，代码经过精心简短，题目测试参考洛谷
C++红黑树实现过程
09-15
在C++中实现红黑树，需要理解并遵循红黑树的五个性质： 1. 每个节点要么是红色，要么是黑色。 2. 根节点是黑色。 3. 所有叶子节点（NIL或空节点）是黑色。 4. 如果一个节点是红色，则它的两个子节点都是黑色。 5. ...
P1145 约瑟夫
zty20120913的博客
08-06 424
n个人站成一圈，从某个人开始数数，每次数到m的人就被杀掉，然后下一个人重新开始数，直到最后只剩一个人。现在有一圈人，k个好人站在一起，k个坏人站在一起。从第一个好人开始数数。你要确定一个最小的m，使得在第一个好人被杀死前，k个坏人先被杀死。
C++初学者指南-5.标准库(第二部分)--数值运算算法
silencestarsky的博客
08-06 940
本文介绍了C++标准库中数值运算的相关算法，重点包括iota、reduce和各种扫描操作（scans），阐述了这些算法的用途、用法及其实现示例，并对并行执行的支持进行了说明。此外，文章还提到了一些遗留操作及其使用场景，为初学者理解C++标准库提供了实用的参考。
day 9 回溯算法
最新发布
m0_73924943的博客
08-08 248
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
day021二叉树最后章节
m0_62956971的博客
08-06 574
思路: 二叉搜索树的中序遍历就是有序升序数组，所以想要将它在转换成二叉树，我想到的方法就是通过递归来做，通过中间节点找到二叉搜索树的根节点，然后根据left和right双指针逐层递归构造左右子树。思路:最开始没有判断当当前节点小于最小值时，当前节点的右侧节点的情况，和当前节点大于最大值时，当前节点的左节点的情况，所以出错了，因此要在代码中判断一下这两种情况。思路: 累加树 由题意可知，在二叉搜索树中的递归顺序是右中左的顺序，创建一个新的函数，进行右中左的遍历，在遍历中要将节点的值记录下来，用来做累加。
CSP - J day7
2301_81608637的博客
08-06 189
答案具有单调性：对于正确答案 ans ，小于 ans 的都一定符合条件，大于 ans 的一定不符合条件，因此可以二分答案。先dfs到叶节点，再逐步递归出来，过程中节点数增加，一旦达到 mid ，ans 加一，同时向上贡献节点数变为零。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Sakura＆NANA

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值