【C++ RB树】

最新推荐文章于 2024-05-21 19:54:20 发布
最新推荐文章于 2024-05-21 19:54:20 发布
阅读量1k 收藏 12
点赞数 22
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l2894/article/details/136748737
版权

文章目录

红黑树

AVL树是一颗绝对平衡的二叉搜索树，要求每个节点的左右高度差的绝对值不超过1，这样保证查询时的高效时间复杂度O( l o g 2 N ) log_2 N) log2​N)，但是要维护其绝对平衡，旋转的次数比较多。因此，如果一颗树的结构经常修改，那么AVL树就不太合适，所以就有了红黑树。

红黑树的概念

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

红黑树的性质

  1. 每个节点不是红色就是黑色
  2. 根节点是黑色的
  3. 不存在连续的红色节点
  4. 任意一条从根到叶子的路径上的黑色节点的数量相同
    根据上面的性质，红黑树就可以确保没有一条路径会比其他路径长出两倍，因为每条路径上的黑色节点的数量相同，所以理论上最短边一定都是黑色节点，最长边一定是一黑一红的不断重复的路径。

红黑树节点的定义

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

插入新节点的颜色一定是红色，因为如果新节点的颜色是黑色，那么每条路径上的黑色节点的数量就不相同了，处理起来就比较麻烦，所以宁愿出现连续的红色节点，也不能让某一条路径上多出一个黑色节点。

红黑树的插入

1.根据二叉搜索树的规则插入新节点

bool Insert(const pair<K, V>& kv)
{
	if (_root == nullptr)
	{
		_root = new Node(kv);
		_root->_col = BLACK;
		return true;
	}
	Node* curr = _root;
	Node* parent = nullptr;
	while (curr)
	{
		if (curr->_kv.first < kv.first)
		{
			parent = curr;
			curr = curr->_right;
		}
		else if (curr->_kv.first > kv.first)
		{
			parent = curr;
			curr = curr->_left;
		}
		else
		{
			return false;
		}
	}
	curr = new Node(kv);
	if (parent->_kv.first < kv.first)
		parent->_right = curr;
	else
		parent->_left = curr;
	curr->_parent = parent;
........

2.测新节点插入后，红黑树的性质是否造到破坏

bool Insert(const pair<K, V>& kv)
{
	if (_root == nullptr)
	{
		_root = new Node(kv);
		_root->_col = BLACK;
		return true;
	}
	Node* curr = _root;
	Node* parent = nullptr;
	while (curr)
	{
		if (curr->_kv.first < kv.first)
		{
			parent = curr;
			curr = curr->_right;
		}
		else if (curr->_kv.first > kv.first)
		{
			parent = curr;
			curr = curr->_left;
		}
		else
		{
			return false;
		}
	}
	curr = new Node(kv);
	if (parent->_kv.first < kv.first)
		parent->_right = curr;
	else
		parent->_left = curr;
	curr->_parent = parent;

	while (parent && parent->_col == RED)
	{
		Node* grandfather = parent->_parent;
		if (parent == grandfather->_left)
		{
			Node* uncle = grandfather->_right;
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;

				curr = grandfather;
				parent = curr->_parent;
			}
			else
			{
				if (curr == parent->_left)
				{
					//      g
					//   p     u
					//c
					RotatoR(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					//      g
					//   p     u
					//    c
					RotatoL(parent);
					RotatoR(grandfather);
					curr->_col = BLACK;
					grandfather->_col = RED;
				}
				break;
			}
		}
		else
		{
			Node* uncle = grandfather->_left;
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;

				curr = grandfather;
				parent = curr->_parent;
			}
			else
			{
				if (curr == parent->_right)
				{
					//      g   
					//   u     p
					//           c
					RotatoL(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					//      g   
					//   u     p
					//        c
					RotatoR(parent);
					RotatoL(grandfather);
					curr->_col = BLACK;
					grandfather->_col = RED;
				}
				break;
			}
		}
		
	}
	_root->_col = BLACK;
	return true;
}
void RotatoL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	parent->_right = subRL;
	if (subRL)
		subRL->_parent = parent;
	subR->_left = parent;
	Node* ppnode = parent->_parent;
	parent->_parent = subR;
	if (parent == _root)
	{
		_root = subR;
		subR->_parent = nullptr;
	}
	else
	{
		if (ppnode->_left == parent)
			ppnode->_left = subR;
		else
			ppnode->_right = subR;
		subR->_parent = ppnode;
	}
}
void RotatoR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	parent->_left = subLR;
	if (subLR)
		subLR->_parent = parent;
	subL->_right = parent;
	Node* ppnode = parent->_parent;
	parent->_parent = subL;
	if (parent == _root)
	{
		_root = subL;
		subL->_parent = nullptr;
	}
	else
	{
		if (ppnode->_left == parent)
			ppnode->_left = subL;
		else
			ppnode->_right = subL;
		subL->_parent = ppnode;
	}
}

