C++ 红黑树实现详解：理论+代码+图解

最新推荐文章于 2025-08-09 16:37:48 发布
最新推荐文章于 2025-08-09 16:37:48 发布
阅读量1.2k 收藏 23
点赞数 35
CC 4.0 BY-SA版权
分类专栏： C++成神之路 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75587702/article/details/150023755

C++ 红黑树实现详解：理论+代码+图解

文章目录

一、红黑树的概念

在这里插入图片描述

1.1 红黑树的规则

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述—

1.2 红黑树的效率

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

1.3 红黑树和AVL树的比较

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

二、红黑树的实现

2.1 红黑树的结构

这里用枚举值表示颜色，默认按key/value结构实现，更新控制平衡也要加入parent指针！

在这里插入图片描述

2.2 红黑树的插入

红黑树插入节点和二叉搜索树是一样的，但是红黑树有红黑两种颜色标识
红黑树的插入：关键看叔叔uncle

在这里插入图片描述

在这里插入图片描述

下面介绍如果红黑树的结构被破坏了，需要做的以下三种调整！

2.2.1 插入结点是根结点

这里会违反根叶黑的性质，直接把根节点变黑即可
在这里插入图片描述

2.2.2 插入结点的叔叔是红色

对cur的父亲、叔叔、爷爷三个节点进行变色（红变黑，黑变红）
随后让爷爷变成cur插入节点：cur指向爷爷，进一步向上判定是否违反红黑树性质
对于插入节点的叔叔是红色，可能不止调整一次，每次调整完，都需要跳转到爷爷那继续判定调整

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

2.2.3 插入结点的叔叔是黑色

插入节点的叔叔是黑色：（LL,RR,LR,RL）旋转，然后变色

2.2.3.1 LL型

在这里插入图片描述

2.2.3.2 RR型

在这里插入图片描述

2.2.3.3 RL型

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

2.2.3.4 LR型

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

2.2.4 红黑树的插入代码实现

旋转代码的实现跟AVL树是一样的，只是不需要更新平衡因子

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

代码如下（示例）：

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;
			 // g
			 // p u
			 if (parent == grandfather->_left)
			 {
				 Node* uncle = grandfather->_right;
				 if (uncle && uncle->_col == RED)
				 {
					 // u存在且为红 -》变⾊再继续往上处理
					 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;
				 // 叔叔存在且为红，-》变⾊即可
				 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;
	}

2.3 红黑树的查找

按二叉搜索树逻辑实现即可，搜索效率为O(logN)
在这里插入图片描述

2.4 红黑树的验证

在这里插入图片描述

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

代码如下（示例）：

	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);
	}

2.5 红黑树的删除

红黑树的删除主要采用了二叉搜索树的方法
在这里插入图片描述

2.5.1 只有左孩子/右孩子：代替后变黑

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

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

2.5.2 没有孩子

2.5.2.1 没有孩子： 删除红节点

在没有孩子的情况下，如果删除红节点：删除后无需任何调整

在这里插入图片描述

2.5.2.2 没有孩子： 删除黑节点

为了更好理解这个过程，我们这里引入了双黑节点的概念
因为删除黑色节点之后，所有经过他的路径都会少一个黑色节点，假设这个节点具有两层黑色
这样我们后面调整的任务就是将这个双黑节点消除或者让他变成单黑节点

2.5.2.2.1 没有孩子： 删除黑节点（兄弟是黑色）
2.5.2.2.1.1 没有孩子： 删除黑节点（兄弟是黑色）兄弟至少有一个红孩子

这里注意：LL和RR是同种类型，LR和RL也是同一种类型

第一种情况：LL 变色+旋转

在这里插入图片描述

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

第二种情况：RR 变色+旋转

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

第三种情况：LR 变色+旋转

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

第四种情况：RL 变色+旋转

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

2.5.2.2.1.2 没有孩子： 删除黑节点（兄弟是黑色）兄弟的孩子都是黑色

在这里插入图片描述

在这里插入图片描述

（1）第一种情况

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

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

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

（2）第二种情况

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

（3）第三种情况

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

2.5.2.2.2 没有孩子： 删除黑节点（兄弟是红色）

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

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

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

2.5.3 删除的代码实现

代码如下（示例）：

