C++ | 红黑树

目录

红黑树的概念

红黑树的性质

红黑树节点的定义

红黑树的基本框架

红黑树的插入操作

1.按照二叉搜索树的规则进行插入新节点

[2. 新节点插入后，红黑树的变色以及旋转](#2. 新节点插入后，红黑树的变色以及旋转)

[情况1： cur为红，p为红，g为黑，u存在且为红](#情况1： cur为红，p为红，g为黑，u存在且为红)

情况2：cur为红，p为红，g为黑，u不存在或者u为黑

情况3：cur为红，p为红，g为黑，u不存在/u存在且为黑

红黑树的删除

1.被删除节点无子节点

2.被删除节点只有一个子节点

3.被删除节点有两个子节点

红黑树与AVL树的比较

红黑树的应用

---

红黑树的概念

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

同是二叉搜索平衡树，但是AVL树控制的比红黑树严格的多，AVL树要是每个节点的平衡因子绝对值不超过1，就会导致不断的去旋转调整，付出相对较高的代价，而这里红黑树更像是一种近似平衡，条件没有这么苛刻。

---

红黑树的性质

1. 每个结点不是红色就是黑色
2. 根节点是黑色的
3. 如果一个节点是红色的，则它的两个孩子结点是黑色的(不能有连续的红色节点)
4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点
5. 每个叶子结点都是黑色的**(此处的叶子结点指的是空结点)**

那么，为什么满足上面的特性，红黑树就能保证：其最长路径中节点个数不会超过最短路径中节点个数的两倍？

因为最短路径是全黑节点（数量 = 黑色高度bh），最长路径是红黑交替（红节点数≤黑节点数），因此最长路径≤2×bh=2× 最短路径。

---

红黑树节点的定义

红黑树的节点跟AVL二叉平衡搜索树的节点有些类似，不同的是，后者是借助平衡因子来判断是否需要调整搜索树，而红黑树则是根据节点的颜色来判断是否需要调整搜索树。

enum Color
{
    RED,
    BLACK
};

template<class T>
struct RBTreeNode
{
    _RBTreeNode<T>* _left = nullptr;
    _RBTreeNode<T>* _right = nullptr;
    _RBTreeNode<T>* _parent = nullptr;

    Color _col = RED;
    T _data;

    _RBTreeNode(const T& data)
        :_data(data)
    {}
};

为什么插入的节点在构造函数这里要处理成红色？

如果处理成黑色，则一定导致新插入节点的那条路径多出一个黑色节点，不再满足各个路径黑色节点个数相同的性质，一定破坏性质4，此时很难维护。

如果处理成红色，则可能父亲节点也是红色，此时就出现了连续的红色节点，破坏性质3，不过此时我们向上调整即可，但如果父亲节点是黑色，那就无需操作了，不违反任何性质。
综合利弊，插入黑色节点一定会破坏性质4，而插入红色节点可能破坏性质3，因此处理成红色为宜。

---

红黑树的基本框架

有人可能好奇，为什么节点定义时，模板只有一个class T，而树的定义时，却有class K, class V, class KeyOfT

首先，节点的定义，我们说set、map的底层是红黑树嘛，set只有key，而map是<key, value>，但是在我写的"C++ STL | set、multiset"中说了，set也能看作是<key, key>，因此节点的定义的模板只用一个class T即可。

其次，树的定义，class K, class V, class KeyOfT，先说KeyOfT，这是key对比的仿函数，C++ STL中默认是less<T>，即key1 < key2时进行替换，通过迭代器遍历红黑树打印出来是升序的。

那么，class K, class V呢，如果是用来做map的底层容器的话，可以理解，刚好<key, value>嘛，那如果我要同时支持set呢？则K和V都是key的类型。那怎么传参给RBTreeNode???其实这里换个思路就好了，无论是set还是map，class K都传key的类型，而class V，则set传key的类型，map传

pair<key, value>即可。

那么，为什么RBTree的模板class K, class V为什么不直接设计为一个class T呢？set直接传key的类型，map直接传<key, value>的类型？这是为了方便迭代器的设计，以及方便仿函数对key的比较，因此单独把key拿出来有利于提高开发效率，以及方便后续的维护。

// set -> RBTree<K, K, SetOfT> 
// map -> RBTree<K, pair<K, V>, MapOfT>
template<class K, class V, class KeyOfT>
class RBTree
{
    typedef RBTreeNode<V> Node;
public:
    // ...

private:
    Node* _root = nullptr;
};

不过，为了方便理解，我们以RBTree的模板参数只有一个class T为例子进行讲解。

---

红黑树的插入操作

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

1.按照二叉搜索树的规则进行插入新节点

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);
    // 进行变换操作使树满足红黑树性质
    // ... 缺少变换操作的代码 ...

    // 插入成功
    return true;
}

