【C++进阶】红黑树

于 2024-08-10 16:04:54 发布
阅读量668 收藏 31
点赞数 39
分类专栏： C++指南 文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79969994/article/details/141069240
版权

目录


在这里插入图片描述

什么是红黑树？

红黑树

红黑树（Red-Black Tree）是一种自平衡的二叉搜索树，用于保持树的平衡，以确保在最坏情况下基本操作（如插入、删除和查找）的时间复杂度仍为 O(log n)。红黑树的每个节点都包含一个额外的颜色位，即红色或黑色。红黑树通过严格的平衡条件来维持树的平衡。

红黑树的性质

  1. 节点是红色或黑色的：每个节点都有颜色属性，红色或黑色。
  2. 根是黑色的：红黑树的根节点必须是黑色的。
  3. 叶节点（NIL 节点）是黑色的：红黑树中的所有叶节点（这里的叶节点是指为空的 NIL 节点，而不是实际的元素节点）都是黑色的。
  4. 红色节点的子节点必须是黑色的（即红色节点不能有红色子节点，也叫“红黑相间”）：红色节点不能连续连接在一起。
  5. 从任何节点到其每个叶子的所有简单路径都必须包含相同数量的黑色节点：这确保了树的平衡性。

定义红黑树

enum Color
{
	RED,
	BLACK,
};
template<class K, class V>
struct RBTreeNode
{
	pair<K, V> _kv;
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	Color _col;
	RBTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
	{}
};
template<class K,class V> 
class RBTree
{
public:
	typedef RBTreeNode<K, V> Node;
private:
	Node* _root = nullptr;
};

红黑树的操作

insert

红黑树的逻辑是在普通的二叉搜索树上进行实现的，在普通的二叉搜索树中，我们不需要调节平衡，但是在红黑树当中我们需要根据红黑树的性质来调整数的颜色和高度，首先我们来看看第一种情况：
在这里插入图片描述
cur是插入节点，由于红色节点不能连续，所以这里已经破坏了平衡，所以我们应该进行调整颜色，我们不可能插入cur是黑色节点，因为如果插入黑色节点的话代价很大，每条路上都会多出来一个黑色节点，这样很不好维护，所以插入红色节点是代价最小的，插入红色节点之后，破坏了规则，所以p应该变成黑色，由于p这条路多了一个黑色节点，所以u应该也变成黑色节点，由于这棵树有可能是某个子树，这两条路多出来一个黑色节点为了保证黑色节点不多，所以g节点应该也变成红色，这样做完之后继续往上调整，将cur赋值到g节点，继续往上调整颜色。

在这里插入图片描述
这样就算调整完毕了。
第二种情况：当u节点不存在时
在这里插入图片描述
对于这种情况我们先准备调色，首先我们先将p改为黑色节点，然后将g改为红色节点之后，我们会发现，左边这条路多出来一个黑色节点，这样是不行的。
在这里插入图片描述
上面这个是不行的，左边已经多出来了一个黑色节点了，但是右边没有黑色节点，所以这种情况我们应该进行旋转。
对g节点进行右旋：
在这里插入图片描述
进行右旋之后将p改为黑色节点，将g改为红色节点，这样两边都保持平衡了。
在这里插入图片描述
还有一种情况：u存在但是为黑色
在这里插入图片描述

最下面的那个红色节点是插入节点：
这种情况我们先向上调整：
在这里插入图片描述
调整成这样之后，我们就发现，u是黑色节点，不管我们怎么调整，左边都会多出一个黑色节点，所以这里我们应该旋转：
绕着g节点进行旋转之后我们可以发现调整颜色就会平衡：
在这里插入图片描述
还有双旋的情况，双旋的情况，我们只说一种：
在这里插入图片描述
左旋将p和cur的位置交换，然后再对g进行右旋，就可以达到平衡的效果。

左旋接口：