//删除函数
bool Erase(const K& key)
{
    //(一)找到删除节点
    Node* cur = Find(key);
    //未找到返回false
    if (cur == nullptr)
    {
        return false;
    }
    //记录父节点
    Node* parent = cur->_parent;
    //用于标记实际的待删除结点及其父结点
    Node* delParent = nullptr;
    Node* delCur = nullptr;
    if (cur->_left == nullptr) //待删除结点的左子树为空
    {
        if (cur == _root) //待删除结点是根结点
        {
            _root = _root->_right; //让根结点的右子树作为新的根结点
            if (_root)
            {
                _root->_parent = nullptr;
                _root->_col = BLACK; //根结点为黑色
            }
            delete cur; //删除原根结点
            return true;
        }
        else
        {
            delParent = parent; //标记实际删除结点的父结点
            delCur = cur; //标记实际删除的结点
        }
    }
    else if (cur->_right == nullptr) //待删除结点的右子树为空
    {
        if (cur == _root) //待删除结点是根结点
        {
            _root = _root->_left; //让根结点的左子树作为新的根结点
            if (_root)
            {
                _root->_parent = nullptr;
                _root->_col = BLACK; //根结点为黑色
            }
            delete cur; //删除原根结点
            return true;
        }
        else
        {
            delParent = parent; //标记实际删除结点的父结点
            delCur = cur; //标记实际删除的结点
        }
    }
    else //待删除结点的左右子树均不为空
    {
        //替换法删除
        //寻找待删除结点右子树当中key值最小的结点作为实际删除结点
        Node* minParent = cur;
        Node* minRight = cur->_right;
        while (minRight->_left)
        {
            minParent = minRight;
            minRight = minRight->_left;
        }
        cur->_kv = minRight->_kv; //将待删除结点的键值改为minRight的键值
        delParent = minParent; //标记实际删除的父节点
        delCur = minRight; //标记实际删除的结点
    }
    //记录待删除结点及其父结点，便于后面删除
    Node* del = delCur;
    Node* delP = delParent;
    //(二)调整红黑树
    AdjustRBTree(delCur, delParent);
    //(三)进行实际删除
    DeleteNode(del, delP);
    return true;
}
void DeleteNode(Node* del, Node* delP)
{
    if (del->_left == nullptr) //实际删除结点的左子树为空
    {
        if (del == delP->_left) //实际删除结点是其父结点的左孩子
        {
            delP->_left = del->_right;
            //指向父节点
            if (del->_right)
                del->_right->_parent = delP;
        }
        else //实际删除结点是其父结点的右孩子
        {
            delP->_right = del->_right;
            if (del->_right)
                del->_right->_parent = delP;
        }
    }
    else //实际删除结点的右子树为空
    {
        if (del == delP->_left) //实际删除结点是其父结点的左孩子
        {
            delP->_left = del->_left;
            if (del->_left)
                del->_left->_parent = delP;
        }
        else //实际删除结点是其父结点的右孩子
        {
            delP->_right = del->_left;
            if (del->_left)
                del->_left->_parent = delP;
        }
    }
    delete del; //实际删除结点
}
void AdjustRBTree(Node* delCur, Node* delParent)
{
    if (delCur->_col == BLACK) //删除的是黑色结点
    {
        if (delCur->_left) //待删除结点有一个红色的左孩子（不可能是黑色）
        {
            delCur->_left->_col = BLACK; //将这个红色的左孩子变黑即可
        }
        else if (delCur->_right) //待删除结点有一个红色的右孩子（不可能是黑色）
        {
            delCur->_right->_col = BLACK; //将这个红色的右孩子变黑即可
        }
        else //待删除结点的左右均为空
        {
            while (delCur != _root) //可能一直调整到根结点
            {
                if (delCur == delParent->_left) //待删除结点是其父结点的左孩子
                {
                    Node* brother = delParent->_right; //兄弟结点是其父结点的右孩子
                    //情况一：brother为红色
                    if (brother->_col == RED)
                    {
                        delParent->_col = RED;
                        brother->_col = BLACK;
                        RotateL(delParent);
                        //需要继续处理
                        brother = delParent->_right; //更新brother
                    }
                    //情况二：brother为黑色，且其左右孩子都是黑色结点或为空
                    if (((brother->_left == nullptr) || (brother->_left->_col == BLACK))
                        && ((brother->_right == nullptr) || (brother->_right->_col == BLACK)))
                    {
                        brother->_col = RED;
                        if (delParent->_col == RED)
                        {
                            delParent->_col = BLACK;
                            break;
                        }
                        //需要继续处理
                        delCur = delParent;
                        delParent = delCur->_parent;
                    }
                    else
                    {
                        //情况三：brother为黑色，且其左孩子是红色结点，右孩子是黑色结点或为空
                        if ((brother->_right == nullptr) || (brother->_right->_col == BLACK))
                        {
                            brother->_left->_col = BLACK;
                            brother->_col = RED;
                            RotateR(brother);
                            //需要继续处理
                            brother = delParent->_right; //更新brother
                        }
                        //情况四：brother为黑色，且其右孩子是红色结点
                        brother->_col = delParent->_col;
                        delParent->_col = BLACK;
                        brother->_right->_col = BLACK;
                        RotateL(delParent);
                        break; //情况四执行完毕后调整一定结束
                    }
                }
                else //delCur == delParent->_right //待删除结点是其父结点的右孩子
                {
                    Node* brother = delParent->_left; //兄弟结点是其父结点的左孩子
                    //情况一：brother为红色
                    if (brother->_col == RED) //brother为红色
                    {
                        delParent->_col = RED;
                        brother->_col = BLACK;
                        RotateR(delParent);
                        //需要继续处理
                        brother = delParent->_left; //更新brother
                    }
                    //情况二：brother为黑色，且其左右孩子都是黑色结点或为空
                    if (((brother->_left == nullptr) || (brother->_left->_col == BLACK))
                        && ((brother->_right == nullptr) || (brother->_right->_col == BLACK)))
                    {
                        brother->_col = RED;
                        if (delParent->_col == RED)
                        {
                            delParent->_col = BLACK;
                            break;
                        }
                        //需要继续处理
                        delCur = delParent;
                        delParent = delCur->_parent;
                    }
                    else
                    {
                        //情况三：brother为黑色，且其右孩子是红色结点，左孩子是黑色结点或为空
                        if ((brother->_left == nullptr) || (brother->_left->_col == BLACK))
                        {
                            brother->_right->_col = BLACK;
                            brother->_col = RED;
                            RotateL(brother);
                            //需要继续处理
                            brother = delParent->_left; //更新brother
                        }
                        //情况四：brother为黑色，且其左孩子是红色结点
                        brother->_col = delParent->_col;
                        delParent->_col = BLACK;
                        brother->_left->_col = BLACK;
                        RotateR(delParent);
                        break; //情况四执行完毕后调整一定结束
                    }
                }
            }
        }
    }
}

