C++ 实现红黑树详解（内附源码）_c++ 完整稳定红黑树源码-优快云博客

本文链接：https://blog.youkuaiyun.com/2301_77754590/article/details/144001181

红黑树是一种自平衡二叉搜索树，它能保证在插入和删除元素时，树的高度保持在对数级别，从而保证了查找操作的时间复杂度是 O(log n)。本篇文章将详细介绍如何在 C++ 中实现红黑树，重点解析其核心数据结构与操作算法。

首先我们来了解下红黑树的基本概念

红黑树的基本概念

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

Black 。通过对 任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路

径会比其他路径长出俩倍 ，因而是 接近平衡 的

红黑树的性质

红黑树是一种特殊的二叉搜索树，其节点具有以下颜色属性：

每个节点要么是红色，要么是黑色。
根节点始终是黑色。
每个叶子节点（NIL节点，表示空节点）是黑色。
如果一个节点是红色的，则它的两个子节点必须是黑色的。
从任一节点到其所有后代叶子节点的路径上，必须有相同数量的黑色节点。

这些性质保证了红黑树的平衡性，避免了树的退化成链表。

数据结构设计

在 C++ 中，我们通常会设计一个 RBTreeNode 结构体来表示红黑树的节点

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include <map>
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; // 父节点
    std::pair<K, V> _kv;       // 键值对
    Colour _col;               // 节点颜色（红色或黑色）

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

1. 节点成员变量

_left、_right、_parent：分别指向当前节点的左子节点、右子节点和父节点。
_kv：存储节点的键值对，K 表示键，V 表示值。
_col：表示节点的颜色，RED 表示红色，BLACK 表示黑色。

2. 节点构造函数

RBTreeNode 结构体的构造函数用于初始化节点的颜色和键值对。默认情况下，节点的颜色为红色，左右子节点和父节点为 nullptr。

紧接着我们要思考一个问题，红黑树接下来要实现是吗核心操作，毫无疑问，核心便是插入操作，只有熟悉插入操作是如何改变树的结构的，又是如何与红黑树前几点性质契合的，我们才能说自己懂红黑树。

红黑树的插入操作

1. 插入操作

插入操作通常分为两个步骤：

标准的二叉搜索树插入：先将节点插入到树中，形成一个符合二叉搜索树的结构。
修复红黑树的性质：插入的节点可能会破坏红黑树的性质，因此需要进行修复，常见的修复方法有旋转操作。

插入后的修复过程

插入节点后，可能会出现以下几种情况：

插入的节点的父节点是黑色，无需进一步修复。
插入的节点的父节点是红色，则需要进行旋转和重新着色以恢复红黑树的性质。

具体修复过程涉及左旋、右旋以及重新着色的操作。旋转操作是红黑树平衡的核心。

紧着我们来详细的讲解一下插入操作：

首先既然插入新节点，所以规则一定是符合二叉树的基本规则，大的向右排序，小的向左排序。

首先我们要明白二叉树的基本规则是如何互相影响的呢?

通过前文我们知道，红黑树的每条路径必须有相同数量的黑色节点，而同时，红色节点的下一个节点一定是黑色节点，通过这最重要的两点我们能推断出什么？

每条路径都要有一样的黑色节点，所以是不是可以理解为除了黑色以外的红色节点就说多余的节点，红色越多代表当前路径越长，但是红色后面一定是黑色，说明顺序一定是一黑一红，所以由此我们可以得出“一黑一红为最长，全黑为最短” 因此，最短路径和最长路径距离一定在2倍以内。

这就保证了我们红黑树的平衡问题，而插入的时候是不是就会打破这个平衡呢？

比如在红色节点的基础上又插入了一个红色节点，两个红色节点岂不是违反了我们的规则。所以就要进行调整，所以就来到了我们插入的第一步“要插入红色好还是黑色好呢？”

1.插入黑色：

通过红黑树的基本性质可以知道每条路径必须拥有相同数量的黑色节点，假设我在当前路径新插入了一个黑色节点，那岂不是我其他的所有路径为了满足数量相同都要插入一个一样的黑色节点，插入什么节点先不说，这个工作量岂不是超负荷啊，所以黑色一定是行不通的。

2.插入红色：

如果我新插入的是红色呢，是不是他只违反我们的“红色节点下一个节点必是黑色节点”的性质呢，相比插入黑色，貌似插入红色付出的“代价”是很小的，我们是不是只需要对插入红色后的当前子树进行调整，比如变色？旋转？，最终就平衡了啊

综上，我们新插入的节点一定只能是红色！

所以完成我们插入步骤的第一步了，紧接着就要完成第二步，修复红黑树

2. 修复操作