void RotateL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	parent->_right = subRL;
	if (subRL)subRL->_parent = parent;

	Node* parentParent = parent->_parent;
	subR->_left = parent;
	parent->_parent = subR;
	if (parentParent == nullptr)
	{
		_root = subR;
		subR->_parent = nullptr;
	}
	else
	{
		if (parent == parentParent->_left)parentParent->_left = subR;
		else parentParent->_right = subR;
		subR->_parent = parentParent;
	}
}

右旋接口：

void RotateR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;

	parent->_left = subLR;
	if (subLR)subLR->_parent = parent;

	Node* parentParent = parent->_parent;
	subL->_right = parent;
	parent->_parent = subL;
	if (parentParent == nullptr)
	{
		_root = subL;
		subL->_parent = nullptr;
	}
	else
	{
		if (parentParent->_left == parent)parentParent->_left = subL;
		else parentParent->_right = subL;
		subL->_parent = parentParent;
	}
}

insert的代码：

bool Insert(const pair<K, V>& kv)
{
	if (_root == nullptr)
	{
		_root = new Node(kv);
		_root->_col = BLACK;
		return true;
	}
	Node* cur = _root;
	Node* parent = nullptr;
	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;
	else parent->_left = cur;
	cur->_parent = parent;
	//调整颜色或旋转
	//parent不为空并且parent指向的颜色是红色才进行调整
	while (parent && parent->_col == RED)
	{
		Node* grandparent = parent->_parent;
		if (grandparent->_left == parent)
		{
			Node* uncle = grandparent->_right;
			//uncle存在且是红色
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandparent->_col = RED;
				cur = grandparent;
				parent = cur->_parent;
			}
			//uncle不存在或者存在为黑色
			else
			{
				//判断cur是parent的左子树还是右子树：
				//右单旋
				if (cur == parent->_left)
				{
					RotateR(grandparent);
					grandparent->_col = RED;
					parent->_col = BLACK;
				}
				else
				{
					RotateL(parent);
					RotateR(grandparent);
					cur->_col = BLACK;
					grandparent->_col = RED;
				}
				break;
			}
		}
		else
		{
			Node* uncle = grandparent->_left;
			//uncle存在且是红色
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandparent->_col = RED;
				cur = grandparent;
				parent = cur->_parent;
			}
			//uncle不存在或者存在为黑色
			else
			{
				//判断cur是parent的左子树还是右子树：
				//右单旋
				if (cur == parent->_right)
				{
					RotateL(grandparent);
					grandparent->_col = RED;
					parent->_col = BLACK;
				}
				else
				{
					RotateR(parent);
					RotateL(grandparent);
					cur->_col = BLACK;
					grandparent->_col = RED;
				}
				break;
			}
		}
	}
	_root->_col = BLACK;
	return true;
}

inorder

void InOrder()
{
	_InOrder(_root);
}
void _InOrder(Node* root)
{
	if (root == nullptr)return;
	_InOrder(root->_left);
	cout << root->_kv.first << ':' << root->_kv.second << endl;
	_InOrder(root->_right);
}

find

bool Find(const K& k)
{
	Node* cur = _root;
	while (cur)
	{
		if (cur->_kv.first < k) cur = cur->_right;
		else if (cur->_kv.first > k) cur = cur->_left;
		else return true;
	}
	return false;
}

height

int height()
{
	return _height(_root);
}
int _height(Node* root)
{
	if (root == nullptr)return 0;
	int leftheight = _height(root->_left);
	int rightheight = _height(root->_right);
	return max(leftheight, rightheight) + 1;
}

size

int size()
{
	return _size(_root);
}
int _size(Node* root)
{
	if (root == nullptr)return 0;
	int left = _size(root->_left);
	int right = _size(root->_right);
	return left + right + 1;
}

构造函数

//默认构造
RBTree() = default;
//拷贝构造
RBTree(const RBTree<K, V>& t)
{
	_root = Copy(t._root);
}
Node* Copy(Node* root)
{
	if (root == nullptr)return nullptr;
	Node* newnode = new Node(root->_kv);
	newnode->_left = Copy(root->_left);
	newnode->_right = Copy(root->_right);
	return newnode;
}