cur为当前需要插入的结点，默认为红色，如果当前的树为空树，那么插入的结点则是根节点，需要将颜色更改为黑色。

2. 新节点插入后，红黑树的变色以及旋转

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

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

情况1： cur为红，p为红，g为黑，u存在且为红

解决方式：将p,u改为黑，g改为红，如果g为根节点，则将g改为黑，否则将g当成cur向上调整

为什么当g不为根节点时，调整完后还需要将g当成cur继续向上调整？

因为当g不为根节点时，g被调整为红色，如果g的双亲结点也为红色的话，就跟性质3冲突了，因此需要将g当成cur继续向上调整

情况2：cur为红，p为红，g为黑，u不存在或者u为黑

解决方式：
p为g的左孩子，cur为p的左孩子，则进行右单旋转；相反， p为g的右孩子，cur为p的右孩子，则进行左单旋转。 p、g变色--p变黑，g变红

因为g的位置被调整为黑色，不用担心调整完后会与性质3冲突，因此不需要再向上调整

情况3：cur为红，p为红，g为黑，u不存在/u存在且为黑

解决方式：
p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；相反， p为g的右孩子，cur为p的左孩子，则针对p做右单旋转。
转换完之后，则变成了 情况2

综上，参考代码如下：

	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为新插入的节点，接下来针对这一个节点进行讨论变换(颜色)就可以了

		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;
			if (grandfather->_left == parent)
			{
				Node* uncle = grandfather->_right;
				// 情况1：u存在且为红，变色处理，并继续往上处理
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else // 情况2+3：u不存在/u存在且为黑，旋转+变色
				{
					//     g
					//   p   u
					// c 
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//     g
						//   p   u
						//     c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						//parent->_col = RED;
						grandfather->_col = RED;
					}

					break;
				}
			}
			else // (grandfather->_right == parent)
			{
				//    g
				//  u   p
				//        c
				Node* uncle = grandfather->_left;
				// 情况1：u存在且为红，变色处理，并继续往上处理
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else // 情况2+3：u不存在/u存在且为黑，旋转+变色
				{
					//     g
					//  u     p
					//          c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						grandfather->_col = RED;
						parent->_col = BLACK;
					}
					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;

		Node* ppnode = parent->_parent;

		subR->_left = parent;
		parent->_parent = subR;

		if (ppnode == nullptr)
		{
			_root = subR;
			_root->_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;

		Node* ppnode = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;

		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subL;
			}
			else
			{
				ppnode->_right = subL;
			}
			subL->_parent = ppnode;
		}
	}

---

红黑树的删除

同AVL树大致，分为三种情况：

1.被删除节点无子节点

如果待删除节点是叶子节点，则直接删除该节点即可。

如果待删除节点是根节点，则删除根节点并将根节点设置为 null。

2.被删除节点只有一个子节点

如果待删除节点只有一个子节点，可以用其子节点来替代被删除的节点，并保持红黑树的性质：

• 如果待删除节点是红色节点，则用其子节点来代替该节点，并不会影响树的性质；
• 如果待删除节点是黑色节点，则需要根据其子节点和父节点的颜色组合，进行颜色变换并进行旋转操作，使树重新满足红黑树的性质。

