【C++】：红黑树深度剖析 --- 手撕红黑树！

已于 2024-07-26 23:06:41 修改
阅读量2.4k 收藏 108
点赞数 113
分类专栏： C++从入门到起飞 文章标签： c++ 开发语言
于 2024-07-25 20:22:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77900444/article/details/140680877
版权

目录


点击跳转至上一篇文章： 【C++】：AVL树的深度解析及其实现

点击跳转至文章：【C++】：二叉树进阶 — 搜索二叉树

💡前言

上一篇文章介绍了什么是AVL树和AVL树的实现，AVL树也有它的缺点：就是太过追求绝对平衡，比如在插入时要维护其绝对平衡，旋转次数太多，在删除时甚至有可能要一直旋转到根位置，使之性能低下。

本篇文章介绍的红黑树也是一种平衡树，是通过改变节点颜色以及旋转操作，使之接近平衡。

红黑树比AVL树的用途更加广泛，在一些方面效率甚至要优于AVL树，并且 map/set 的底层封装用的也是红黑树。

一，红黑树的概念

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

在这里插入图片描述

二，红黑树的性质

(1) 每个结点不是红色就是黑色 ；
(2) 根节点是黑色的 ；
(3) 如果一个节点是红色的，则它的两个孩子结点是黑色的（重点）；
(4) 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点（重点） ；
(5) 每个叶子结点都是黑色的(此处的叶子结点指的是空结点，这条性质可有可无，平时不关注)。

三，红黑树节点的定义

红黑树的节点结构与AVL树的大致相同，只是AVL树中有节点的颜色，没有平衡因子。

//枚举颜色
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(BLACK)
	{}
};

四，红黑树的插入操作

首先我们要思考一个问题，插入节点时，到底是插入红色节点还是黑色节点？为什么？

答案：插入红色节点。

因为我们知道红黑树最重要的两条性质是第(3)(4)条，通过维护这两条规则使之成为红黑树，而当新插入一个节点时，必定会破坏两条规则之一。

假设插入节点为黑色节点，则所有路径的黑色节点数量均不相同，如何让它们相同将是一个巨大的难题，而插入红色节点(此时一定是作为孩子节点)，就破坏规则(3)，但是只要根据其父亲和叔叔节点进行适当的变色就可以继续恢复规则(3)。

显而易见，规则(3)(4)就好比"慈父严母"，非要选择得罪其中一人，那当然是"慈父"了。

红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可分为两步：

4.1 第一步

按照二叉搜索的树规则插入新节点：

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

	//新增节点，颜色为红色
	cur->_col = RED;

	//链接时要判断链接在parent的左还是右
	if (parent->_kv.first > kv.first)
		parent->_left = cur;
	else
		parent->_right = cur;

	cur->_parent = parent;

	//检测新节点插入后，红黑树的性质是否造到破坏
	//……
	
}

4.2 第二步

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

因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整；但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连在一起的红色节点，此时需要对红黑树分情况来讨论：

约定：
(1) cur 为当前节点，p为父节点，g为祖父节点，u为叔叔节点

(2) 下面的抽象图中，a/b/c/d/e 表示具有 n 个节点的红黑树，n >=0。

(一) 情况一: cur为红，p为红，g为黑，u存在且为红：

在这里插入图片描述

解决方式：将p,u改为黑，g改为红，然后把g当成cur，继续向上调整。

(二) 情况二: cur为红，p为红，g为黑，u不存在/u存在且为黑

在这里插入图片描述

下面我们根据 u 的情况用具象图分别解释单旋与双旋操作：

(1) u 不存在，a/b/c/d/e都是空，cur 是新增：

p为g的左孩子，cur为p的左孩子，则进行右单旋转，再 p 变黑，g 变红：

在这里插入图片描述

相反，p为g的右孩子，cur为p的右孩子，则进行左单旋转，再 p 变黑，g 变红：

在这里插入图片描述

p为g的左孩子，cur为p的右孩子，先针对p做左单旋转，再针对 g 做右单旋，cur 变黑，g 变红：

在这里插入图片描述

(2) u 存在且为黑

单旋情况：

在这里插入图片描述
双旋情况：
在这里插入图片描述