因为 新节点的默认颜色是红色 ，因此：如果 其双亲节点的颜色是黑色，没有违反红黑树任何

性质，则不需要调整；但 当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连

在一起的红色节点 ，此时需要对红黑树分情况来讨论：

因为当前父亲和新增节点一定是红色的，那么决定因素在谁呢？我们是不是说了每条路径的黑色节点要相同啊，那么对于我当前子树，唯一能参考的另一颗子树只能是叔叔的那一棵子树了，因为爷爷一定是黑色节点，决定因素在叔叔节点！

约定 :cur 为当前节点， p 为父节点， g 为祖父节点， u 为叔叔节点

情况一:

cur为红，p为红，g为黑，u存在且为红

这种情况也就是叔叔为红，我们的操作是什么呢？有图可以看到我们将父亲节点和叔叔节点同时变黑，同时将爷爷变红，这样下来不难发现每条路径的黑色节点数量竟然还和原来一样？是不是很神奇，而仅仅是这样就结束了吗

这里的g是不是只是象征性的根节点，他还有可能只是我众多子树中的其中一颗，如果他是子树的根节点，g又变成了红色，如果g的父亲节点原来也是红色节点呢？此时这棵树是不是还需要调整啊，是不是还要判断g的叔叔啊，是不是和当前情况完全一样啊，所以我们只需要向上遍历即可，也就是，cur变为g，p变为cur的父亲节点，继续向上完成遍历操作，直到根节点

情况二:

cur为红，p为红，g为黑，u不存在/u存在且为黑

那我们先看u不存在的情况

此时我们只需要把p变成黑色，爷爷变成红色，再进行一个右单旋操作，是不是既解决了黑色节点相同的问题，还解决了平衡问题啊，

紧接着我们看u存在且为黑的情况：

那么这张图就不那么合理了，为什么？叔叔为黑的情况下是不是意味着每条路径都要有两个黑色节点，那么此时左边原本如果没有cur的话岂不是只有一个黑色节点，所以根本不存在这种情况，cur一定不会是新增节点，cur只能是黑色,他只能是下图这种向上调整时才会出现

那么我们看似是不是完成了所有条件的考虑呢，叔叔存在且为红，叔叔不存在，叔叔为黑，可是有没有发现，我们当前的cur是不是一直都是在p的左侧啊，我们假设的一直都是小值，可如果来个大值呢,也就是cur在p的右侧，这种情况我们还没有考虑到，

这种情况我们该怎么办，仅仅一个右单旋够吗？

只右单旋的话cur会变成g的左子树，又重新变成了两个连续的红色节点，所以我们需要先进行左单旋恢复情况一，再进行右单旋就可以轻松解决此问题

然后我们就可以对我们的红黑树进行一个验证了

红黑树的检测分为两步：

1. 检测其是否满足二叉搜索树 ( 中序遍历是否为有序序列 )

2. 检测其是否满足红黑树的性质


	void InOrder() {
		_InOrder(_root);
	}

	bool Isbalance()
	{
		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)
		{
			if (blackNum != refNum)
			{
				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 _InOrder(Node* root)
	{
		if (root == nullptr) {
			return;
		}
		_InOrder(root->_left);
		cout << root->_kv.first << " " << root->_kv.second << endl;
		_InOrder(root->_right);
	}
	Node* _root = nullptr;
	size_t size = 0;
};

希望本文对你了解红黑树的工作原理和 C++ 实现有所帮助！以下是完整的C++实现红黑树源码

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include <map>
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;
	std::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 = 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 (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
				{
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			else
			{
				Node* uncle = grandfather->_left;
				if (parent == grandfather->_right)
				{
					//主要看叔叔
					Node* uncle = grandfather->_left;
					if (uncle && uncle->_col == RED)
					{
						parent->_col = uncle->_col =  BLACK;
						grandfather->_col = RED;
						cur = grandfather;
						parent = cur->_parent;
					}
					else
					{
						//叔叔不存在或者为黑才涉及到旋转，
						if (cur == parent->_right)
						{
							RotateL(grandfather);
							parent->_col = BLACK;
							grandfather->_col = RED;
						}
						else
						{
							RotateR(parent);
							RotateL(grandfather);
							cur->_col = BLACK;
							grandfather->_col = RED;
						}
						break;
					}
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}

	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 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 InOrder() {
		_InOrder(_root);
	}

	bool Isbalance()
	{
		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)
		{
			if (blackNum != refNum)
			{
				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 _InOrder(Node* root)
	{
		if (root == nullptr) {
			return;
		}
		_InOrder(root->_left);
		cout << root->_kv.first << " " << root->_kv.second << endl;
		_InOrder(root->_right);
	}
	Node* _root = nullptr;
	size_t size = 0;
};