【C + +】红黑树：全面剖析与深度学习

🌟个人主页：第七序章****

🌈专栏系列：C＋＋****

❄️前言：

☀️一、红黑树概念

[🌙1.1. 红黑树的性质](#🌙1.1. 红黑树的性质)

[🌙1.2. 最短和最长路径](#🌙1.2. 最短和最长路径)

[☀️二、红黑树节点的定义和结构](#☀️二、红黑树节点的定义和结构)

[🌙2.1. 基本元素](#🌙2.1. 基本元素)

❄️前言：

前面我们学习了AVL树的平衡机制与实现，今天我们来学习一下红黑树的实现，上一篇博客传送门------C + +异常处理。

☀️一、红黑树概念

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

红黑树由Rudolf Bayer在1972年发明，最初被称为平衡二叉B树（Symmetric Binary B-trees），后来被Guibas和Robert Sedgewick修改为如今的"红黑树"。

🌙1.1. 红黑树的性质

每个节点不是红色就是黑色

根节点是黑色的

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

对于每个节点，从该节点到其后代节点的简单路径上，均包含相同数目的黑色节点

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

满足上面的性质，红黑树就能保证:其最长路径中节点个数不会超过最短路径节点个数的两倍，但是不能保证满足这样的条件就是红黑树，具体还是往下看吧，这里重点关注的是规则3、4。

🌙1.2. 最短和最长路径

最短:全黑

最长:一黑一红

虽然有最短和最长路径，但是不一定存在最短或最长路径

具体说明:

对于红黑树满足最长路径中节点个数不会超过最短路径节点个数的两倍结论，是根据红黑树规则及其最短和最长路径得来的。

规则四:对于每个节点，从该节点到其后代节点的简单路径上，均包含相同数目的黑色节点。保证了每条路径黑色节点数量相同的。如果我们想要延长某一条路径，插入黑色节点不能达成目的，对此我们需要插入红色节点，碍于规则三:如果一个节点是红色的，则它的两个孩子节点是黑色的限制，对此只能在两个黑色节点之间插入一个红色节点或者在最后黑色节点插入一个红色节点。导致了最短为全黑，最长一黑一红，大致形成两倍的关系，但是不一定存在最短或最长路径(路径相同)。

红黑树的平衡维护在这微妙的关系中，如果不能保证其最长路径中节点个数不会超过最短路径节点个数的两倍就是不是红黑树，就是能保证也不一定是红黑树，不充分必要条件

使用枚举常量代替红色和黑色的含义。就是跟全部黑色节点或者全部黑色节点配合红色节点

☀️二、红黑树节点的定义和结构

🌙2.1. 基本元素

_left：****指向节点的左子节点的指针

_right：****指向节点的右子节点的指针

_parent：****指向节点的父节点的指针

_kv：****一个结构体或配对（pair），包含节点的键值（key）和值（value）。这取决于红黑的具体用途，可能只包含键或包含键值对。

_col：****表示当前节点的颜色。

🌙2.2.节点颜色

在上面的定义中，_col 成员变量用于表示节点的颜色，通过 Color枚举类型来定义，可以是RED或BLACK。

🌙2.3.构造函数

初始化一个新节点时，通常需要一个构造函数，它接受一个键值对（或仅键），并设置节点的左子节点、右子节点、父节点和颜色（初始化为红色）

cpp 复制代码

//枚举值表示颜色
enum Colour
{
	RED,
	BLACK
};
 
//这里我们默认使用key/value结构实现
template<class K,class V>
struct RBTreeNode
{
	// 这里更新控制平衡加入parent指针
	pair<K, V> _kv;
	RBTreeNode<K,V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
 
	Colour _col;
 
	RBTreeNode(const pair<K,V>& kv)
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
	{ }
};
 
template<class K,class V>
class RBTree
{
	typedef RBTreeNode<class K, class V> Node;
public:
private:
	Node* _root;
};

思考：在节点的定义中，为什么要将节点的默认颜色给成红色的？

答案：优先增加黑色节点必定会破坏红黑树的默认规则和结构，而新插入红色节点可以通过调整来适应规则，不一定会破坏结构。

☀️三、关于红黑树的插入

这里我们可以确定c\p\g颜色是确定的，关键在于u颜色是不确定，从而影响整棵树的平衡

可以将情况分为两种：

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

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

⭐【红黑树树插入一个值的大概过程】

插入一个值按⼆叉搜索树规则进行插⼊，插⼊后我们只需要观察是否符合红黑树的4条规则。
如果是空树插⼊，新增结点是黑色结点。如果是非空树插⼊，新增结点必须红色结点，因为⾮空树插⼊，新增黑色结点就破坏了规则4，规则4是很难维护的。
⾮空树插⼊后，新增结点必须红色结点，如果父亲结点是黑色的，则没有违反任何规则，插入结束
非空树插入后，新增结点必须红色结点，如果父亲结点是红色的，则违反规则3。进⼀步分析，c是红色，p为红，g必为黑（插入之前保证这棵树是一棵平衡的红黑树），这三个颜色都固定了，关键的变化看u的情况，需要根据u分为以下几种情况分别处理。

说明：下图中假设我们把新增结点标识为c (cur)，c的父亲标识为p(parent)，p的父亲标识为 g(grandfather)，p的兄弟标识为u（uncle）。

⭐【情况1：变色】

c为红，p为红，g为黑，u存在且为红，则将p和u变黑，g变红。在把g当做新的c，继续往上更新。
分析：因为p和u都是红色，g是黑色，把p和u变黑，左边子树路径各增加⼀个黑色结点，g再变红，相当于保持g所在子树的黑色结点的数量不变，同时解决了c和p连续红色结点的问题，需要继续往上更新是因为，g是红色，<1>如果g的父亲还是红色，那么就还需要继续处理；<2>如果g的⽗亲是黑色，则处理结束了；<3>如果g就是整棵树的根，再把g变回黑色。

情况1只变色，不旋转。所以无论c是p的左还是右，p是g的左还是右，都是上面的变色处理方式。

跟AVL树类似，图0我们展示了⼀种具体情况，但是实际中需要这样处理的有很多种情况。
图1将以上类似的处理进行了抽象表达，d/e/f代表每条路径拥有hb个黑色结点的子树，a/b代表每条路径拥有hb-1个黑色结点的根为红的子树，hb>=0。
图2/图3/图4，分别展示了hb == 0/hb == 1/hb == 2的具体情况组合分析，当hb等于2时，这⾥组合情况上百亿种，这些样例是帮助我们理解，不论情况多少种，多么复杂，处理方式⼀样的，变色再继续往上处理即可，所以我们只需要看抽象图即可。

图3

⭐【情况2：单旋+变色】

c为红，p为红，g为⿊，u不存在或者u存在且为黑，u不存在，则c⼀定是新增结点，u存在且为黑，则 c⼀定不是新增，c之前是黑色的，是在c的子树中插入，符合情况1，变色将c从黑色变成红色，更新上来的。

分析：p必须变黑，才能解决，连续红色结点的问题，u不存在或者是黑色的，这里单纯的变色无法解决问题，需要旋转+变色。

如果p是g的左，c是p的左，那么以g为旋转点进⾏右单旋，再把p变⿊，g变红即可。p变成这颗树的根，这样⼦树黑色结点的数量不变，没有连续的红色结点了，且不需要往上更新，因为p的⽗亲是黑色还是红色或者空都不违反规则。

如果p是g的右，c是p的右，那么以g为旋转点进行左单旋，再把p变⿊，g变红即可。p变成这颗树新的根，这样子树黑色结点的数量不变，没有连续的红色结点了，且不需要往上更新，因为p的父亲是黑色还是红色或者空都不违反规则。

⭐【情况2：双旋+变色】

c为红，p为红，g为⿊，u不存在或者u存在且为黑，u不存在，则c⼀定是新增结点，u存在且为黑，则c⼀定不是新增，c之前是黑色的，是在c的子树中插入，符合情况1，变色将c从黑色变成红色，更新上来的。

分析：p必须变黑，才能解决，连续红色结点的问题，u不存在或者是黑色的，这里单纯的变色无法解决问题，需要旋转+变色。

如果p是g的左，c是p的右，那么先以p为旋转点进行左单旋，再以g为旋转点进行右单旋，再把c变黑，g变红即可。c变成这棵树新的根，这样子树黑色结点的数量不变，没有连续的红色结点了，且不需要往上更新，因为c的父亲是黑色还是红色或者空都不违反规则。

如果p是g的右，c是p的左，那么先以p为旋转点进⾏右单旋，再以g为旋转点进行左单旋，再把c变黑，g变红即可。c变成这颗树新的根，这样子树黑色结点的数量不变，没有连续的红色结点了，且不需要往上更新，因为c的父亲是黑色还是红色或者空都不违反规则。

这里将根据思路和不同功能罗列代码了，这里旋转后的节点的颜色需要自己根据图单独进行处理的。红黑树也是属于二叉搜索树，对此我们这里可以CV下代码。

右旋代码

cpp 复制代码

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)
    {
        SubL = _root;
        SubL->_parent = nullptr;
    }
    else
    {
        if (ppNode->_left == parent)
        {
            ppNode->_left = SubL;
        }
        else if (ppNode->_right == parent)
        {
            ppNode->_right = SubL;
        }
        SubL->_parant = ppNode;
    }
}

左旋代码

cpp 复制代码

void RotateL(Node* parent)
{
    Node* SubR = parent->_right;
    Node* SubRL = SubR->_left;

    parent->_right = SubRL;
    if (SubRL)
        SubR->_parent = parent;

    SubR->_left = parent;
    Node* ppNode = parent->_parent;

    parent->_parent = SubR;

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

⭐红黑树插入逻辑(重点)

cpp 复制代码

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 = new Node(kv);
	cur->_col = RED;
	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 (grandfather->_left == parent)
		{
			//   g
			// p   u
			//
			Node* uncle = grandfather->_right;
			// 情况一：uncle存在且为红
			if (uncle && uncle->_col == RED)
			{
				// 变色
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;
 
				// 继续往上处理
				cur = grandfather;
				parent = cur->_parent;
			}
			else  // 情况二：uncle不存在，或者存在且为黑
			{
				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;
			// 情况一：叔叔存在且为红，变色即可
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;
 
				// 继续往上处理
				cur = grandfather;
				parent = cur->_parent;
			}
			else // 叔叔不存在，或者存在且为黑
			{
				// 情况二：叔叔不存在或者存在且为黑
				// 单旋+变色
				//    g
				//  u   p
				//        c
				if (cur == parent->_right)
				{
					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;
}

☀️四、遍历红黑树

如果中序遍历可得到一个有序的序列，就说明为二叉搜索树

cpp 复制代码

void InOder()
{
    _InOder(_root);
    cout << endl;
}
private:	
void _InOder(Node* _root)
{
    _InOder(_root->_left);
    cout << endl;
    _InOder(_root->_right);

}

这里将中序遍历实现逻辑封装到私有成员函数中隐藏它的具体实现细节，使得外部用户无法直接访问该函数，提高了代码的安全性和可维护性，符合面向对象编程的封装性原则。这里外部访问中序遍历接口，只是传递了节点指针的副本，而不修改任何节指针的实际值。

☀️五、判断是否满足红黑树

可以根据红黑树的规则来进行判断，具体细节在代码块注释。其中规则四就是判断每条路径的黑色节点个数是否相同，那么可以提前记录好一条路径的黑色节点个数去比较 ，当**_root == nullptr**说明这条路径遍历完毕，需要就行判断

cpp 复制代码

bool IsBalance() 
	{
    //规则一:根节点颜色为黑色
		if (_root->_color == RED)
		{
			return false;
		}
	
		int refNum = 0;
		//记录单独一边黑色节点个数
		Node* cur = _root;
		while (cur)
		{
			refNum++;
			cur = cur->_left;
		}

		return Check(_root, 0, refNum);
	}
private:

bool Check(Node* root, int blackNum, const int refNum)
{
    //接下就是遍历每条路径了
    if (_root == nullptr)
    {
        //规则4
        if (blackNum != refNum)
        {
            cout << "不满足每条路径相同黑色节点" << endl;
            return  false;
        }
        return true;
    }
    //规则3
    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)
}

关于规则3这里判断逻辑设计，是根找父亲，而不是根找儿子。如果是根找儿子，需要去左右孩子去找又分为多种情况，不然选择一条单一的路线，根找父亲，反正都是遍历每个节点。

问题:

为什么不能通过其最长路径中节点个数不会超过最短路径节点个数的两倍来判断是否为红黑树呢？

答:

这里是不充分必要条件，比如下图左边这条路径不满足规则4，当插入时就会出现问题。(路径是指某条路径空节点到根节点)

☀️六、红黑树的删除

红黑树的删除本章节不做讲解，有兴趣的同学可参考：《算法导论》或者《STL源码剖析》中讲解。

☀️七、红黑树与AVL树的比较

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

🌙完整代码：

可以进行红黑树和AVL树的一些性能测试

⭐RBTree.h

cpp 复制代码

#pragma once
 
enum Colour
{
	RED,
	BLACK
};
// 这里我们默认按key/value结构实现
template<class K, class V>
struct RBTreeNode
{
	// 这里更新控制平衡也要加入parent指针
	pair<K, V> _kv;
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
 
	Colour _col;
 
	RBTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
	{
	}
};
 
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 = new Node(kv);
		cur->_col = RED;
		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 (grandfather->_left == parent)
			{
				//   g
				// p   u
				//
				Node* uncle = grandfather->_right;
				// 情况一：uncle存在且为红
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
 
					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else  // 情况二：uncle不存在，或者存在且为黑
				{
					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;
				// 情况一：叔叔存在且为红，变色即可
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
 
					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else // 叔叔不存在，或者存在且为黑
				{
					// 情况二：叔叔不存在或者存在且为黑
					// 单旋+变色
					//    g
					//  u   p
					//        c
					if (cur == parent->_right)
					{
						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;
	}
 
	// 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);
	}
 
	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);
	}
 
	int Height()
	{
		return _Height(_root);
	}
 
	int Size()
	{
		return _Size(_root);
	}
 
	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 nullptr;
	}
 
protected:
	int _Size(Node* root)
	{
		if (root == nullptr)
			return 0;
 
		return _Size(root->_left) + _Size(root->_right) + 1;
	}
 
	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;
	}
 
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
 
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
 
		Node* ppNode = parent->_parent;
 
		subL->_right = parent;
		parent->_parent = subL;
 
		//if (ppNode == nullptr)
		if (parent == _root)
		{
			_root = subL;
			subL->_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;
		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 _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;
};

⭐AVLTree.h

cpp 复制代码

#pragma once
 
template<class K, class V>
struct AVLTreeNode
{
	// 需要parent指针，后续更新平衡因子可以看到
	pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf; // balance factor
 
	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _bf(0)
	{
	}
};
 
template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			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 = new Node(kv);
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
 
		cur->_parent = parent;
 
		// 更新平衡因子
		while (parent)
		{
			if (cur == parent->_right)
			{
				parent->_bf++;
			}
			else
			{
				parent->_bf--;
			}
 
			if (parent->_bf == 0)
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				// 旋转
				if (parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == 1)
				{
					RotateL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					RotateLR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}
				else
				{
					assert(false);
				}
 
				break;
			}
			else
			{
				assert(false);
			}
		}
 
		return true;
	}
 
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
 
	bool IsBalanceTree()
	{
		return _IsBalanceTree(_root);
	}
 
	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 nullptr;
	}
 
 
	int Height()
	{
		return _Height(_root);
	}
 
	int Size()
	{
		return _Size(_root);
	}
