[C++] 红黑树（Red-Black Tree）详解

于 2024-08-11 10:07:49 发布
阅读量416 收藏 9
点赞数 6
分类专栏： c++ 文章标签： 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75921742/article/details/141101861
版权

目录

1. 红黑树的基本概念

2. 红黑树的性质

3. 红黑树的操作

3.1 插入操作

3.2 删除操作

4. C++ 中的红黑树实现

总结

红黑树是一种自平衡的二叉搜索树，广泛用于计算机科学中以实现高效的数据存储和检索。它在许多标准库中得到应用，例如 C++ 的 std::map 和 std::set 都基于红黑树实现。本文将介绍红黑树的基本概念、性质、操作以及如何在 C++ 中实现红黑树。

1. 红黑树的基本概念

红黑树是一种具有以下性质的二叉搜索树：

  1. 节点颜色：每个节点都是红色或黑色。
  2. 根节点：根节点是黑色。
  3. 叶子节点：所有的叶子节点（NULL 指针）都是黑色。
  4. 红色节点：红色节点的子节点都是黑色（即红色节点不能有两个连续的红色节点）。
  5. 路径一致性：从任何节点到其所有子孙叶子节点的路径包含相同数量的黑色节点。

这些性质确保了树的平衡性，从而保证了基本操作的对数时间复杂度。

2. 红黑树的性质

这些性质帮助红黑树维持平衡，确保在最坏情况下操作的时间复杂度为 O(log⁡n)O(\log n)O(logn)：

  • 根节点为黑色。
  • 每个叶子节点（NIL节点）为黑色。
  • 红色节点的两个子节点都是黑色。
  • 从任何节点到其每个叶子节点的路径上，必须包含相同数量的黑色节点。

3. 红黑树的操作

3.1 插入操作

插入操作分为两个步骤：

  1. 标准二叉搜索树插入：将新节点插入到红黑树中，按照二叉搜索树的规则。
  2. 修复红黑树：通过调整树的结构和节点颜色，恢复红黑树的性质。这包括重新着色和旋转操作。
3.2 删除操作

删除操作涉及：

  1. 标准二叉搜索树删除：删除节点，并保持二叉搜索树的结构。
  2. 修复红黑树：通过复杂的重新着色和旋转操作，恢复红黑树的性质。

4. C++ 中的红黑树实现

在 C++ 标准库中，红黑树的实现被封装在 std::map 和 std::set 中。这里我们提供一个简单的红黑树实现示例：

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;


//枚举  ：黑  白
enum Color
{
	RED,
	BLACK
};

//创建树节点，存储三叉链：父亲，左节点，右节点
template <class T>
struct RBTreeNode
{
	T _data;  //数据 泛型化
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	Color _color;   //存储颜色
	RBTreeNode(const T& data)
		:_data(data)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
	{}
};

//迭代器
template <class T ,class Ref, class Ptr>
struct RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef RBTreeIterator<T, Ref, Ptr> Self;

	Node* _node;//传入的节点指针
	Node* _root;
	//初始化
	RBTreeIterator(Node* node, Node* root)
		:_node(node)
		,_root(root)
	{}

	Self& operator++()
	{
		if (_node->_right)
		{
			//右不为空，右子树的最左节点
			Node* leftMost = _node->_right;
			while (leftMost->_left)
			{
				leftMost = leftMost->_left;
			}
			_node = leftMost;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_right)
			{
				cur = parent;
				parent = cur->_parent;
			}
			_node = parent;

		}
		
		return *this;
	}

	Self& operator--()
	{
		if (_node == nullptr)
		{
			Node* rightMost = _root;
			while (rightMost->_right)
			{
				rightMost = rightMost->_right;
			}
			_node = rightMost;
		}
		else if (_node->_left)
		{
			//左不为空，左子树的最右节点
			Node* rightMost = _node->_left;
			while (rightMost->_right)
			{
				rightMost = rightMost->_right;
			}
			_node = rightMost;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_left)
			{
				cur = parent;
				parent = cur->_parent;
			}
			_node = parent;

		}

		return *this;
	}

	Ref operator*()
	{
		return _node->_data;
	}

	Ptr operator->()
	{
		return &_node->_data;
	}

	bool operator!= (const Self& s)
	{
		return _node != s._node;
	}

	bool operator== (const Self& s)
	{
		return _node == s._node;
	}

};