三、源代码总结

代码如下（示例）：

#include<iostream>
using namespace std;
#include<string>


// 枚举值表⽰颜⾊
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:
	// ......

	// 旋转代码的实现跟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 = 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;
			 // g
			 // p u
			 if (parent == grandfather->_left)
			 {
				 Node* uncle = grandfather->_right;
				 if (uncle && uncle->_col == RED)
				 {
					 // u存在且为红 -》变⾊再继续往上处理
					 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;
				 // 叔叔存在且为红，-》变⾊即可
				 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;
	}

	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;
	}



	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);
	}

    //删除函数
    bool Erase(const K& key)
    {
        //(一)找到删除节点
        Node* cur = Find(key);
        //未找到返回false
        if (cur == nullptr)
        {
            return false;
        }
        //记录父节点
        Node* parent = cur->_parent;
        //用于标记实际的待删除结点及其父结点
        Node* delParent = nullptr;
        Node* delCur = nullptr;
        if (cur->_left == nullptr) //待删除结点的左子树为空
        {
            if (cur == _root) //待删除结点是根结点
            {
                _root = _root->_right; //让根结点的右子树作为新的根结点
                if (_root)
                {
                    _root->_parent = nullptr;
                    _root->_col = BLACK; //根结点为黑色
                }
                delete cur; //删除原根结点
                return true;
            }
            else
            {
                delParent = parent; //标记实际删除结点的父结点
                delCur = cur; //标记实际删除的结点
            }
        }
        else if (cur->_right == nullptr) //待删除结点的右子树为空
        {
            if (cur == _root) //待删除结点是根结点
            {
                _root = _root->_left; //让根结点的左子树作为新的根结点
                if (_root)
                {
                    _root->_parent = nullptr;
                    _root->_col = BLACK; //根结点为黑色
                }
                delete cur; //删除原根结点
                return true;
            }
            else
            {
                delParent = parent; //标记实际删除结点的父结点
                delCur = cur; //标记实际删除的结点
            }
        }
        else //待删除结点的左右子树均不为空
        {
            //替换法删除
            //寻找待删除结点右子树当中key值最小的结点作为实际删除结点
            Node* minParent = cur;
            Node* minRight = cur->_right;
            while (minRight->_left)
            {
                minParent = minRight;
                minRight = minRight->_left;
            }
            cur->_kv = minRight->_kv; //将待删除结点的键值改为minRight的键值
            delParent = minParent; //标记实际删除的父节点
            delCur = minRight; //标记实际删除的结点
        }
        //记录待删除结点及其父结点，便于后面删除
        Node* del = delCur;
        Node* delP = delParent;
        //(二)调整红黑树
        AdjustRBTree(delCur, delParent);
        //(三)进行实际删除
        DeleteNode(del, delP);
        return true;
    }
    void DeleteNode(Node* del, Node* delP)
    {
        if (del->_left == nullptr) //实际删除结点的左子树为空
        {
            if (del == delP->_left) //实际删除结点是其父结点的左孩子
            {
                delP->_left = del->_right;
                //指向父节点
                if (del->_right)
                    del->_right->_parent = delP;
            }
            else //实际删除结点是其父结点的右孩子
            {
                delP->_right = del->_right;
                if (del->_right)
                    del->_right->_parent = delP;
            }
        }
        else //实际删除结点的右子树为空
        {
            if (del == delP->_left) //实际删除结点是其父结点的左孩子
            {
                delP->_left = del->_left;
                if (del->_left)
                    del->_left->_parent = delP;
            }
            else //实际删除结点是其父结点的右孩子
            {
                delP->_right = del->_left;
                if (del->_left)
                    del->_left->_parent = delP;
            }
        }
        delete del; //实际删除结点
    }
    void AdjustRBTree(Node* delCur, Node* delParent)
    {
        if (delCur->_col == BLACK) //删除的是黑色结点
        {
            if (delCur->_left) //待删除结点有一个红色的左孩子（不可能是黑色）
            {
                delCur->_left->_col = BLACK; //将这个红色的左孩子变黑即可
            }
            else if (delCur->_right) //待删除结点有一个红色的右孩子（不可能是黑色）
            {
                delCur->_right->_col = BLACK; //将这个红色的右孩子变黑即可
            }
            else //待删除结点的左右均为空
            {
                while (delCur != _root) //可能一直调整到根结点
                {
                    if (delCur == delParent->_left) //待删除结点是其父结点的左孩子
                    {
                        Node* brother = delParent->_right; //兄弟结点是其父结点的右孩子
                        //情况一：brother为红色
                        if (brother->_col == RED)
                        {
                            delParent->_col = RED;
                            brother->_col = BLACK;
                            RotateL(delParent);
                            //需要继续处理
                            brother = delParent->_right; //更新brother
                        }
                        //情况二：brother为黑色，且其左右孩子都是黑色结点或为空
                        if (((brother->_left == nullptr) || (brother->_left->_col == BLACK))
                            && ((brother->_right == nullptr) || (brother->_right->_col == BLACK)))
                        {
                            brother->_col = RED;
                            if (delParent->_col == RED)
                            {
                                delParent->_col = BLACK;
                                break;
                            }
                            //需要继续处理
                            delCur = delParent;
                            delParent = delCur->_parent;
                        }
                        else
                        {
                            //情况三：brother为黑色，且其左孩子是红色结点，右孩子是黑色结点或为空
                            if ((brother->_right == nullptr) || (brother->_right->_col == BLACK))
                            {
                                brother->_left->_col = BLACK;
                                brother->_col = RED;
                                RotateR(brother);
                                //需要继续处理
                                brother = delParent->_right; //更新brother
                            }
                            //情况四：brother为黑色，且其右孩子是红色结点
                            brother->_col = delParent->_col;
                            delParent->_col = BLACK;
                            brother->_right->_col = BLACK;
                            RotateL(delParent);
                            break; //情况四执行完毕后调整一定结束
                        }
                    }
                    else //delCur == delParent->_right //待删除结点是其父结点的右孩子
                    {
                        Node* brother = delParent->_left; //兄弟结点是其父结点的左孩子
                        //情况一：brother为红色
                        if (brother->_col == RED) //brother为红色
                        {
                            delParent->_col = RED;
                            brother->_col = BLACK;
                            RotateR(delParent);
                            //需要继续处理
                            brother = delParent->_left; //更新brother
                        }
                        //情况二：brother为黑色，且其左右孩子都是黑色结点或为空
                        if (((brother->_left == nullptr) || (brother->_left->_col == BLACK))
                            && ((brother->_right == nullptr) || (brother->_right->_col == BLACK)))
                        {
                            brother->_col = RED;
                            if (delParent->_col == RED)
                            {
                                delParent->_col = BLACK;
                                break;
                            }
                            //需要继续处理
                            delCur = delParent;
                            delParent = delCur->_parent;
                        }
                        else
                        {
                            //情况三：brother为黑色，且其右孩子是红色结点，左孩子是黑色结点或为空
                            if ((brother->_left == nullptr) || (brother->_left->_col == BLACK))
                            {
                                brother->_right->_col = BLACK;
                                brother->_col = RED;
                                RotateL(brother);
                                //需要继续处理
                                brother = delParent->_left; //更新brother
                            }
                            //情况四：brother为黑色，且其左孩子是红色结点
                            brother->_col = delParent->_col;
                            delParent->_col = BLACK;
                            brother->_left->_col = BLACK;
                            RotateR(delParent);
                            break; //情况四执行完毕后调整一定结束
                        }
                    }
                }
            }
        }
    }