private:
	int _Size(Node* root)
	{
		if (root == nullptr)
			return 0;
 
		return _Size(root->_left) + _Size(root->_right) + 1;
	}
 
	bool _IsBalanceTree(Node* root)
	{
		// 空树也是AVL树
		if (nullptr == root)
			return true;
 
		// 计算pRoot结点的平衡因子：即pRoot左右子树的高度差
		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);
		int diff = rightHeight - leftHeight;
 
		// 如果计算出的平衡因子与pRoot的平衡因子不相等，或者
		// pRoot平衡因子的绝对值超过1，则一定不是AVL树
		if (abs(diff) >= 2)
		{
			cout << root->_kv.first << "高度差异常" << endl;
			return false;
		}
 
		if (root->_bf != diff)
		{
			cout << root->_kv.first << "平衡因子异常" << endl;
			return false;
		}
 
		// pRoot的左和右如果都是AVL树，则该树一定是AVL树
		return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right);
	}
 
	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;
	}
 
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
 
		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_InOrder(root->_right);
	}
 
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
 
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
 
		Node* ppNode = parent->_parent;
 
		subL->_right = parent;
		parent->_parent = subL;
 
		//if (ppNode == nullptr)
		if (parent == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
 
		parent->_bf = 0;
		subL->_bf = 0;
	}
 
	void RotateL(Node* parent)
	{
		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;
		}
		parent->_bf = subR->_bf = 0;
	}
 
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;
 
		RotateL(parent->_left);
		RotateR(parent);
 
		if (bf == -1)
		{
			subL->_bf = 0;
			parent->_bf = 1;
			subLR->_bf = 0;
		}
		else if (bf == 1)
		{
			subL->_bf = -1;
			parent->_bf = 0;
			subLR->_bf = 0;
		}
		else if (bf == 0)
		{
			subL->_bf = 0;
			parent->_bf = 0;
			subLR->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
 
	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;
		RotateR(parent->_right);
		RotateL(parent);
		if (bf == 0)
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			subR->_bf = 0;
			subRL->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == -1)
		{
			subR->_bf = 1;
			subRL->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}