template <class K,class T,class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef RBTreeIterator<T, T&, T*> Iterator;
	typedef RBTreeIterator<T, const T&, const T*> ConstIterator;

	RBTree() = default;
	RBTree(const RBTree& t)
	{
		_root = Copy(t._root);
	}

	Iterator Begin()
	{
		Node* lastleft = _root;
		while (lastleft && lastleft->_left)
		{
			lastleft = lastleft->_left;
		}
		return Iterator(lastleft,_root);
	}

	Iterator End()
	{
		return Iterator(nullptr,_root);
	}

	ConstIterator Begin() const
	{
		Node* leftMost = _root;
		while (leftMost && leftMost->_left)
		{
			leftMost = leftMost->_left;
		}

		return ConstIterator(leftMost, _root);
	}

	ConstIterator End() const
	{
		return ConstIterator(nullptr, _root);
	}

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

	~RBTree()
	{
		Destroy(_root);
		_root = nullptr;
	}

	
	pair<Iterator, bool> Insert(const T& data)
	{
		//如果红黑树为空，直接插入
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_color = BLACK;
			return make_pair(Iterator(_root, _root), true);
		}
		KeyOfT kot;
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (kot(cur->_data) > kot(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (kot(cur->_data) < kot(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return make_pair(Iterator(cur, _root), false);
			}
			
		}
		cur = new Node(data);
		Node* newnode = cur;
		//新增红色节点
		cur->_color = RED;
		if (kot(parent->_data) > kot(data))
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;
		while (parent && parent->_color == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				//     g
				//   p   u
				// c
				if (uncle&& uncle->_color == RED)
				{
					//u存在且为红，
					// 把父亲和叔叔变黑，爷爷变红，继续向上处理
					parent->_color = uncle->_color = BLACK;
					grandfather->_color = RED;
					
					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					//u存在且为黑，或不存在 旋转+变色
					//     g
					//   p   u
					// c
					if (parent->_left == cur)
					{
						RotateRight(grandfather);
						parent->_color = BLACK;
						grandfather->_color = RED;

					}
					else
					{
						//     g
						//   p   u
						//	   c
						RotateLeft(parent);
						RotateRight(grandfather);

						cur->_color = BLACK;
						grandfather->_color = RED;
					}
					break;
				}
				
			}
			else
			{
				Node* uncle = grandfather->_right;
				if (uncle&& uncle->_color == RED)
				{
					//u存在且为红，
					// 把父亲和叔叔变黑，爷爷变红，继续向上处理
					parent->_color = uncle->_color = BLACK;
					grandfather->_color = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					//u存在且为黑，或不存在 旋转+变色
					//     g
					//   u   p
					//         c
					if (parent->_right == cur)
					{
						RotateLeft(grandfather);
						parent->_color = BLACK;
						grandfather->_color = RED;

					}
					else
					{
						//     g
						//   u   p
						//	   c
						RotateRight(parent);
						RotateLeft(grandfather);

						cur->_color = BLACK;
						grandfather->_color = RED;
					}
					break;
				}
			}
		}
		_root->_color = BLACK;
		return make_pair(Iterator(newnode, _root), true);
	}

	bool IsBalance()
	{
		if (_root == nullptr)
			return true;

		if (_root->_color == RED)
		{
			return false;
		}

		// 参考值
		int refNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_color == BLACK)
			{
				++refNum;
			}

			cur = cur->_left;
		}

		return Check(_root, 0, refNum);
	}

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

private:

	bool Check(Node* root, int blackNum, const int refNum)
	{
		if (root == nullptr)
		{
			//cout << blackNum << endl;
			if (refNum != blackNum)
			{
				cout << "存在黑色节点的数量不相等的路径" << endl;
				return false;
			}

			return true;
		}

		if (root->_color == RED && root->_parent->_color == RED)
		{
			cout << root->_kv.first << "存在连续的红色节点" << endl;
			return false;
		}

		if (root->_color == BLACK)
		{
			blackNum++;
		}

		return Check(root->_left, blackNum, refNum)
			&& Check(root->_right, blackNum, refNum);
	}

	void RotateLeft(Node* parent)
	{
		//_rotateNum++;
		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  RotateRight(Node* parent)
	{
		//_rotateNum++;

		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 (parent == parentParent->_left)
			{
				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;
		}
		Node* newRoot = new Node(root->_key, root->_value);
		newRoot->_left = Copy(root->_left);
		newRoot->_right = Copy(root->_right);

		return newRoot;
	}
private:
	Node* _root = nullptr;
};

总结

红黑树是一种自平衡的二叉搜索树，具有对数时间复杂度的插入、删除和查找操作。它通过特定的节点颜色和旋转操作来保持平衡。C++ 标准库中的 std::map 和 std::set 就是基于红黑树实现的。上述示例展示了红黑树的基本实现，包括节点插入和树的平衡维护。了解红黑树的基本操作和实现细节对优化数据结构和提高程序效率非常重要。

