红黑树的实现及测试

于 2024-08-01 19:40:42 发布
阅读量254 收藏 8
点赞数 17
文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cy18779588218/article/details/140855301
版权

目录

1.红黑树的结构

2.红黑树的节点

3.红黑树的实现

1）插入操作

1.u存在且为红

2.u不存在或存在且为黑（且cur 为 parent 的左）

3.u不存在或存在且为黑（且cur 为 parent 的右）

2）查找操作

3）判断是否为有效的红黑树

4）逻辑测试

完整代码：

1.红黑树的结构

其是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。

性质：

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

2. 根节点是黑色的  

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

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

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

2.红黑树的节点

节点和二叉搜索树几乎一样，只不过多了个表示颜色的存储位

template<class K, class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	pair<K, V> _data;
	color _col;

	RBTreeNode(const pair<K, V>& data)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(RED)
	{}
};

3.红黑树的实现

1）插入操作

对于红黑树来说，最重要的依旧是插入操作，与AVL树不同的是，一个是插入完后调整平衡因子，另一个是插入完后调整节点的颜色，使其保持性质

bool Insert(const pair<K, V>& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return true;
		}

		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (data.first < cur->_data.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (data.first > cur->_data.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(data);
		if (parent->_data.first < data.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		// 颜色调整
        ......
}

关于颜色调整，一共分为三种情况：

但是要从两个大类来分析 -> 即 p 是位于左还是位于右，操作起来是一样的，只不过要分开写

这里我们只从p在左边进行分析，因为两者分析方式一致。

1.u存在且为红

这种是最简单的情况，因为就只需要去变动颜色即可：

p 和 u 变为黑色，g 变为红色

但是要谨记，根节点是一定为黑色的，如果g为根，要将其变为黑色

2.u不存在或存在且为黑（且cur 为 parent 的左）

这时候就不仅仅需要变动颜色，而且还需要进行右旋 -> RotateR(grandfather)

3.u不存在或存在且为黑（且cur 为 parent 的右）

这种情况是三种情况中最难搞的：

需要变动颜色，且需要进行双旋转->即先 RotateL(parent) 然后 RotateR(grandfather)

2）查找操作

与二叉搜索树相同：

    Node* Find(const V& value)
	{
		Node* cur = _root;
		while (cur)
		{
			if (value < cur->_data.first)
			{
				cur = cur->_left;
			}
			else if (value > cur->_data.first)
			{
				cur = cur->_right;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}
3）判断是否为有效的红黑树

可以先记录最左边一条路的黑色节点个数，然后去递归每一条路，拿到每一条路径的上的黑色节点与其进行比较，若不相同，则返回false，递归同时，检查该节点是否与其父节点同时为红色，若为，则也返回false

    bool IsValid()
	{
		Node* cur = _root;
		size_t comp = 0;
		while (cur)
		{
			if (cur->_col == BLACK)
				comp++;
			cur = cur->_left;
		}

		return _IsValid(_root, 0, comp);
	}

	bool _IsValid(Node* root, size_t dist, size_t comp)
	{
		if (root == nullptr)
		{
			if (dist != comp)
			{
				cout << "存在黑色节点不相等的两条路" << endl;
				return false;
			}
			return true;
		}

		if (root->_col == BLACK)
			dist++;

		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "有两个连续的红色节点->数字" << root->_data.first << endl;
			return false;
		}

		return _IsValid(root->_left, dist, comp) && _IsValid(root->_right, dist, comp);
	}

这时，基本逻辑就已经都实现完了，可以进行测试了

4）逻辑测试
void TestRBTree1()
{
	//int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14, 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	RBTree<int, int> t1;
	for (auto e : a)
	{
		if (e == 8)
			int i = 0;

		t1.Insert({ e,e });

		cout << "Insert:" << e << "->" << t1.IsValid() << endl;
	}

	t1.InOrder();
}

经测试，发现插入每个数据后都平衡，因此没问题

不过，还有项更严谨的测试，即产生大量随机数，插入进去测试平衡：

void TestRBTree2()
{
	const int N = 1000000;
	vector<int> v;
	v.reserve(N);
	srand(time(0));

	for (size_t i = 0; i < N; i++)
	{
		v.push_back(rand() + i);
	}

	size_t begin2 = clock();
	RBTree<int, int> t;
	for (auto e : v)
	{
		t.Insert(make_pair(e, e));
	}
	size_t end2 = clock();

	cout << t.IsValid() << endl;
}

最后显示的结果也是平衡，那就大概率没有逻辑上的问题了

完整代码：

#pragma once
#include <iostream>
#include <vector>

enum color
{
	BLACK,
	RED
};

template<class K, class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	pair<K, V> _data;
	color _col;

	RBTreeNode(const pair<K, V>& data)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _data(data)
		, _col(RED)
	{}
};

template<class K, class V>
class RBTree
{
public:
	typedef RBTreeNode<K, V> Node;
public:
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* ppNode = parent->_parent;

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

		subL->_right = parent;
		parent->_parent = subL;

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

			subL->_parent = ppNode;
		}
	}

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


		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		subR->_left = parent;
		parent->_parent = subR;

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

	bool Insert(const pair<K, V>& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return true;
		}

		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (data.first < cur->_data.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (data.first > cur->_data.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(data);
		if (parent->_data.first < data.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

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

				// cur为红，p为红，g为黑，u存在且为红
				if (uncle && uncle->_col == RED)
				{
					//   g
					//  p  u
					// c
					grandfather->_col = RED;
					parent->_col = uncle->_col = BLACK;

					cur = grandfather;
					parent = cur->_parent;
				}
				else if (!uncle || (uncle && uncle->_col == BLACK))	// cur为红，p为红，g为黑，u不存在或存在且为黑
				{
					if (cur == parent->_left)
					{
						//     g             p
						//   p   u   ->    c   g   
						// c                     u
						grandfather->_col = RED;
						parent->_col = BLACK;
						RotateR(grandfather);
					}
					else
					{
						//   g             g                                g
						// p   u   ->    c   u  (变成上述情况去解决) ->   p   u              
						//   c         p                                c      
						grandfather->_col = RED;
						cur->_col = BLACK;
						RotateL(parent);
						RotateR(grandfather);
					}
					break;
				}
			}
			else
			{
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED)
				{
					//   g
					//  u  p
					//       c
					grandfather->_col = RED;
					parent->_col = uncle->_col = BLACK;

					cur = grandfather;
					parent = cur->_parent;
				}
				else if (!uncle || (uncle && uncle->_col == BLACK))
				{
					if (cur == parent->_right)
					{
						//     g             p
						//   u   p   ->    g   c   
						//         c     u        
						grandfather->_col = RED;
						parent->_col = BLACK;
						RotateL(grandfather);
					}
					else
					{
						//   g             g                         
						// u   p   ->    u   p  (变成上述情况去解决)             
						//   c                  c                          
						grandfather->_col = RED;
						cur->_col = BLACK;
						RotateR(parent);
						RotateL(grandfather);
					}
					break;
				}
			}
		}	
		_root->_col = BLACK;
		return true;
	}
	
	Node* Find(const V& value)
	{
		Node* cur = _root;
		while (cur)
		{
			if (value < cur->_data.first)
			{
				cur = cur->_left;
			}
			else if (value > cur->_data.first)
			{
				cur = cur->_right;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}

	// 获取红黑树最左侧节点
	Node* LeftMost()
	{
		Node* cur = _root;
		while (cur->_left)
		{
			cur = cur->_left;
		}
		return cur;
	}

	// 获取红黑树最右侧节点
	Node* RightMost()
	{
		Node* cur = _root;
		while (cur->_right)
		{
			cur = cur->_right;
		}
		return cur;
	}

	// 遍历 打印
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	// 判断是否为有效红黑树
	bool IsValid()
	{
		Node* cur = _root;
		size_t comp = 0;
		while (cur)
		{
			if (cur->_col == BLACK)
				comp++;
			cur = cur->_left;
		}

		return _IsValid(_root, 0, comp);
	}

private:
	bool _IsValid(Node* root, size_t dist, size_t comp)
	{
		if (root == nullptr)
		{
			if (dist != comp)
			{
				cout << "存在黑色节点不相等的两条路" << endl;
				return false;
			}
			return true;
		}

		if (root->_col == BLACK)
			dist++;

		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "有两个连续的红色节点->数字" << root->_data.first << endl;
			return false;
		}

		return _IsValid(root->_left, dist, comp) && _IsValid(root->_right, dist, comp);
	}

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

		_InOrder(root->_left);
		cout << root->_data.first << ":" << root->_data.second << endl;
		_InOrder(root->_right);
	}