4.3 插入操作的完整代码

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

	//新增节点，颜色为红色
	cur->_col = RED;

	//链接时要判断链接在parent的左还是右
	if (parent->_kv.first > kv.first)
		parent->_left = cur;
	else
		parent->_right = cur;

	cur->_parent = parent;

	while (parent && parent->_col == RED)
	{
		Node* grandfather = parent->_parent;
		//    g
		// p     u
		if (parent == grandfather->_left)
		{
			//找到u的位置
			Node* uncle = grandfather->_right;
			
			if (uncle && uncle->_col == RED)
			{
				//u存在且为红,把p/u变黑，g变红,继续向上调整
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;

				cur = grandfather;
				parent = cur->_parent;
			}
			else
			{
				//u不存在或存在且为黑
				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
		{
			//    g
			// u     p
			Node* uncle = grandfather->_left;
			
			//u存在且为红,把p/u变黑，g变红,继续向上调整
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;

				cur = grandfather;
				parent = cur->_parent;
			}
			else
			{
				//u不存在或存在且为黑
				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;
}

五，红黑树的验证

红黑树的检测分为两步：

(1) 检测其是否满足二叉搜索树(中序遍历是否为有序序列)
(2) 检测其是否满足红黑树的性质

这里重点检测的是性质(3)与性质(4)。

检测性质(3)：只要判断当前节点与其父亲节点是否为连续的红色节点；

检测性质(4)：先计算出任意一条路径上的黑色节点作为参考值，再用这个参考值与其他路径上的黑色节点数量比较。

private:
	//中序遍历
	void InOrder()
	{
		_Inorder(_root);
		cout << endl;
	}

	//判断是否平衡
	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);
	}

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->_col == RED && root->_parent->_col == RED)
		{
			cout << root->_kv.first << "存在连续的红色节点" << endl;
			return false;
		}
		
		//blackNum表示：根节点到当前节点的路径上黑色节点的数量
		if (root->_col == BLACK)
			blackNum++;
		
		return Check(root->_left, blackNum, refNum)
			&& Check(root->_right, blackNum, refNum);
	}

六，实现红黑树的完整代码

RBTree.h

#pragma once

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

//枚举颜色
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(BLACK)
	{}
};

template <class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	Node* Find(const pair<K, V>& kv)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first > kv.first)
				cur = cur->_left;
			else if (cur->_kv.first < kv.first)
				cur = cur->_right;
			else
				return cur;
		}
		return nullptr;
	}

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

		//新增节点，颜色为红色
		cur->_col = RED;

		//链接时要判断链接在parent的左还是右
		if (parent->_kv.first > kv.first)
			parent->_left = cur;
		else
			parent->_right = cur;

		cur->_parent = parent;

		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			//    g
			// p     u
			if (parent == grandfather->_left)
			{
				//找到u的位置
				Node* uncle = grandfather->_right;
				
				if (uncle && uncle->_col == RED)
				{
					//u存在且为红,把p/u变黑，g变红,继续向上调整
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					//u不存在或存在且为黑
					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
			{
				//    g
				// u     p
				Node* uncle = grandfather->_left;
				
				//u存在且为红,把p/u变黑，g变红,继续向上调整
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					//u不存在或存在且为黑
					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 InOrder()
	{
		_Inorder(_root);
		cout << endl;
	}

	//判断是否平衡
	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);
	}

private:
	//每个节点的位置记录一个值blackNum
	//blackNum表示：根节点到当前节点的路径上黑色节点的数量
	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->_col == RED && root->_parent->_col == RED)
		{
			cout << root->_kv.first << "存在连续的红色节点" << endl;
			return false;
		}

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

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

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

		subL->_right = parent;

		//改变之前记录
		Node* ppNode = parent->_parent;
		parent->_parent = subL;

		//parent为根
		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			//parent为一颗子树
			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;

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

		subR->_left = parent;

		Node* ppNode = parent->_parent;
		parent->_parent = subR;

		//parent为根
		if (parent == _root)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			//parent为一颗子树
			if (ppNode->_left == parent)
				ppNode->_left = subR;
			else
				ppNode->_right = subR;

			subR->_parent = ppNode;
		}
	}

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

		_Inorder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_Inorder(root->_right);
	}
private:
	Node* _root = nullptr;
};