方歧
关注
专栏目录
C/C++ RBTree(红黑树) 算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-22 2107
红黑树的主要目的是确保树的高度平衡，以保证在最坏情况下的插入、删除和查找操作的时间复杂度都能保持在O(log n)。b. 如果删除节点有两个子节点，找到其后继节点(比该节点大的最小节点)，将后继节点的值复制到删除节点，并删除后继节点，最后修复红黑树的性质。因此，在插入新节点时，需要将新节点的颜色设置为红色，并通过修复函数来保持根节点的黑色性质。a. 如果删除节点是叶节点或者只有一个子节点，直接删除并修复红黑树的性质。为了验证实现的正确性，可以对插入的节点进行中序遍历，并确保结果是有序的。
C/C++ 红黑树算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
07-03 564
红黑树是一种自平衡的二叉搜索树，它在每个节点上增加了一个额外的属性——颜色，可以是红色或者黑色。红黑树是一种自平衡的二叉搜索树，它在每个节点上增加了一个额外的属性——颜色，可以是红色或者黑色。红黑树是一种自平衡的二叉搜索树，它在每个节点上增加了一个额外的属性——颜色，可以是红色或者黑色。红黑树是一种自平衡的二叉搜索树，它在每个节点上增加了一个额外的属性——颜色，可以是红色或者黑色。通过保持以上性质，红黑树可以保持树的高度近似平衡。这使得红黑树的查找、插入和删除操作具有较好的平均和最坏情况性能。
c++——红黑树
蜗@牛的博客
07-10 292
一、红黑树的概念 红黑树是一种二叉搜索树，但是每个结点都有表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出2倍，因而是接近平衡的二叉搜索树。 二、红黑树的特性 1、每个节点要么是黑色，要么是红色。 2、根节点是黑色。 3、每个叶子节点（NIL）是黑色。 4、每个红色结点的两个子结点一定都是黑色。 5、任意一结点到每个叶子结点的路径都包含数量相同的黑结点。 三、红黑树的实现 1、红黑树的插入 （1）根节点为空，则直接插入
【C++】——红黑树（手撕红黑树，彻底弄懂红黑树）
最新发布
m0_74092462的博客
07-26 1406
我们之前都学过ALV树，AVL树的本质就是一颗平衡二叉树，它的作用就是查找，插入和删除节点，最坏的时间复杂度都是O(logn)的，同时维护的高度差都是小于等于1的，但是也就是因为这个原因才被红黑树所替代红黑树是一种自平衡的二叉查找树，是一种高效的查找树。它是由 Rudolf Bayer 于1978年发明，在当时被称为平衡二叉 B 树(symmetric binary B-trees)。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的红黑树。
C++【红黑树】
芊樱烛渊的博客
11-05 1075
AVLTree：要求左右高度差不超过1红黑树：AVLTree过分严格，可能会导致过分的旋转，那能不能不要那么严格呢？需要达到的目的，最长路径不超过最短路径的二倍。也就是说，我们的AVLTree是严格平衡，我们的红黑树是不严格平衡，而是近似平衡结果：相对而言，插入同样的数据，AVL树的旋转更多，红黑树的旋转次数更少假设N是100w，AVL树为logN的高度，也就是大概20左右但是我们的红黑树的话，最短的高度大概是logN也就是20左右，最深的应该为2*logN，为40次左右。
【C++】红黑树
qq_62939852的博客
05-13 1044
使用枚举来记录红色与黑色，用_col表示当前节点颜色但是在构造函数中为什么默认是红色呢？为什么不能是黑色呢？
红黑树(Red Black Tree)超详细解析
qq_65786321的博客
11-09 976
​ 红黑树，是一种二叉搜索树的特化，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而是接近平衡的。​ 红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O(logN)，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。
红黑树详解：数据结构与C++实现
class RedBlackTree { public: // 构造函数，插入操作，查找操作，删除操作... void insert(const Key& key, const T& value); T* find(const Key& key); void erase(const Key& key); private: // 红黑树的...
红黑树原理详解
12-07
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由计算机科学家Rudolf Bayer在1972年提出。它的设计目标是保证在插入、删除和查找操作时保持相对良好的性能，同时保持树的平衡。红黑树的名字来源于它的节点颜色...
C++之红黑树
cls的博客
05-23 2171
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 4.2.2 红黑树的性质 1. 每个结点不是红色就是黑色 2. 根节点是黑色的 3. 如果一个节点是红色的，则它的两个孩子结点是黑色的，但是没有连续的红节点 4. 对于每个结点，从该结点到其所有后代叶结点的简单路径...
C++:红黑树
zhang_si_hang的博客
08-21 1817
1.红黑树的概念红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。（最长的路径不超过最短路径的2倍，近似平衡）2.红黑树的性质1.每个结点不是红色就是黑色2.根节点是黑色的3. 如果一个节点是红色的，则它的两个孩子结点是黑色的(没有连续的红色节点)
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

方歧

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

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

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

打赏作者

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

抵扣说明：

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

余额充值