C++进阶--红黑树

最新推荐文章于 2024-06-15 16:46:40 发布
最新推荐文章于 2024-06-15 16:46:40 发布
阅读量503 收藏 27
点赞数 28
分类专栏： C++进阶 文章标签： c++ 开发语言 红黑树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74068921/article/details/136690014
版权

概念与特性

红黑树，是一种自平衡的二叉搜索树，它具有以下特点：

  1. 每个节点要么是红色，要么是黑色
  2. 根节点是黑色的。
  3. 每个叶子节点（NIL节点，空节点）都是黑色的。
  4. 如果一个节点是红色的，那么它的两个子节点都是黑色的，也就说，不存在两个连续的红色节点。
  5. 对于任意节点，从该节点到其后代叶子节点的所有路径上包含相同数目的黑色节点，即保证了红黑树的黑色节点高度相同。

在这里插入图片描述

红黑树的定义

enum Colour
{
	RED,
	BLACK
};

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

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

在这里插入图片描述

红黑树的插入操作

旋转的见：AVL树链接入口

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

		//确定插入位置
		Node* parent = nullptr;
		Node* cur = _root;
		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节点和p节点的位置关系
		cur = new Node(kv);
		if (parent->_kv.first < kv.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;
				//情况一
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					//向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2
				{
					if (cur == parent->_left)
					{
						//      g
						//    p    u
						//  c
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//      g
						//    p    u
						//      c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;//旋转完的子树的根节点必为黑，这时就不用向上调整处理了

				}
			}
			else
			{
				Node* uncle = grandfather->_left;
				// 情况一：叔叔存在且为红
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2
				{
					if (cur == parent->_right)
					{
						//      g
						//    u    p
						//           c
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//      g
						//    u    p
						//        c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;//旋转完的子树的根节点必为黑，这时就不用向上调整处理了

				}
			}
		}

		_root->_col = BLACK;
		return true;

	}

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

验证

void TestRBTree1()
{

	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	RBTree<int, int> t;
	for (auto e : a)
	{
		t.Insert(make_pair(e, e));
	}

	t.InOrder();
	cout << t.IsBalance() << endl;
}

在这里插入图片描述
在这里插入图片描述

bool Check(Node* cur, int blackNum, int refBlackNum)
	{
		if (cur == nullptr)
		{
			//当节点为空时，表示这条路径结束，这时就要对黑色节点进行判断
			if (refBlackNum != blackNum)
			{
				cout << "与其他路径的黑色节点数不相等" << endl;
				return false;
			}
			return true;
		}

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

		if (cur->_col == BLACK)
		{
			blackNum++;
		}

		return Check(cur->_left,blackNum,refBlackNum) && Check(cur->_right,blackNum,refBlackNum);
	}

	bool IsBalance()
	{
		if (_root && _root->_col == RED)
			return false;

		//统计一条路径的黑色节点数
		int refBlackNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				refBlackNum++;
			}
			cur = cur->_left;
		}

		return Check(_root,0,refBlackNum);
	}

在这里插入图片描述

红黑树的性能测试

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 a : v)
	{
		t.Insert(make_pair(a, a));
	}

	size_t end2 = clock();

	
	cout << "Insert:" << end2 - begin2 << endl;

	cout << t.IsBalance() << endl;
	//测高度，数量
	cout << "height" << t.Height() << endl;
	cout << "Size:" << t.Size() << endl;


	//测查找时间
	size_t begin1 = clock();

	for (size_t i = 0; i < N; i++)
	{
		t.Find((rand() + i));
	}

	size_t end1 = clock();

	cout << "Find:" << end1 - begin1 << endl;


}

在这里插入图片描述

原码

#pragma once
enum Colour
{
	RED,
	BLACK
};

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

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

};

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* parent = nullptr;
		Node* cur = _root;
		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节点和p节点的位置关系
		cur = new Node(kv);
		if (parent->_kv.first < kv.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;
				//情况一
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					//向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2
				{
					if (cur == parent->_left)
					{
						//      g
						//    p    u
						//  c
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//      g
						//    p    u
						//      c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;//旋转完的子树的根节点必为黑，这时就不用向上调整处理了

				}
			}
			else
			{
				Node* uncle = grandfather->_left;
				// 情况一：叔叔存在且为红
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2
				{
					if (cur == parent->_right)
					{
						//      g
						//    u    p
						//           c
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//      g
						//    u    p
						//        c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;//旋转完的子树的根节点必为黑，这时就不用向上调整处理了

				}
			}
		}

		_root->_col = BLACK;
		return true;

	}

	void RotateL(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 RotateR(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(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_kv.first << endl;
		_InOrder(root->_right);
	}

	void InOrder()
	{
		_InOrder(_root);
	}

	bool Check(Node* cur, int blackNum, int refBlackNum)
	{
		if (cur == nullptr)
		{
			//当节点为空时，表示这条路径结束，这时就要对黑色节点进行判断
			if (refBlackNum != blackNum)
			{
				cout << "与其他路径的黑色节点数不相等" << endl;
				return false;
			}
			return true;
		}

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

		if (cur->_col == BLACK)
		{
			blackNum++;
		}

		return Check(cur->_left,blackNum,refBlackNum) && Check(cur->_right,blackNum,refBlackNum);
	}

	bool IsBalance()
	{
		if (_root && _root->_col == RED)
			return false;

		//统计一条路径的黑色节点数
		int refBlackNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				refBlackNum++;
			}
			cur = cur->_left;
		}

		return Check(_root,0,refBlackNum);
	}

	size_t Size()
	{
		return _Size(_root);
	}

	size_t _Size(Node* root)
	{
		if (root == NULL)
			return 0;

		return _Size(root->_left)
			+ _Size(root->_right) + 1;
	}

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

		return NULL;
	}

	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;

		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);

		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

	int Height()
	{
		return _Height(_root);
	}