析构函数

~RBTree()
{
	Destroy(_root);
	_root = nullptr;
}
void Destroy(Node* root)
{
	if (root == nullptr)return;
	Destroy(root->_left);
	Destroy(root->_right);
	delete root;
}

赋值拷贝

RBTree<K, V>& operator=(RBTree<K, V> t)
{
	swap(_root, t._root);
	return *this;
}

判断红黑树

bool IsBalance()
{
	//空树也是搜索树
	if (_root == nullptr) return true;

	//根节点不能为红色
	if (_root->_col == RED) return false;

	//参考值
	int refNum = 0;
	Node* cur = _root;
	while (cur)
	{
		//遇到黑色++
		if (cur->_col == BLACK) refNum++;
		cur = cur->_left;
	}

	return Check(_root, 0, refNum);
}
bool Check(Node* root, int blackNum, const int refNum)
{
	//走到空之后就算出一条路径的数量了
	if (root == nullptr)
	{
		if (blackNum != refNum)
		{
			cout << "存在黑色节点不相等的路径" << endl;
			return false;
		}
		return true;
	}
	//存在连续的红色节点
	if (root->_col == RED && root->_parent->_col == RED)return false;

	if (root->_col == BLACK)blackNum++;
	return Check(root->_left, blackNum, refNum) && Check(root->_right, blackNum, refNum);
}

全部代码

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;
enum Color
{
	RED,
	BLACK,
};
template<class K, class V>
struct RBTreeNode
{
	pair<K, V> _kv;
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	Color _col;
	RBTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
	{}
};
template<class K,class V> 
class RBTree
{
public:
	typedef RBTreeNode<K, V> Node;
	//默认构造
	RBTree() = default;
	//拷贝构造
	RBTree(const RBTree<K, V>& t)
	{
		_root = Copy(t._root);
	}
	//赋值拷贝
	RBTree<K, V>& operator=(RBTree<K, V> t)
	{
		swap(_root, t._root);
		return *this;
	}
	//析构函数
	~RBTree()
	{
		Destroy(_root);
		_root = nullptr;
	}
	//查找
	bool Find(const K& k)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < k) cur = cur->_right;
			else if (cur->_kv.first > k) cur = cur->_left;
			else return true;
		}
		return false;
	}
	//中序遍历
	void InOrder()
	{
		_InOrder(_root);
	}
	//插入
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;
		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;
		else parent->_left = cur;
		cur->_parent = parent;
		//调整颜色或旋转
		//parent不为空并且parent指向的颜色是红色才进行调整
		while (parent && parent->_col == RED)
		{
			Node* grandparent = parent->_parent;
			if (grandparent->_left == parent)
			{
				Node* uncle = grandparent->_right;
				//uncle存在且是红色
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandparent->_col = RED;
					cur = grandparent;
					parent = cur->_parent;
				}
				//uncle不存在或者存在为黑色
				else
				{
					//判断cur是parent的左子树还是右子树：
					//右单旋
					if (cur == parent->_left)
					{
						RotateR(grandparent);
						grandparent->_col = RED;
						parent->_col = BLACK;
					}
					else
					{
						RotateL(parent);
						RotateR(grandparent);
						cur->_col = BLACK;
						grandparent->_col = RED;
					}
					break;
				}
			}
			else
			{
				Node* uncle = grandparent->_left;
				//uncle存在且是红色
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandparent->_col = RED;
					cur = grandparent;
					parent = cur->_parent;
				}
				//uncle不存在或者存在为黑色
				else
				{
					//判断cur是parent的左子树还是右子树：
					//右单旋
					if (cur == parent->_right)
					{
						RotateL(grandparent);
						grandparent->_col = RED;
						parent->_col = BLACK;
					}
					else
					{
						RotateR(parent);
						RotateL(grandparent);
						cur->_col = BLACK;
						grandparent->_col = RED;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}
	//大小
	int size()
	{
		return _size(_root);
	}
	//树的高度
	int height()
	{
		return _height(_root);
	}
private:
	int _height(Node* root)
	{
		if (root == nullptr)return 0;
		int leftheight = _height(root->_left);
		int rightheight = _height(root->_right);
		return max(leftheight, rightheight) + 1;
	}
	int _size(Node* root)
	{
		if (root == nullptr)return 0;
		int left = _size(root->_left);
		int right = _size(root->_right);
		return left + right + 1;
	}
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL)subRL->_parent = parent;

		Node* parentParent = parent->_parent;
		subR->_left = parent;
		parent->_parent = subR;
		if (parentParent == nullptr)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (parent == parentParent->_left)parentParent->_left = subR;
			else parentParent->_right = subR;
			subR->_parent = parentParent;
		}
	}
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)subLR->_parent = parent;

		Node* parentParent = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;
		if (parentParent == nullptr)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (parentParent->_left == parent)parentParent->_left = subL;
			else parentParent->_right = subL;
			subL->_parent = parentParent;
		}
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)return;
		_InOrder(root->_left);
		cout << root->_kv.first << ':' << root->_kv.second << endl;
		_InOrder(root->_right);
	}
	void Destroy(Node* root)
	{
		if (root == nullptr)return;
		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
	}
	Node* Copy(Node* root)
	{
		if (root == nullptr)return nullptr;
		Node* newnode = new Node(root->_kv);
		newnode->_left = Copy(root->_left);
		newnode->_right = Copy(root->_right);
		return newnode;
	}
	Node* _root = nullptr;
};