private:
	Node* _root = nullptr;
};

⭐test.cpp

cpp 复制代码

#define _CRT_SECURE_NO_WARNINGS 1
 
#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;
 
#include"RBTree.h"
#include"AVLTree.h"
 
// 测试代码
void TestRBTree1()
{
	RBTree<int, int> t;
 
	// 常规的测试用例
	int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
 
	// 特殊的带有双旋场景的测试用例
	//int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
 
	for (auto e : a)
	{
		/*if (e == 14)
		{
			int x = 0;
		}*/
 
		t.Insert({ e, e });
		cout << "Insert:" << e << "->";
		cout << t.IsBalance() << endl;
	}
 
	t.InOrder();
	cout << t.IsBalance() << endl;
}
 
// 插入一堆随机值，测试平衡，顺便测试一下高度和性能等
void TestRBTree2()
{
	const int N = 10000000;
	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.IsBalance() << endl;
 
	cout << "RBTree Insert:" << end2 - begin2 << endl;
	cout << "RBTree Height:" << t.Height() << endl;
	cout << "RBTree Size:" << t.Size() << endl;
 
	size_t begin1 = clock();
	// 确定在的值
	/*for (auto e : v)
	{
		t.Find(e);
	}*/
	// 随机值
	for (size_t i = 0; i < N; i++)
	{
		t.Find((rand() + i));
	}
 
	size_t end1 = clock();
	cout << "RBTree Find:" << end1 - begin1 << endl << endl;
}
 