private:
	Node* _root = nullptr;
};

void TestRBTree1()
{

	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	RBTree<int, int> t;
	for (auto e : a)
	{
		t.Insert(make_pair(e, e));
	}

	t.InOrder();
	cout << t.IsBalance() << endl;
}

//性能测试
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 a : v)
	{
		t.Insert(make_pair(a, a));
	}

	size_t end2 = clock();

	
	cout << "Insert:" << end2 - begin2 << endl;

	cout << t.IsBalance() << endl;
	//测高度，数量
	cout << "height" << t.Height() << endl;
	cout << "Size:" << t.Size() << endl;


	//测查找时间
	size_t begin1 = clock();

	for (size_t i = 0; i < N; i++)
	{
		t.Find((rand() + i));
	}

	size_t end1 = clock();

	cout << "Find:" << end1 - begin1 << endl;


}
诡异森林。
关注
  • 28
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 25
    评论
专栏目录
c++进阶前置-环境准备+shell编程
07-08
C++进阶前置-环境准备+shell编程 C++是高级语言编程的必备知识，环境准备和shell编程是 Linux 后端服务器方面的基础知识。 C++编程语言概述 C++是由Bjarne Stroustrup于1983年开发的高级语言，具有面向对象、...
红黑树-基于C++实现的红黑树数据结构.zip
03-21
红黑树 红黑树_基于C++实现的红黑树数据结构
C++进阶--红黑树模拟实现STL中的map和set
sushang的博客
01-15 1191
因此，上层容器map需要向底层红黑树提供一个仿函数，用于获取T当中的键值Key，这样一来，当底层红黑树当中需要比较两个结点的键值时，就可以通过这个仿函数来获取T当中的键值了。但是对于底层红黑树来说，它并不知道上层容器是map还是set，因此需要进行两个结点键值的比较时，底层红黑树都会通过传入的仿函数来获取键值Key，进而进行两个结点键值的比较。这样一来，当底层红黑树需要进行两个结点之间的键值的比较时，都会通过传入的仿函数来获取相应结点的键值，然后再进行比较。
C++进阶--AVL树
m0_74068921的博客
03-06 989
int _bf;
c++进阶--二叉搜索树模拟实现
jolly0514的博客
08-08 290
一、二叉搜索树1.二叉搜索树概念二叉搜索树又称为二叉排序树，它或者是一颗空树，或者具有以下性质的二叉树：若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值左、右子树都是二叉搜索树2.二叉搜索树操作1.二叉搜索树的查找从根节点开始比较，查找，如果比根节点值大，往右走查找，比根节点值小，往左走查找最多查找高度次，走到空节点还没找到，则说明这个值在树中不存在。2.二叉搜索树的插入若为空树，则直接新增节点，赋值给root指针。
C++进阶--unordered_set、unordered_map的介绍和使用
sushang的博客
01-15 2838
1.unordered_set是不按特定顺序存储键值的关联式容器，其允许通过键值快速的索引到对应的元素。2.在unordered_set中，元素的值同时也是唯一的标识它的key。3.在内部，unordered_set中的元素没有按照任何特定的顺序排序，为了能在常数范围内找到指定的key，unordered_set将相同哈希值的键值放在相同的桶中。4.unordered_set容器通过key访问单个元素要比set快，但它通常在遍历元素子集的范围迭代方面效率较低。5.它的迭代器至少是前向迭代器。
【C++进阶06】红黑树图文详解及C++模拟实现红黑树
2302_76421042的博客
01-12 3133
红黑树详解、模拟实现
C++进阶--1
weixin_45699456的博客
08-23 108
向量vector) 后端可高效增加元素的顺序表。数组arrayC++11，定长的顺序表，C 风格数组的简单包装。双端队列deque) 双端都可高效增加元素的顺序表。列表list) 可以沿双向遍历的链表。单向列表) 只能沿一个方向遍历的链表。
C++进阶---Map和Set使用及模拟实现
qq_41420788的博客
02-21 471
Map和Set使用及模拟实现1）引入pairmake_pair2）树形结构的关联式容器（STL分为树形结构和哈希结构）①set注意迭代器构造 容量(略)修改操作②multiset注意迭代器 构造 容量 修改(略)操作③map注意③multimap 1）引入 关联式容器与序列式容器： 关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对，在数据检索时比序列式容器效率更高 键值对： 用来表示具有一 一对应关系的一种结构，该结构中一般只包含两个成
C++进阶-- map和set
m0_74068921的博客
03-02 716
set是C++标准库中的一种关联式容器，它用于存储一组有序的、唯一的元素。set中的元素按照键值进行自动排序，并且不允许存在重复的元素。set在底层是由二叉搜索树（红黑树）实现的。set中只放value，但在底层实际存放的是由<vlaue,value> 构成的键值对。log_2 nmap是C++标准库中的一种关联式容器，它用于存储一组键值对。每个元素都由一个唯一的键和对应的值组成。map中的元素按照键进行自动排序，并且不允许存在重复键。在map内部，
C++进阶--哈希表模拟实现unordered_set和unordered_map
sushang的博客
01-21 1032
哈希表里面具体存的是什么类型的元素，是由模板参数T来决定如果是unordered_set，传给T就是Key如果是unordered_map，传给T的就是pair哈希表结点结构T _data;{}迭代器的结构：注意：哈希表迭代器封装的是结点指针和哈希表指针，因为要在哈希表中找下一个桶，所以要用到哈希表指针在构造正向迭代器时，我们不仅需要对应哈希结点的指针，还需要该哈希结点所在哈希表的地址。
C++R-Tree代码
11-26
C++写的R-Tree代码，供大家参考
C++基础-进阶.rar
11-06
培训班C++详细教程，包含基础教程-进阶教程-提高教程-项目历练
嵌入式C语言培训-编程进阶-2字符串
12-19
嵌入式C语言培训-编程进阶-2字符串，需要的朋友可以下载一下。
6.15 c语言
jwh199694的博客
06-15 115
char类型的指针变量称为字符指针变量，字符指针变量与字符有着密切关系，他也被用来处理字符串。当一个字符指针指向一个字符串常量时，不能修改指针指向的对象的值。3、字符串常量//char *p = “welcome”;字符串常量不能被修改，因为存储在静态存储区//会发生段错误。初始化字符指针是把内存中字符串的首地址赋予指针。c语言通过使用字符数组来处理字符串。2、static局部变量。
c++ 6.11
Johan1111的博客
06-11 268
(5)另外， RMB 类还包含一个静态整型成员变量 count，用于记录当前已创建的 RMB 对象的数量。每当创建一个新的 RMB 对象时，count 应该自增 1；(1)重载算术运算符 + 和 -，使得可以对两个 RMB 对象进行加法和减法运算，并返回一个新的 RMB 对象作为结果。(2)重载关系运算符 >，判断一个 RMB 对象是否大于另一个 RMB 对象，并返回 true 或 false。(3)重载前置减减运算符 --，使得每次调用时 RMB 对象的 yuan、jiao 和 fen 分别减 1。
【C++提高编程-05】----C++之Deque容器实战
最新发布
一伦明悦的博客
06-15 800
Deque（双端队列）是C++ STL中的一种序列容器
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1021
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
930. 循环进阶-辗转相减c++
10-06
辗转相减算法，也称为辗转减法，是计算两个正整数最大公约数的一种方法。它的基本原理是，用较大的数减去较小的数，然后用结果再减去较小的数，直到所得差为0或者两个数相等为止。最后得到的非零余数就是最大公约数。 辗转相减算法的步骤如下： 1. 首先，判断两个数 a 和 b 的大小，将较大的数赋值给 x，较小的数赋值给 y。 2. 计算 x 和 y 的差值，即 z = x - y。 3. 判断 z 的大小： - 如果 z = 0，则 y 就是最大公约数。 - 如果 z ≠ 0，则将 y 赋值给 x，z 赋值给 y，然后进入步骤 2。 辗转相减算法的时间复杂度较高，特别是当两个数之间差值较大时。为了优化算法的性能，可以使用更高级的算法，如辗转相减结合移位运算或二进制算法。 辗转相减算法的优点是简单易理解，可以求解任意两个正整数的最大公约数。但是由于算法需要多次减法运算，所以性能较低，对于大数计算不太适用。 总而言之，辗转相减算法是一种基于减法运算的寻找最大公约数的方法。虽然它的性能不够高效，但在一些简单的计算场景中仍然具有一定的应用价值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

诡异森林。

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

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

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

打赏作者

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

抵扣说明：

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

余额充值