代码实现

#pragma once
#include <utility>

namespace lw
{
	enum Color
	{
		RED,
		BLACK
	};
	template<class K, class V>
	struct RBTreeNode
	{
		RBTreeNode<K, V>* _left;
		RBTreeNode<K, V>* _right;
		RBTreeNode<K, V>* _parent;
		Color _col;
		pair<K, V> _kv;
		RBTreeNode(const pair<K, V>& kv)
			:_left(nullptr)
			,_right(nullptr)
			,_parent(nullptr)
			,_col(RED)
			,_kv(kv)
		{}
	};
	template<class K, class V>
	class RBTree
	{
		typedef RBTreeNode<K, V> Node;
	public:
		bool Insert(const pair<K, V>& kv)
		{
			if (_root == nullptr)
			{
				_root = new Node(kv);
				_root->_col = BLACK;
				return true;
			}
			Node* curr = _root;
			Node* parent = nullptr;
			while (curr)
			{
				if (curr->_kv.first < kv.first)
				{
					parent = curr;
					curr = curr->_right;
				}
				else if (curr->_kv.first > kv.first)
				{
					parent = curr;
					curr = curr->_left;
				}
				else
				{
					return false;
				}
			}
			curr = new Node(kv);
			if (parent->_kv.first < kv.first)
				parent->_right = curr;
			else
				parent->_left = curr;
			curr->_parent = parent;

			while (parent && parent->_col == RED)
			{
				Node* grandfather = parent->_parent;
				if (parent == grandfather->_left)
				{
					Node* uncle = grandfather->_right;
					if (uncle && uncle->_col == RED)
					{
						parent->_col = uncle->_col = BLACK;
						grandfather->_col = RED;

						curr = grandfather;
						parent = curr->_parent;
					}
					else
					{
						if (curr == parent->_left)
						{
							//      g
							//   p     u
							//c
							RotatoR(grandfather);
							parent->_col = BLACK;
							grandfather->_col = RED;
						}
						else
						{
							//      g
							//   p     u
							//    c
							RotatoL(parent);
							RotatoR(grandfather);
							curr->_col = BLACK;
							grandfather->_col = RED;
						}
						break;
					}
				}
				else
				{
					Node* uncle = grandfather->_left;
					if (uncle && uncle->_col == RED)
					{
						parent->_col = uncle->_col = BLACK;
						grandfather->_col = RED;

						curr = grandfather;
						parent = curr->_parent;
					}
					else
					{
						if (curr == parent->_right)
						{
							//      g   
							//   u     p
							//           c
							RotatoL(grandfather);
							parent->_col = BLACK;
							grandfather->_col = RED;
						}
						else
						{
							//      g   
							//   u     p
							//        c
							RotatoR(parent);
							RotatoL(grandfather);
							curr->_col = BLACK;
							grandfather->_col = RED;
						}
						break;
					}
				}
				
			}
			_root->_col = BLACK;
			return true;
		}
		void RotatoL(Node* parent)
		{
			Node* subR = parent->_right;
			Node* subRL = subR->_left;
			parent->_right = subRL;
			if (subRL)
				subRL->_parent = parent;
			subR->_left = parent;
			Node* ppnode = parent->_parent;
			parent->_parent = subR;
			if (parent == _root)
			{
				_root = subR;
				subR->_parent = nullptr;
			}
			else
			{
				if (ppnode->_left == parent)
					ppnode->_left = subR;
				else
					ppnode->_right = subR;
				subR->_parent = ppnode;
			}
		}
		void RotatoR(Node* parent)
		{
			Node* subL = parent->_left;
			Node* subLR = subL->_right;
			parent->_left = subLR;
			if (subLR)
				subLR->_parent = parent;
			subL->_right = parent;
			Node* ppnode = parent->_parent;
			parent->_parent = subL;
			if (parent == _root)
			{
				_root = subL;
				subL->_parent = nullptr;
			}
			else
			{
				if (ppnode->_left == parent)
					ppnode->_left = subL;
				else
					ppnode->_right = subL;
				subL->_parent = ppnode;
			}
		}
		void InOrder()
		{
			_InOrder(_root);
		}
		bool IsBalance()
		{
			if (_root && _root->_col == RED)
				return false;
			Node* left = _root;
			int count = 0;
			while (left)
			{
				if (left->_col == BLACK)
					count++;
				left = left->_left;
			}
			return check(_root, 0, count);
		}
	private:
		bool check(Node* root, int count, int refBlackNumber)
		{
			if (root == nullptr)
			{
				if (count == refBlackNumber)
					return true;
				else
					return false;
			}
			if (root->_col == RED && root->_parent->_col == RED)
				return false;
			if (root->_col == BLACK)
				count++;
			return check(root->_left, count, refBlackNumber)
				&& check(root->_right, count, refBlackNumber);
		}
		void _InOrder(Node* root)
		{
			if (root == nullptr)
				return;
			_InOrder(root->_left);
			cout << root->_kv.first << " : " << root->_kv.second << endl;
			_InOrder(root->_right);
		}
		Node* _root = nullptr;
	};
}