void TestAVLTree2()
{
	const int N = 10000000;
	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();
	AVLTree<int, int> t;
	for (auto e : v)
	{
		t.Insert(make_pair(e, e));
	}
	size_t end2 = clock();
 
	cout << t.IsBalanceTree() << endl;
 
	cout << "AVLTree Insert:" << end2 - begin2 << endl;
	cout << "AVLTree Height:" << t.Height() << endl;
	cout << "AVLTree Size:" << t.Size() << endl;
 
	size_t begin1 = clock();
	// 确定在的值
	/*for (auto e : v)
	{
		t.Find(e);
	}*/
	// 随机值
	for (size_t i = 0; i < N; i++)
	{
		t.Find((rand() + i));
	}
 
	size_t end1 = clock();
	cout << "AVLTree Find:" << end1 - begin1 << endl;
}
 
int main()
{
	TestRBTree2();
	TestAVLTree2();
 
	return 0;
}

☀️本文小结：

章节	核心内容	关键细节
一、红黑树概念	1. 起源：1972 年 Rudolf Bayer 发明，初称 "平衡二叉 B 树"，后经修改为 "红黑树"2. 核心性质：保证最长路径节点数不超过最短路径的 2 倍（非充分必要条件）3. 路径特点：最短路径为全黑节点，最长路径为 "黑 - 红" 交替	1. 关键规则：规则 3（红节点的子节点必为黑）、规则 4（任一节点到后代空节点的路径黑节点数相同）2. 颜色标识：用枚举常量`RED`和`BLACK`表示节点颜色
二、红黑树节点定义	1. 基本元素：`_left`（左子指针）、`_right`（右子指针）、`_parent`（父指针）、`_kv`（键值对）、`_col`（颜色）2. 构造函数：初始化节点成员，默认无父节点、无子节点	1. 节点默认颜色：红色（新增黑色节点必破坏规则 4，红色节点可通过调整适配规则）2. 模板设计：支持`K`（键类型）和`V`（值类型）的泛型定义
三、红黑树插入	1. 插入流程：先按二叉搜索树规则插入，空树插入黑色节点，非空树插入红色节点2. 平衡调整：根据叔叔节点（`u`）颜色分 3 种情况	1. 情况 1（u 为红）：仅变色（父、叔变黑色，祖父变红色），继续向上处理2. 情况 2（u 为黑 / 不存在）：单旋 + 变色（如祖父右旋，父变黑色、祖父变红色）3. 情况 3（u 为黑 / 不存在）：双旋 + 变色（如父左旋后祖父右旋，当前节点变黑色、祖父变红色）4. 最终保证：根节点强制设为黑色
四、红黑树遍历	1. 遍历方式：中序遍历（结果为有序序列，可验证是否为二叉搜索树）2. 封装设计：外部接口`InOrder()`调用私有`_InOder()`，隐藏实现细节	1. 私有函数作用：避免外部直接访问节点指针，符合面向对象封装原则2. 遍历逻辑：递归访问左子树→输出当前节点键值→递归访问右子树
五、红黑树验证	1. 验证依据：红黑树规则（根节点为黑、无连续红节点、路径黑节点数相同）2. 实现方法：先记录一条路径的黑节点数（`refNum`），再递归检查所有路径	1. 关键判断：- 根节点若为红，直接返回`false`- 存在连续红节点（当前红且父红），返回`false`- 某路径黑节点数≠`refNum`，返回`false`
六、红黑树删除	暂不讲解，推荐参考资料：《算法导论》《STL 源码剖析》	略......
七、红黑树与 AVL 树对比	1. 共性：均为平衡二叉树，增删改查时间复杂度均为`O(logn)`2. 差异：红黑树非绝对平衡（最长路径≤2 倍最短），AVL 树绝对平衡（左右子树高度差≤1）	1. 性能优势：红黑树插入 / 旋转次数更少，适合频繁增删场景2. 实现复杂度：红黑树更简单，实际应用更广泛（如 STL 容器底层）
完整代码文件	1. `RBTree.h`：红黑树类（插入、旋转、遍历、验证等核心接口）2. `AVLTree.h`：AVL 树类（用于性能对比）3. `test.cpp`：测试代码（常规插入测试、百万级数据性能测试）	1. 旋转接口：`RotateR()`（右旋）、`RotateL()`（左旋），处理父节点与祖父节点的指针关系2. 性能测试：对比红黑树与 AVL 树的插入耗时、查询耗时、树高

🌻共勉:

以上就是本篇博客的所有内容，如果你觉得这篇博客对你有帮助的话，可以点赞收藏关注支持一波~~🥝

【C + +】红黑树：全面剖析与深度学习

❄️前言：

☀️一、红黑树概念

🌙1.1. 红黑树的性质

🌙1.2. 最短和最长路径

☀️二、 红黑树节点的定义和结构

🌙2.1. 基本元素

🌙2.2.节点颜色

🌙2.3.构造函数

☀️三、关于红黑树的插入

⭐【红黑树树插入一个值的大概过程】

⭐【情况1：变色】

⭐【情况2：单旋+变色】

⭐【情况2：双旋+变色】

⭐红黑树插入逻辑(重点)

☀️四、遍历红黑树

☀️五、判断是否满足红黑树

☀️六、红黑树的删除

☀️七、红黑树与AVL树的比较

🌙完整代码：

⭐RBTree.h

⭐AVLTree.h

⭐test.cpp

☀️本文小结：

🌻共勉:

☀️二、红黑树节点的定义和结构