private:
	Node* _root = nullptr;
};
【C++之红黑树底层封装操作的详解+图解】
m0_69455439的博客
05-19 677
C++学习笔记023 --- set/map底层红黑树插入旋转操作详解+图解等知识
C++——红黑树（图片+动图详解）
2301_80687320的博客
08-11 991
在了解完平衡搜索二叉树的优势和应用后，我们学习了AVL树这种方案来实现它，但在前人们的不断使用和开辟，另一种更优的方案横空出世——红黑树。一、红黑树是什么？红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路 径会比其他路径长出俩倍，因而是接近平衡的。通过图片的观察，我们发红黑树有一下几个性质1、每个结点不是红色就是黑色；2、根节点是黑色；3、红色节点不能是连续两个；
C++ 红黑树 详细讲解
foodsx的博客
06-07 1271
C++ 红黑树 详细讲解
红黑树 图文详解与代码实现
qq_54831038的博客
09-01 1648
红黑树被应用于数据结构map/set的封装的底层，也应用于Linux的数据内核，在进程调度CFS，虚拟内存管理，共享内存slab等场景都有广泛应用。数据结构的角度看，（1）用于存储。无论数据是否平衡都可以在O（logN)的复杂度下完成 搜索、插入、删除操作。（2）用于排序。找到最小值和最大值红黑树黑色和红色 也可看成两种状态，红黑区分的状态中，可以根据实际需求添加业务逻辑。......
C++红黑树(图文详解)
qq_42433334的博客
06-14 2648
添加链接描述
详解红黑树插入的平衡调节
2402_86037826的博客
03-17 1022
图文详解红黑树插入结点的平衡调节
红黑树详解&实现 C++
qq_44486439的博客
07-18 453
红黑树 性质 红黑树是一棵二叉搜索树，它在每个节点上增加了一个存储位来表示节点的颜色，可以是RED或BLACK 通过对任何一条从根到叶子的简单路径上各个结点的颜色进行约束，红黑树确保没有一条路径会比其他路径长出两倍，因而近似于平衡，可以保证最坏情况下基本动态集合操作的时间复杂度为O(lgn) 红黑性质： 每个节点是黑色或红色 根节点是黑色的 每个叶节点都是黑色的 若一个节点是红色，则其两个子...
红黑树（万字图文详解）
originalHSL的博客
11-27 4089
本文讲解了红黑树的简单实现及其相关知识，希望对大家有所帮助！
图解红黑树
Dablelv 的博客专栏。
08-10 1994
1.红黑树简介 红黑树（Red Black Tree）是一种含有红黑结点并能自平衡二叉查找树，典型的用途是实现 map。 它必须满足下面规则： 规则1：每个结点要么是黑色，要么是红色。 规则2：根结点是黑色。 规则3：每个叶子结点（NIL）是黑色。 规则4：每个红色结点的两个子结点都是黑色。 规则5：任意一结点到每个叶子结点的路径都包含相同数量的黑结点。 记住上面的规则也不难，我们会发现黑色结点非常特殊，规则1即“非红即黑”，规则2和3即“首尾全黑”，规则4即“红子双黑”，规则5即“路径等黑”。 这些规则
IT笔试面试--红黑树详细解析，代码+图解
04-14
"红黑树详解" 红黑树是一种自平衡二叉查找树，它的统计性能要好于平衡二叉树（AVL 树），因此，红黑树在很多地方都有应用。在 C++ STL 中，很多部分（包括 set, multiset, map, multimap）应用了红黑树的变体（SGI ...
数据结构之二叉搜索树详解（附C++代码实现查找、插入、删除操作）
hestyle的博客
04-18 1772
  最近在分析分析红黑树时，感觉上来就挑最难的树结构之一进行分析，难度太大，所以特意写这篇二叉搜索树分析的博客作为铺垫。那么为啥挑二叉搜索树进行分析捏？其实红黑树也是一种更为复杂的二叉搜索树，建议阅读一下我的另外一篇博客 数据结构之二叉树、AVL树、红黑树、Trie树、B树、B+树、B*树浅析 。为了帮助大家理解红黑树，先写这篇博客分析二叉搜索树。下面将主要分析二叉搜索树的查找、插入、删除三种操作...