//测试代码
void Test1()
{
	//int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	int a[] = { 16,3,7,11,9,26,18,14,15 };
	RBTree<int, int> t;
	for (auto e : a)
		t.Insert({ e ,e });

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

Test.cpp

#include "RBTree.h"

int main()
{
	Test1();

	return 0;
}

运行结果如下：

中序遍历是有序的，说明是搜索二叉树，返回1，说明满足红黑树的性质，是平衡树。

在这里插入图片描述

五，红黑树与AVL树的比较

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

24k纯甄
关注
  • 113
    点赞
  • 踩
  • 108
    收藏
    觉得还不错? 一键收藏
  • 85
    评论
专栏目录
ARM/Linux嵌入式面经（十八）：TP-Link联洲
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
07-21 950
sizeof：是一个关键字，是编译时运算符，用于判断变量或数据类型的字节大小。其值在编译时就已计算好，可以接收数组、指针、类型、对象、函数等作为参数。strlen：是一个函数，用于计算字符串的长度，直到遇到第一个空字符（‘\0’）为止，但不包括该空字符。它必须在运行时才能计算，且参数必须是字符型指针（char*）。sizeof是编译时运算符，计算的是数据类型或变量所占的内存空间大小，与变量实际存储的内容无关。strlen。
深入浅出C++ ——手撕红黑树
weixin_55051736的博客
02-22 748
/节点的值域 Colour _col;//节点的颜色 RBTreeNode < K , V > * _left;//节点的左孩子 RBTreeNode < K , V > * _right;//节点的右孩子 RBTreeNode < K , V > * _parent;//节点的双亲 };
C++之红黑树剖析
wzh18907434168的博客
08-11 297
红黑树是一种自平衡的二叉搜索树，它是由 Rudolf Bayer 在1972年提出，并由 Leonidas J. Guibas 和 Robert Sedgewick 在1978年进行改进和推广的。红黑树是一种复杂的数据结构，旨在确保在最坏情况下的高效的插入、删除和查找操作。红黑树之所以被称为红黑树，是因为每个节点有一个存储的二进制值来表示节点的颜色，通常为红色或黑色。每个节点要么是红色，要么是黑色。根节点是黑色。每个叶子节点（NIL节点，空节点）是黑色。
【C++/STL】：红黑树的应用 --- 封装map和set
2301_77900444的博客
07-27 1559
map 和 set 的底层本质上还是复用通过对红黑树的改造，再分别套上一层 map 和 set 的 “壳子”，以达到 “一树二用” 的目的。在改造红黑树的过程中，我大概归纳了以下几个需要重点解决的问题：(1) 对红黑树节点的改造。关联式容器中存储的是的键值对，K为key的类型，如果是 set 则是 K，如果是map，则为pair。如何用一个节点结构控制两种类型，使用类模板参数T。(2) 在插入操作时，如何完成数据的比较。
手撕红黑树——C++高阶数据结构详解
热门推荐
qq_61500888的博客
09-06 1万+
带你一命通关红黑树 十五分钟手撕数据结构原理
28.红黑树_1.wmv（目前数据结构最好的视频,共42集，需要哪一集的知识自己下，一集3积分）
03-13
26红黑树 27红黑树_0 28红黑树_1 29红黑树_2 30红黑树_3 31红黑树_4 32红黑树_5 33红黑树_6 34堆 35堆排序 36哈希与映射的概述 37B树有什么用 38B树的概念 39图_邻接矩阵 40图_邻接表 41图_DFS 42图_BFS
红黑树之 原理算法详解
wyx911111的博客
12-13 502
  .手撕红黑树之 原理算法详解
华为OD--C++面经--23届考研二战失败
Jarrod-Zhou的博客
04-17 1099
末流985专业自动化，23届考研二战未就业，在学校主要打ACM竞赛，拿了ICPC和数学建模等比赛的几个国奖。虽然进过实验室，但没什么产出，也就没写简历上，约等于无项目无实习无科研，只有竞赛。3月8号开始准备，4月1号机试400分，4月2号下午做的性格测试，因为清明节放假没人面试，等了几天在背八股，4月7号晚上19:40HR资格审查，4月9号晚上19:00技术一面，4月12号下午17:00技术二面，4月16号晚上18:30主管面。
windows C++-windows C++/CX简介(六)
苏洛的博客
08-23 721
windows C++/CX介绍
【C++】链表
qq_38801607的博客
08-22 1100
链表是一种常见的动态数据结构，与数组相比，它在插入和删除操作中具有更高的效率。链表的每个元素称为节点（Node），节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。链表的最大特点是节点的内存位置不需要连续，可以通过指针来链接在一起。
【C/C++】C++程序设计基础（输入输出、数据类型、动态内存、函数重载、内联函数、常量、引用）
最新发布
强者征服今天，懦夫哀叹昨天，懒汉坐等明天。
08-28 503
在后面的章节中，会讲到类与对象，欢迎各位的关注~
C++ 重载运算符和重载函数
lly202406的博客
08-25 1017
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 1798
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
C++语言特性常见问题
wuxiaoyu0806的博客
08-25 628
循环引用是指两个或多个对象相互持有对方的，导致内存无法释放。解决方案是将其中一个改为，从而打破循环引用，避免内存泄漏。引用计数的引用计数在创建、复制、移动和销毁时发生变化，用于管理对象的生命周期。弱引用计数的弱引用计数在创建、复制、移动和销毁时变化，不影响对象的生命周期，但用于监控对象是否仍然存在。当最后一个被销毁时，引用计数归零，对象会被销毁并释放内存。
初识顺序表---C语言
weixin_74202161的博客
08-23 748
顺序表是一种以数组为基础的结构，对数组进行封装，实现常用的增删改查等操作的。//销毁。
＜C++＞ 多态
prodigy623的博客
08-24 1207
多态的细节
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 543
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
探索搜索树：二叉、AVL、红黑与B-树的原理与应用
红黑树广泛应用于C++ STL中的关联容器，如set、map等。 4. **B-树** B-树是一种多路搜索树，适用于磁盘等外存环境下，它能在一次I/O操作中处理多个记录。B-树的特点是每个节点可以有多个子节点，并且所有叶子节点...
评论 85
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值