3.被删除节点有两个子节点

如果待删除节点有两个子节点，需要先寻找其后继节点（即右子树中最小的节点或左子树中最大的节点），将其替换到待删除节点的位置，然后再删除该后继节点。

在实现过程中，需要注意以下几点：

• 对于黑色节点的处理，需要进行额外的操作，以保证树的性质；
• 在红黑树中，每个节点都带有颜色属性，因此需要在代码中对颜色进行判断和处理；
• 删除节点或替换节点后，重新插入到树上的节点也需要进行变换操作，以保证树的性质。

下面是一个实现删除红黑树节点的代码示例：

    bool erase(const T& val) {
        // 1. 找到待删除节点
        Node* delNode = find(val);
        if (!delNode) return false;

        // 2. 备份待删节点颜色（黑色才需要修复）
        Color delColor = delNode->color;
        Node* replaceNode = nullptr; // 替换节点（用于修复）

        // 场景1：无子节点（叶子）
        if (!delNode->left && !delNode->right) {
            replaceNode = nullptr;
            removeNode(delNode, replaceNode);
        }
        // 场景2：只有一个子节点
        else if (!delNode->left || !delNode->right) {
            replaceNode = delNode->left ? delNode->left : delNode->right;
            removeNode(delNode, replaceNode);
        }
        // 场景3：有两个子节点（找后继节点替换）
        else {
            // 找右子树最小节点（后继）
            Node* successor = findMin(delNode->right);
            delColor = successor->color; // 后继节点的颜色（修复用）
            replaceNode = successor->right; // 后继只有右孩子/空

            // 替换后继节点到待删位置
            if (successor->parent == delNode) {
                if (replaceNode) replaceNode->parent = successor;
            } else {
                removeNode(successor, successor->right);
                successor->right = delNode->right;
                delNode->right->parent = successor;
            }

            removeNode(delNode, successor);
            successor->left = delNode->left;
            delNode->left->parent = successor;
            successor->color = delNode->color; // 继承颜色
        }

        // 3. 修复红黑树性质（仅删除黑色节点时需要）
        if (delColor == BLACK) {
            fixAfterErase(replaceNode);
        }

        delete delNode;
        return true;
    }

在该示例中，Find 函数用于查找要删除的节点，如果未找到则返回 false。如果待删除节点有两个子节点，则需要寻找其后继节点，并将后继节点的值赋给待删除节点。然后，判断待删除节点的颜色，如果为黑色节点，则需要进行额外的操作以维护树的性质。最后，调用 Replace 函数删除节点，并返回 true 表示删除成功。

---

红黑树与AVL树的比较

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

维度	AVL 树	红黑树
平衡规则	严格平衡（高度差≤1）	松弛平衡（最长路径≤2× 最短路径）
核心优势	查找效率略高	插入 / 删除效率高、实现简单、空间开销小
核心劣势	插入 / 删除调整成本高、实现复杂	查找效率略低（可忽略）
适用场景	读多写少	写多读少、通用场景

---

红黑树的应用

红黑树是一种高效的平衡二叉搜索树，具有较好的查找、插入和删除性能。因此，它在许多方面都有广泛的应用。

1. C++ STL中的map和set容器：STL库中的map和set容器都是基于红黑树实现的，它们提供了快速的键值查找和排序的功能。
2. 数据库索引结构：许多数据库系统采用B+树或B树作为索引结构，但也有一些数据库系统采用红黑树作为索引结构来加速数据的查找。
3. 操作系统调度：操作系统CPU调度算法中也使用了红黑树。例如，在Linux内核中，用红黑树来维护进程的优先级队列。
4. 编译器标识符表：编译器在分析代码时需要维护一个标识符表来存放变量、函数等信息。红黑树可以作为标识符表的底层数据结构，提高符号查找的效率。
5. 计算机网络路由表：路由表是计算机网络中进行数据包转发的重要组成部分之一。为了快速查找路由路径，许多路由器会使用红黑树等数据结构来维护路由表。