private:
	Node* _root = nullptr;
};

void TestRBTree1()
{
	//int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14, 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	RBTree<int, int> t1;
	for (auto e : a)
	{
		if (e == 8)
			int i = 0;

		t1.Insert({ e,e });

		cout << "Insert:" << e << "->" << t1.IsValid() << endl;
	}

	t1.InOrder();
}

void TestRBTree2()
{
	const int N = 1000000;
	vector<int> v;
	v.reserve(N);
	srand(time(0));

	for (size_t i = 0; i < N; i++)
	{
		v.push_back(rand() + i);
		//cout << v.back() << endl;
	}

	size_t begin2 = clock();
	RBTree<int, int> t;
	for (auto e : v)
	{
		t.Insert(make_pair(e, e));
		//cout << "Insert:" << e << "->" << t.IsBalance() << endl;
	}
	size_t end2 = clock();

	cout << t.IsValid() << endl;
}
阿^觅
关注
  • 17
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
红黑树与区间树算法实现
04-08
在实验中，`RedBlackTree.c`和`RedBlackTree.h`文件包含了红黑树的实现，包括插入、删除、旋转、查找等操作。`Tree.dot`文件用于生成红黑树的图形表示，通过graphviz工具可视化。 区间树是一种特殊的树形数据结构，...
linux kernel中的红黑树及红黑树测试代码移植
08-11
提取linux kernel中的红黑树实现，供项目使用。可以在linux下编译运行。可以用来研究红黑树代码，已经在项目中使用。附上运行结果 xw@xw-virtual-machine:~/share/test/rbtree$ ./rbtest KERN_ALERT rbtree testing ...
对红黑树的认识总结
热门推荐
张彦峰的博客
05-12 170万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
红黑树算法实现与测试
FanJiangDaoHai的博客
02-17 863
前言 红黑树是一种特殊的二叉树，他的优点是插入、删除和查找时间复杂度都是log(n),并且只需要中序遍历就能从小到大遍历节点，常用于解决哈希冲突。 算法思路 实现代码（C#） using System; using System.Collections.Generic; namespace SF_红黑树 { //颜色枚举 public enum Color { RED, //红色 BLACK//黑色 } //节点 public
红黑树实现代码+详细注释
ltrbless的博客
05-19 1558
简介 因为网上太多红黑树原理的讲解了，不需要再去讲解原理，所以在这就提供一些将原理不错的博客，然后主要是给红黑树代码的实现，用的c++语言模板实现红黑树，并附带详细注释。（目前只实现了红黑树的插入与查询操作，并可视化打印红黑树）。 红黑树插入操作的流程图：（参考：红黑树总结 - lukazan - 博客园 (cnblogs.com)，该博客用图详细解释了红黑树插入操作的事件，然后我用红色对其事件进行了编号，以便于和代码注释相对应） 红黑树的本质其实就是2-3树，在上面推荐的博客中也有提到。 代码
Java-红黑树的实现
xhmico的博客
04-12 1175
数据结构可视化-红黑树因为红黑树中有变色左旋右旋等变化，不是很容易理解，如果能自己对红黑树进行操作，那么这些概念上的东西相对而言就好接受一点了。红黑树是一种自平衡二叉查找树，和AVL 树类似，都是在进行插入和删除时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。红黑树虽然复杂，但它的最坏情况运行时间仍非常好，并且在实践中效率很高，它可以在O(logn)实践内进行查找、插入和删除操作，其性能要优于AVL 树。（1）其节点要么是红色，要么是黑色（2）根节点是黑色的（3）每个叶子节点都是黑色的。
C++实现红黑树
hdsHDS6的博客
06-28 1593
C++实现红黑树，插入和删除思路
红黑树(C++实现)
清欢Allen的技术博客
04-17 802
我们实现的是KV模型结构的红黑树,由于红黑树需要旋转,我们将红黑树的结点定义为三叉链结构,并且添加一个新成员_col,代表结点的颜色,方便后续的变色平衡.template < class K , class V > struct RBTreeNode //三叉链 {//存储的键值对 Colour _col;
红黑树 图文详解与代码实现
qq_54831038的博客
09-01 1018
红黑树被应用于数据结构map/set的封装的底层，也应用于Linux的数据内核，在进程调度CFS，虚拟内存管理，共享内存slab等场景都有广泛应用。数据结构的角度看，（1）用于存储。无论数据是否平衡都可以在O（logN)的复杂度下完成 搜索、插入、删除操作。（2）用于排序。找到最小值和最大值红黑树黑色和红色 也可看成两种状态，红黑区分的状态中，可以根据实际需求添加业务逻辑。......
红黑树的原理及实现
nandao158的博客
04-03 1609
今天分享平衡二叉树的原理及实现： 红黑树的简介： 1、红黑树（R-B Tree，Red-Black Tree）它一种特殊的二叉查找树，同时具备以下特征： 1)节点非红即黑 2)根节点是黑色 3)所有NUll节点称为叶子节点，且认为颜色为黑 4)所有红色节点的子节点都为黑色 5)从任一节点到其叶子节点的所有路径上都包含相同数目的黑节点 以上五点特征共同保证：从根到叶子的最长的路径不多于最短的可能路径的两倍长。 2、红黑树的插入操作： 红黑树性质1：根节点是黑色 红黑树性质5：从任一节
红黑树的实现原理及应用
wau_hua的博客
12-29 2417
@OTC 什么是红黑树 红黑树(R-B Tree, 全称 Red-Black Tree)是一种特殊的二叉查找树, 其中每个节点都有颜色, 红色或者黑色. 红黑树的特性: 树的节点是黑色或者红色 树的根节点和指向null的叶子节点都是黑色 不能有两个红色节点是连续的 每个节点至为null的子节点的任何路径, 都含有相同数量的黑色节点 示例: 8B ...
红黑树RBTree的模拟实现
拾至名瑰的博客
10-07 807
在上篇文章我们了解了第一种平衡二叉搜索树AVL树，我们知道AVL树是通过平衡因子来控制左右子树高度差，从而将二叉树变成一颗平衡二叉搜索树。但是平衡二叉搜索树因为只要不满足平衡因子的差值就需要旋转，导致旋转的次数太对了，效率可能没有那么好。本篇文章我们将要了解另外一种平衡规则控制的二叉搜索树–红黑树（RBTree）！正文开始//节点的颜色，类型为枚举类型 };在上述红黑树节点的定义中，新节点的_col默认给成红色是有意为之还是红黑色都可以呢？
链表和红黑树测试代码
10-09
3. 测试代码：这部分可能演示了如何使用这些数据结构，如何创建和操作链表和红黑树，以及如何将它们编译为库以便在其他项目中复用。 学习这部分内容有助于深入理解Linux内核的工作原理，特别是涉及到内存管理和文件...
红黑树代码实现及分析
02-25
红黑树是一种自平衡二叉查找树，由IBM的...理解红黑树的概念和原理是关键，但实际编码实现需要对树的结构和性质有深入的理解，同时，对算法的调试和测试也非常重要，以确保在各种情况下都能正确维护红黑树的平衡。
数据结构课程作业-基于C语言实现了红黑树及用户测试程序源码+详细注释+exe执行程序.zip
最新发布
01-16
基于C语言实现了红黑树及用户测试程序源码+详细注释+exe执行程序.zip数据结构课程作业-基于C语言实现了红黑树及用户测试程序源码+详细注释+exe执行程序.zip数据结构课程作业-基于C语言实现了红黑树及用户测试程序...
红黑树的C++实现
01-24
红黑树是数据结构和算法领域中的一个重要概念，广泛应用于各种系统和库，如C++ STL中的`std::map`和`std::set`就是基于红黑树实现的。理解并能熟练应用红黑树，对于提升编程能力，尤其是处理复杂数据结构和算法问题...
红黑树的插入详解及Javascript实现方法示例
11-28
由于红黑树的复杂性，代码通常需要细心调试和测试，以确保所有性质在插入过程中得到维护。 总的来说，红黑树通过巧妙的颜色分配和旋转策略，确保了插入操作的高效性和平衡性，是数据结构中一种重要的工具，常用于...
将linux kernel中的红黑树及红黑树测试代码，修改到windows上，并在vs2022上纯c环境编译通过
08-12
对于rbtree这个文件，它可能是包含红黑树实现的源代码文件，可能包含了红黑树的节点定义、颜色定义、旋转操作、插入和删除算法等。在VS2022中打开这个文件，根据Windows平台的需求进行修改，确保所有的函数调用、...
红黑树的插入操作c++实现
12-03
实验进行的是对红黑树进行插入操作的实现，主要方法按照《算法导论》中红黑树算法的描述及伪代码进行编码，采用的是c++。代码已经经过测试可用
Java红黑树代码实现
09-08
Java红黑树是一种自平衡二叉搜索树，它是在二叉查找树的基础上添加了一些限制，以保证树的平衡。红黑树的着色性质，即每个节点要么是红色的，要么是黑色的，并且有以下几条性质： 1. 每个节点要么是红色的，要么是黑色的。 2. 根节点是黑色的。 3. 每个叶子节点都是黑色的。 4. 如果一个节点是红色的，那么它的子节点一定是黑色的。 5. 对于任意一个节点，从该节点到其子孙节点的所有路径上包含相同数目的黑色节点。 下面是一个Java红黑树的代码实现： ``` public class RedBlackTree { private static final boolean RED = true; private static final boolean BLACK = false; private class Node { int key; Node left; Node right; boolean color; public Node(int key, boolean color) { this.key = key; this.color = color; } } private Node root; public void put(int key) { root = put(root, key); root.color = BLACK; } private Node put(Node h, int key) { if (h == null) { return new Node(key, RED); } if (key < h.key) { h.left = put(h.left, key); } else if (key > h.key) { h.right = put(h.right, key); } else { h.key = key; } if (isRed(h.right) && !isRed(h.left)) { h = rotateLeft(h); } if (isRed(h.left) && isRed(h.left.left)) { h = rotateRight(h); } if (isRed(h.left) && isRed(h.right)) { flipCol
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值