总结

红黑树作为一种自平衡二叉搜索树，通过严格的颜色和旋转规则，保证了在最坏情况下仍能提供高效的查找、插入和删除操作。其特有的平衡机制使得红黑树在实际应用中被广泛采用，尤其在需要频繁增删节点的数据结构中表现出色。掌握红黑树的原理和操作，不仅有助于理解复杂数据结构的实现，也为开发高效算法奠定了坚实基础。希望通过本篇博客，大家能够对红黑树有更加深入的认识，并在实际编程中灵活应用。

lyyyyrics
关注
  • 39
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 24
    评论
专栏目录
C++进阶STL源码笔记
11-15
这份“C++进阶STL源码笔记”显然是一个深入研究STL的资源，适合那些已经有一定C++编程基础的开发者，通过源码分析来提升对STL的理解和应用能力。以下将详细讲解STL中的关键组件和概念。 1. 容器： STL的核心组成...
C++进阶STL笔记资料.zip
07-22
这份"C++进阶STL笔记资料"将详细讲解STL的各个方面，是深入学习和掌握C++进阶技巧的重要参考资料。通过阅读和实践，开发者不仅能熟悉STL的使用，还能理解其背后的设计思想，从而更好地应对复杂的编程挑战。
C++进阶 —— 红黑树
NapoleonCoder的博客
12-11 1492
红黑树！
【C++进阶06】红黑树图文详解及C++模拟实现红黑树
2302_76421042的博客
01-12 3475
红黑树详解、模拟实现
(C++ 进阶) 红黑树
qq_57594025的博客
07-25 200
②如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的，现在看到其是红色的原因是因为cur的子树在调整的过程中将cur节点的颜色由黑色改成红色。①如果u节点不存在，则cur一定是新插入节点，因为如果cur不是新插入节点，则cur和p一定有一个节点的颜色是黑色，不满足每条路径黑色节点个数相同。p为g的左孩子，cur为p的右孩子，则针对p做左单旋转;（1）cur为红，p为红，g为黑，u不存在/u为黑。cur为红，p为红，g为黑，u不存在/u为黑。则转换为情况二进行处理。...
【C++进阶】红黑树实现
weixin_61654591的博客
06-21 314
由于节点的颜色不是红色就是黑色，所以采用枚举类型来定义结点的颜色。在C++中，enum是一种枚举类型，用于定义一组命名的整型常量。枚举类型可以使代码更加具有可读性。可以使用enum关键字来定义枚举类型，如下所示：RED,GREEN,BLUE在上面的例子中，我们定义了一个名为Color的枚举类型，其中包含三种颜色：RED，GREEN和BLUE，它们的值分别为0，1和2。在枚举类型中，每个枚举值都可以用作整数，并且可以通过枚举名称来访问它们。
C++进阶 红黑树封装map和set
小萌新的博客
01-16 870
C++进阶 红黑树封装map和set
C++进阶：红黑树
qq_71806743的博客
04-28 938
抽象子树结构cde中每条路径中有两个黑色结点。抽象子树cde中每条路径都包含一个黑色结点。抽象子树abcde为空。
C++进阶—【红黑树】
一个努力拼搏的人
02-22 255
这里为什么节点的颜色默认是红色的？因为节点如果默认是黑色，那么只要新增节点就一定会破坏红黑树的第四个条件(每个路径上的黑色节点相同)，而节点默认是红色，则有概率插入到正确的位置，即使出现连续的红色节点，我们也可以通过调整节点的颜色来使红黑树恢复正常。
C++进阶之红黑树详细解析
Infernal_Puppet的博客
07-15 586
一起努力，一起奔赴大厂。
【C++进阶】红黑树的实现
m0_67077469的博客
03-20 366
红黑树的实现
C语言的C++数据结构进阶课程
03-30
二叉树、平衡树（如AVL树和红黑树）和搜索树（如B树）是重要的子领域。 - **图**：图数据结构用于表示对象之间的关系，如网络、社交网络和道路系统。图的遍历算法（如深度优先搜索和广度优先搜索）是关键的学习点...
二叉查找树完整C++代码
12-05
为了克服这个问题，可以使用自平衡的二叉查找树，如AVL树或红黑树。 AVL树是最早的自平衡二叉查找树，它的特点是任何节点的两个子树的高度差不超过1，通过旋转操作（左旋、右旋）来保持平衡。AVL树的插入和删除操作...
c++ 面试题.zip
01-20
深入理解各种数据结构，如链表、队列、栈、树（二叉树、红黑树等）、图等，以及与之相关的操作（如查找、排序、插入和删除），是C++开发者的基础功。这些知识在解决复杂问题和优化算法效率时尤其关键。 五、操作...
【数据结构-前缀哈希】力扣523. 连续的子数组和
sjsjs11的博客
08-05 372
当发现有两个余数相同的key的时候，对他们value作差，如果大于等于二，说明该子段长度大于等于二，这时候就找到了一个好的子数组，返回true，如果到最后都没有找到这样一个好的子数组，返回false。，其中 m 是数组 nums 的长度。解释：[23, 2, 6, 4, 7] 是大小为 5 的子数组，并且和为 42。输入：nums = [23,2,6,4,7], k = 13。输入：nums = [23,2,4,6,7], k = 6。输入：nums = [23,2,6,4,7], k = 6。
常见8种数据结构
qq_43575301的博客
08-08 1035
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
理解栈（Stack）及其在 C++ 中的应用【栈、数据结构】
qq_22841387的博客
08-07 378
栈是一种数据结构，它遵循“后进先出”（LIFO - Last In, First Out）的原则。栈就像是一叠盘子，你只能从最上面拿盘子，也只能在最上面放盘子。栈的这一特性使其在很多场景中非常有用，例如递归、回溯算法和表达式计算等。通过这篇博客，我们详细介绍了栈的基本概念及其在 C++ 中的实现。栈是一种非常有用的数据结构，尤其在处理递归、回溯和表达式计算等问题时。我们还讨论了如何将栈中的字符转换为字符串，以及如何使用栈解决括号匹配问题。
数据结构（学习）2024.8.9（双向链表）
最新发布
何物爱惜雨的博客
08-09 419
双向链表的创建，插入，遍历，删除
评论 24
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值