[c++高阶]红黑树的深度剖析
weixin_62196764的博客
11-06 755
到这里红黑树和AVL树的插入的模拟实现都已经全部详解完毕了，至于删除的话，有兴趣的可以自行了解一下，因为删除是非常复杂的。我们学插入的模拟实现，只是为了了解他的底层实现的相关原理，并不是自己去造一个轮子。拓展阅读：​​​​​​​图解：红黑树删除篇（一文读懂） - 知乎 (zhihu.com)【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树-CSDN博客。
C语言零基础第12讲：各类指针变量介绍与转移表应用
0基础编程小白的学习记录
08-06 810
正文开始。
将中频信号作为输入结合RF采样得到的I/Q信号进行cordic旋转的物理意义解释
m0_49540263的博客
08-08 425
这种配置利用CORDIC算法，将RF输入的I/Q数据，根据由DDC频率控制字驱动的、实时生成的NCO相位，进行高精度复数旋转（混频），其输出就是中心频率被搬移到零频（或低中频）的基带I/Q信号。输入是 (I_in, Q_in)，旋转角度 θ 由 NCO 提供（即相位累加器的当前输出值 Φ），输出就是下变频后的基带信号 (I_out, Q_out)。是采样周期），那么CORDIC的连续旋转操作就实现了输入信号频谱在频率轴上平移。将DDC的频率控制字配置作为CORDIC旋转的初始角度是整个设计的关键。
gRPC for C++ 实战全流程 —— 从零搭建到同步/异步服务
最新发布
人心有反复，好在山水有重逢。
08-09 177
定义了两个 RPC 接口：注册和登录。状态中创建新对象以处理后续请求。实现，有两种封装方式。
C语言popen函数详解：轻松执行Shell命令并处理输出
weixin_52734695的博客
08-06 1090
popen函数是C语言中一个简单而强大的工具，用于执行Shell命令并通过管道交互其输入输出。它在获取系统信息、过滤文件内容、执行脚本等场景中非常实用。然而，使用时需要注意安全问题（如命令注入）、资源管理（如关闭管道）以及平台差异。通过本文的讲解，相信你已经对popen函数的用法和注意事项有了深入了解。在实际开发中，合理使用popen可以大大简化命令执行相关的任务。如果你有更多关于C语言或系统编程的问题，欢迎随时探讨！
TSMaster-C小程序使用
weixin_45967696的博客
08-07 381
本文介绍了使用同星TSMaster工具（推荐32位版本）通过C小程序控制CAN报文收发的方法。主要内容包括：1）在C小程序中设计继电器控制逻辑，实现0-39号继电器循环开关（1秒间隔）；2）演示了通过TCAN结构体发送CAN报文（ID 0x240D）控制继电器的代码实现；3）说明TCAN结构体定义（可在TSMaster.h查看），包含通道索引、ID、数据等属性，支持标准/扩展帧设置。该方案便于开发人员通过嵌入式代码灵活控制CAN设备。
PYQT学习笔记：signal 和 slot（信号与槽）
qq_52251819的博客
08-05 805
通过 button.clicked.connect(on_button_clicked) 语句将信号与槽关联。当按钮被点击（发出 clicked 信号）时，执行 on_button_clicked 函数。在示例中，on_button_clicked() 就是一个槽函数，用于处理按钮点击事件。在示例中，button.clicked 就是一个信号，表示 “按钮被点击” 这个事件。每当点一次“统计”按钮，终端就会打印一次“按钮被点击了”支持一个信号连接多个槽，或多个信号连接同一个槽。槽是用于接收信号并处理的。
GESP2023年12月认证C++一级( 第三部分编程题（2）小杨报数）
汉克老师的博客
08-08 269
GESP2023年12月认证C++一级( 第三部分编程题（2）小杨报数）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值