总结

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O( l o g 2 N log_2 N log2​N)，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。

LRBORRR
关注
  • 22
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
红黑树算法C++实现
07-07
该程序详细实现了红黑树算法,带有注释,能正确运行出结果
树木
02-16
树木 这是莫斯科物理技术学院仅出于教育目的的项目。 描述 该项目的目标是实现两个标准数据结构：AVL树和Red-Black树，然后测量插入，查找和删除元素的时间。 最后，构建图形并确保渐近线是对数的。 建筑 要构建项目，只需输入项目根目录并键入： $ cmake。 $使 然后，您将具有可执行的二进制文件“树”。 用法 执行二进制“树”。 然后，您将在文件“ out / avl.tsv”，“ / out / rb.tsv”中获得计时统计信息。 要在图形中显示它，请使用python脚本“ graph.py”。 它将以PNG格式将图形保存在目录“ out /”中。 您也可以通过以下方式与树木互动玩耍： $ ./tree --game avl | rb
rbtrees:红黑树的旧 C++ 实现
07-14
树 红黑树的旧 C++ 实现 线程安全红黑树的 C++ 实现，不使用 STL，完全没有外部依赖。 该实现是通用且高效的。 插入 100 万个 int32_t 键节点需要 521 毫秒，而从 100 万个节点树中检索需要 2 毫秒！！ 编译，签出并运行make 。 注意您必须安装 gtest 才能运行测试套件
RB_Tree.rar_数据结构_Visual_C++_
08-12
红黑树的算法模拟。红黑树的生成，结点的插入、删除和调整。通过类的方式管理。
红黑树(RB_Tree) 模版
12-07
这是本人写的一个红黑树的模版，只需要改一下接口就可以用了。基本操作查找，删除，修改都是O(logn).
C++ rb_tree红黑树
南宫封清的博客
07-25 740
在 STL 编程中，容器是我们经常会用到的一种数据结构，容器分为序列式容器和关联式容器。 两者的本质区别在于：序列式容器是通过元素在容器中的位置顺序存储和访问元素，而关联容器则是通过键 (key) 存储和读取元素。 本篇着重剖析关联式容器相关背后的知识点，来一张思维导图 容器分类 前面提到了，根据元素存储方式的不同，容器可分为序列式和关联式，那具体的又有哪些分类呢，这里我画了一张图来看一下。 关联式容器比序列式容器更好理解，从底层实现来分的话，可以分为 RB_tree 还是 hash_table，所有暴
创建RB树c++
weixin_45964488的博客
12-14 782
样例输入1： 13 1 45 34 98 9 4 35 23 36 37 90 85 80 3 85 27 9 样例输出1： 34(B) 4(B) 1(B) 9(B) 23® 45(B) 36(B) 35® 37® 90® 85(B) 80® 98(B) 1 98 34(B) 4(B) 1(B) 23(B) 45(B) 36(B) 35® 37® 90® 80(B) 98(B) 样例输入2： 3 18 2 7 0 样例输出2： 7(B) 2® 18® 2 18 7(B) 2® 18® 注意：遍历输出..
C++实现红黑树
hdsHDS6的博客
06-28 1481
C++实现红黑树，插入和删除思路
红黑树c++实现
Nomuo的博客
09-01 132
红黑树c++实现 红黑树算法详解 红黑树算法详解 c++实现 c++实现参考 （一）使用示例： #include <iostream> using namespace rb_tree; using namespace std; int main() { red_black_tree<int, int> tree{}; tree.insert(1, 100); tree.insert(45324, -1); tree.insert(-4324, 47845); tree.
C++之红黑树
Janonez的博客
07-20 65
C++红黑树
C++:RB-tree
qq_45035125的博客
07-02 226
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 红黑树的性质 每个结点不是红色就是黑色 根节点是黑色的 如果一个节点是红色的，则它的两个孩子结点是黑色的 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点 每个叶子结点都是黑色的(此处的叶子结点指的是空结点) 红黑树的插入操作 按照二叉搜索的树规则插入新节
C++【红黑树】
热门推荐
北 海的博客
06-22 1万+
红黑树是平衡二叉搜索树中的一种，红黑树性能优异，广泛用于实践中，比如Linux内核中的CFS调度器就用到了红黑树，由此可见红黑树的重要性
C++红黑树
GreedySnaker的博客
02-17 230
一 红黑树概述 历史上 AVL 树流行的另一变种是红黑树（red-black tree）。对红黑树的操作能保证在最坏情况下动态几何操作的时间为 O(logN) 。之前介绍过AVL 树，该树都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。但 RB-Tree 出来之后，便很少有应用场合用到 AVL 。(AVL，平衡二叉树，不了解，可以先行了解后，再了解红黑树事半功倍) 红黑树是二叉查找树，但在每个节点上增加了一位存储位表示该节点的颜色，具体可以是 RED 或 BLACK。通过
【C++】红黑树
Aron的博客
05-20 527
红黑树是平衡二叉搜索树中的一种，红黑树性能优异，广泛用于实践中，比如Linux内核中的CFS调度器就用到了红黑树，由此可见红黑树的重要性。
C语言 变量的存储类型
最新发布
weixin_45966674的博客
05-21 476
今天 我们来说变量的存储类型变量的存储类型是指系统为变量分配存储区域的方式。决定着变量存储空间在哪里分配，和变量的生存期、作用域存在着一定联系。
C语言——函数指针与指针函数
qq_67319052的博客
05-19 639
函数指针与指针函数有什么区别？
C/C++免杀--原生态(GG)
金灰的博客
05-20 388
看个热闹吧... metasploit payload运行原理浅析(sockedi调用约定是什么) lib/msf/core/payload/windows/reverse_tcp.rb: metasploit-framework/lib/msf/core/payload/windows/reverse_tcp.rb at master · rapid7/metasploit-framework · GitHub 原生态: MSF: #include <Windows
【C++】初始化列表
qq_46049113的博客
05-19 159
当创建一个类的实例时，类的构造函数会被调用来初始化该实例。构造函数可以通过其体（即大括号内的代码部分）或通过初始化列表来初始化成员变量。：使用初始化列表可以直接初始化成员变量，而不是先默认构造成员然后再赋值。：对于常量成员变量和引用成员，初始化列表是必需的，因为这些类型的成员一旦创建后就不能再被赋值。：如果一个类继承自基类，或者它包含其他类的对象作为成员，这些基类和成员对象只能通过初始化列表进行初始化。这种初始化方式确保了代码的效率和成员变量的正确设置，特别是在涉及复杂类型或类的资源管理时尤为重要。
能写个c++红黑树代码吗
03-26
以下是C语言实现的红黑树代码： ```c #include <stdio.h> #include <stdlib.h> typedef struct Node { int key; int color; // 0表示黑色，1表示红色 struct Node *left, *right, *parent; } Node; typedef struct { Node *root; } RBTree; // 创建一个节点 Node *new_node(int key, int color) { Node *p = (Node*) malloc(sizeof(Node)); p->key = key; p->color = color; p->left = p->right = p->parent = NULL; return p; } // 左旋 void left_rotate(RBTree *T, Node *x) { Node *y = x->right; x->right = y->left; if (y->left != NULL) y->left->parent = x; y->parent = x->parent; if (x->parent == NULL) T->root = y; else if (x == x->parent->left) x->parent->left = y; else x->parent->right = y; y->left = x; x->parent = y; } // 右旋 void right_rotate(RBTree *T, Node *x) { Node *y = x->left; x->left = y->right; if (y->right != NULL) y->right->parent = x; y->parent = x->parent; if (x->parent == NULL) T->root = y; else if (x == x->parent->left) x->parent->left = y; else x->parent->right = y; y->right = x; x->parent = y; } // 插入一个节点 void rb_insert(RBTree *T, int key) { Node *z = new_node(key, 1); Node *y = NULL; Node *x = T->root; while (x != NULL) { y = x; if (z->key < x->key) x = x->left; else x = x->right; } z->parent = y; if (y == NULL) T->root = z; else if (z->key < y->key) y->left = z; else y->right = z; while (z != T->root && z->parent->color == 1) { if (z->parent == z->parent->parent->left) { Node *y = z->parent->parent->right; if (y != NULL && y->color == 1) { z->parent->color = 0; y->color = 0; z->parent->parent->color = 1; z = z->parent->parent; } else { if (z == z->parent->right) { z = z->parent; left_rotate(T, z); } z->parent->color = 0; z->parent->parent->color = 1; right_rotate(T, z->parent->parent); } } else { Node *y = z->parent->parent->left; if (y != NULL && y->color == 1) { z->parent->color = 0; y->color = 0; z->parent->parent->color = 1; z = z->parent->parent; } else { if (z == z->parent->left) { z = z->parent; right_rotate(T, z); } z->parent->color = 0; z->parent->parent->color = 1; left_rotate(T, z->parent->parent); } } } T->root->color = 0; } // 中序遍历 void inorder_traversal(Node *x) { if (x != NULL) { inorder_traversal(x->left); printf("%d ", x->key); inorder_traversal(x->right); } } // 主函数 int main() { RBTree T; T.root = NULL; rb_insert(&T, 10); rb_insert(&T, 20); rb_insert(&T, 30); rb_insert(&T, 100); rb_insert(&T, 50); rb_insert(&T, 60); rb_insert(&T, 70); inorder_traversal(T.root); return 0; } ``` 在这个例子中，我们实现了红黑树的插入操作，并对它进行了中序遍历。输出结果为： ``` 10 20 30 50 60 70 100 ``` 这证明了我们成功地将所有节点按照升序排列并插入了红黑树中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

LRBORRR

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

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

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

打赏作者

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

抵扣说明：

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

余额充值