《数据结构、算法与应用C++语言描述》-红黑树的C++实现-百万级数据量测试通过

已于 2024-01-10 09:53:17 修改
阅读量1.4k 收藏 16
点赞数 24
分类专栏： 数据结构、算法与应用 C++语言描述学习笔记 文章标签： 数据结构 算法 c++
于 2024-01-09 21:18:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44410704/article/details/135490013
版权

红黑树

完整可编译运行代码见仓库：GitHub - Jasmine-up/Data-Structures-Algorithms-and-Applications/_35Red black tree。
如有问题请在评论区指出。另外，Github仓库会根据我的学习情况持续更新，欢迎大家点star，谢谢。

基本概念

红-黑树（red-black tree）：树中每一个节点的颜色或者是黑色或者是红色。每一个空指针用一个外部节点代替。红黑树是一种二叉搜索树。

基于节点特点的等价

  • RB1：根节点和所有外部节点都是黑色。
  • RB2：在根至外部节点路径上，没有连续两个节点是红色。
  • RB3：在所有根至外部节点的路径上，黑色节点的数目都相同。

基于指针颜色的等价：从父节点指向黑色孩子的指针是黑色的，从父节点指向红色孩子的指针是红色的。

  • RB1’：从内部节点指向外部节点的指针是黑色的。
  • RB2’：在根至外部节点路径上，没有两个连续的红色指针。
  • RB3’：在所有根至外部节点路径上，黑色指针的数目都相同。

注意，如果知道指针的颜色，就能推断节点的颜色，反之亦然。

举例

在图15-10的红-黑树中，阴影的方块是外部节点，阴影的圆圈是黑色节点，白色圆圈是红色节点，粗线是黑色指针，细线是红色指针。注意，在每一条根至外部节点的路径上，都有两个黑色指针和三个黑色节点（包括根节点和外部节点），且不存在两个连续的红色节点或指针。

在这里插入图片描述

节点的阶：是从该节点到一外部节点的路径上黑色指针的数量，外部节点的阶是0。

定理

定理15-1设从根到外部节点的路径长度（length）是该路径上的指针数量。如果P和 Q是红-黑树中的两条从根至外部节点的路径，那么 l e n g t h ( P ) ≤ 2 l e n g t h ( Q ) length(P)\leq 2length(Q) length(P)≤2length(Q)。

证明：在红黑树中，指向外部节点的指针是黑色，没有两个连续的红色指针，但是可以有连续的黑色指针，如果一条路径都是黑色指针，另一条路径是红色黑色指针交叉，这样就可得到极限情况，也就是 l e n g t h ( P ) = 2 l e n g t h ( Q ) length(P)=2length(Q) length(P)=2length(Q)。

定理15-2令h是一棵红-黑树的高度（不包括外部节点），n是树的内部节点数量，而 r是根节点的阶，则

  • 1） h ≤ 2 r h \leq 2r h≤2r。
  • 2） n ≥ 2 r − 1 n\geq 2^r-1 n≥2r−1。
  • 3） h ≤ 2 l o g 2 ( n + 1 ) h\leq 2log_2(n+1) h≤2log2​(n+1)。

红黑树的描述

外部节点使用空指针描述。对于每个节点，需要存储左孩子、右孩子、父亲节点的指针，对于颜色可以存储该节点的颜色或指向它的两个孩子的指针颜色。存储每个节点的颜色只需要附加一位，而存储每个指针的颜色则需要两位。选择哪种方案可根据实际需求决定。

搜索

假设要查找关键字为theKey的元素。先从根开始查找。如果根为空，那么搜索树不包含任何元素，即查找失败。如果不空，则将 theKey与根的关键字相比较。如果 theKey小，那么就不必在右子树中查找，只要查找左子树。如果theKey大，则正好相反，只需查找右子树。如果 theKey等于根的关键字，则查找成功。时间复杂度为O(logn)。

这个和二叉搜索树的查找是一样的。

AVL树是高度最小的，因此，在以搜索操作为主的应用中，在最坏情况下AVL树的时间复杂度是最优的。

插入

以下思路是普通二叉搜索树的插入方法，红黑树需要调整是否平衡。

假设要在二叉搜索树中插人一个新元素thePair，首先要通过查找来确定，在树中是否存在某个元素，其关键字与thePair.first 相同。如果搜索成功，那么就用 thePair.second 替代该元素的值。如果搜索不成功，那么就在搜索中能找到键值与thePair.first相近的节点pp，当thePair.second < pp.second时，将thePair作为pp的左孩子；反之，将thePair作为pp的右孩子。在插入元素后，treeSize++。

对插入的新元素，需要上色。如果插人前的树是空的，那么新节点是根节点，颜色应是黑色（参看特征RB1）。假设插入前的树是非空的。

如果新节点的颜色是黑色，那么在从根到外部节点的路径上，将有一个特殊的黑色节点作为新节点的孩子。如果新节点是红色，那么可能出现两个连续的红色节点。把新节点赋为黑色将肯定不符合RB3，而把新节点赋为红色则可能违反，也可能符合 RB2，因此，应将新节点赋为红色。

如果将新节点赋为红色而引起特征 RB2的破坏，我们就说树的平衡被破坏了。不平衡的类型可以通过检查新节点u、其父节点pu及祖父节点gu来确定。RB2被破坏后的情况便是有两个连续的红色节点：一个是u，另一个一定是它的父节点，因此pu存在。因为pu是红色的，它不可能是根（根据特征RB1），所以u必定有一个祖父节点gu，并且是黑色的（根据特征RB2）。

LLb类型不平衡：当pu是gu的左孩子，u是pu的左孩子且gu的另一个孩子是黑色时（这另一个可以是外部节点）。

LLr类型不平衡：当pu是gu的左孩子，u是pu的左孩子且gu的另一个孩子是红色时（这另一个可以是外部节点）。

LRb类型不平衡：当pu是gu的左孩子，u是pu的右孩子且gu的另一个孩子是黑色时（这另一个可以是外部节点）。

LRr类型不平衡：当pu是gu的左孩子，u是pu的右孩子且gu的另一个孩子是红色时（这另一个可以是外部节点）。

RRb类型不平衡：当pu是gu的右孩子，u是pu的右孩子且gu的另一个孩子是黑色时（这另一个可以是外部节点）。

RRr类型不平衡：当pu是gu的右孩子，u是pu的右孩子且gu的另一个孩子是红色时（这另一个可以是外部节点）。

RLb类型不平衡：当pu是gu的右孩子，u是pu的左孩子且gu的另一个孩子是黑色时（这另一个可以是外部节点）。

RLr类型不平衡：当pu是gu的右孩子，u是pu的左孩子且gu的另一个孩子是红色时（这另一个可以是外部节点）。

XYr（X和Y既可以是L，也可以是R）类型的不平衡可以通过改变颜色来处理，而 XYb类型则需要旋转。当节点gu被改变颜色时，它和上一层的节点可能破坏了RB2特性。这时的不平衡需要重新分类，而且u变为gu，然后再次进行转换。旋转结束后，不再违反RB2特性，因此不需要再进行其他操作。

举例：黑色节点用阴影表示，红色节点没有阴影。加粗指针是黑色指针，较细指针是红色指针。

LLr型与LRr型不平衡调整：例如，在图15-11a中，gu是黑色，而pu和u是红色。gu的两个指针是红色。 g u R gu_R guR​是gu的右子树， p u R pu_R puR​是pu的右子树。**LLr 和 LRr颜色调整需要将pu和 gu的右孩子由红色改为黑色。另外，如果gu不是根，还要将gu的颜色由黑色改为红色。如果gu是根节点，那么颜色不变，这时，所有从根至外部节点路径上的黑色节点数量都增1。**如果将 gu的颜色改为红色而引起了不平衡，那么gu就变成了新的u节点，它的双亲就变成了新的pu，它的祖父节点就变成了新的gu，这时需要继续恢复平衡。如果gu是根节点或者gu节点的颜色改变没有违反规则RB2，那么工作就完成了。

在这里插入图片描述

LLb型和LRb型不平衡调整：图15-12是处理LLb 和 LRb不平衡时所做的旋转。在图15-12a 和图15-12b中，pu是 p u L pu_L puL​的根。注意，这些旋转与AVL树的插人操作所需要的LL（见图15-4）和LR（见图15-5所示）旋转有相似之处。指针的改变是相同的，但是，在LLb旋转中，不仅要改变指针，还要将gu的颜色由黑色改为红色，将pu的颜色由红色改为黑色。在LRb旋转中，需要将u的颜色由红色改为黑色，将gu的颜色由黑色改为红色。

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

删除

使用普通二叉搜索树的删除元素方法，三种情况：

1）p是树叶；

要删除的节点是叶节点。存储叶节点到temp，将叶节点的父节点的左孩子置为nullptr，释放叶节点temp空间。若是根节点，直接释放根节点空间，令根为 nullptr。

2）p只有一棵非空子树；

要删除的节点p只有一棵子树。如果p没有父节点（即p是根节点），则p的唯一子树的根节点成为新的搜索树的根节点。如果p有父节点pp，则修改pp的指针域，使得它指向p的唯一孩子，然后释放节点p。

3）p有两棵非空子树。

先将该节点的元素替换为它的左子树的最大元素或右子树的最小元素，然后把替换元素的节点删除。本文使用左子树的最大元素替换。

要在一个节点的左子树中查找关键字最大的元素，先移动到左子树的根，然后沿着右孩子指针移动，直到右孩子指针为nullptr的节点为止。类似地，要在一个节点的右子树中查找关键字最小的元素，先移动到右子树的根，然后沿着左孩子指针移动，直到左孩子指针为nullptr的节点为止。

调整红黑树

在红黑树中，如果删除的节点是红色节点，那么删除节点后依然满足红黑树特性，不需要重新调整平衡；如果删除的节点是黑色节点，则可能会出现违反RB3的情况。令y是替代被删除节点的节点，也就是y被删除节点的父节点新指向的节点。

当违反 RB3的情况出现时，以y为根的子树缺少一个黑色节点（或一个黑色指针），因此，从根至y子树的外部节点的路径与从根至其他外部节点的路径相比，前者所包含的黑色节点数量比后者的要少一个，这时的树是不平衡的。

不平衡的类型可以根据y的父节点py和兄弟节点v的特点来划分。当y是py的右孩子时，不平衡是R型的，否则是L型的。通过观察可以得知，如果y缺少一个黑色节点，那么v就肯定不是外部节点。如果v是一个黑色节点，那么不平衡是Lb或Rb型的；而当v是红色节点时，不平衡是Lr或Rr型的。首先考察Rb型的不平衡。Lb型不平衡的处理与之相似。根据v的红色孩子的数量，把Rb型不平衡细分为三种情况：Rb0、Rb1和Rb2。

情况一：y是py的右孩子时且v是黑色节点时，不平衡类型为Rb型，可以根据v的红色孩子数量分为三种情况：Rb0、Rb1和Rb2。

如图15-15，是Rb0型的不平衡，如果py在改变前是黑色的，那么颜色的改变将导致以py为根的子树缺少一个黑色节点。在图15-15b中，从根至v的外部节点路径上，黑色节点数量也减少了一个。因此，颜色改变后，无论是从根到v的外部节点的路径，还是从根到y的外部节点的路径，都会缺少一个黑色节点。如果py是整棵红-黑树的根，那么就不需要再做其他工作，否则，py就成新的y，y的不平衡需要重新划分，并且在新的y点需要再进行调整。

若改变颜色前py是红色，则从根到y的外部节点的路径上，黑色节点数量增加了一个，而从根到v的外部节点的路径上，黑色节点数量没有改变。整棵树达到平衡。

在这里插入图片描述

当不平衡类型是Rb1和Rb2时，需要进行旋转，如图15-16所示。在图中，带阴影的节点既可能是红色，也可能是黑色。这种节点的颜色在旋转后不会发生变化。因此，图15-16b中，子树的根在旋转前和旋转后，颜色保持不变——图15-16b中v的颜色与图15-16a 中py的颜色是一样的。可以证明，在旋转后，从根至y的外部节点的路径上，黑色节点（黑色指针）数量增加一个，而从根至其他外部节点路径上，黑色节点的数量没有变化。旋转使树恢复了平衡。

在这里插入图片描述

情况二：y是py的右孩子时且v是红色节点时，不平衡类型为Rr型，可以根据v的右孩子的红色孩子数量分为三种情况：Rr0、Rr1和Rr2。都可以通过一次旋转获得平衡。

由于y中缺少一个黑色节点并且v节点是红色，所以 v L v_L vL​和 v R v_R vR​都至少有一个黑色节点不是外部节点，因此，v的孩子都是内部节点。以下是这三种情况的旋转方法。

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

情况三：y是py的左孩子时且v是黑色节点时，不平衡类型为Lb型，可以根据v的红色孩子数量分为三种情况：Lb0、Lb1和Lb2。

Lb型的解决方案与Rb型的解决方案是基于y节点的父亲节点的完全镜像。

情况四：y是py的左孩子时且v是红色节点时，不平衡类型为Lr型，可以根据v的红色孩子数量分为三种情况：Lr0、Lr1和Lr2。

Lr型的解决方案与Rr型的解决方案是基于y节点的父亲节点的完全镜像。

代码

main.cpp

/*
Project name :			_35Red_black_tree
Last modified Date:		2024年1月5日21点00分
Last Version:			V1.0
Descriptions:			main()主函数
*/
#include "RedBlackTree.h"

int main() {
    RedBlackTreeTest();
    return 0;
}

RedBlackTree.h

/*
Project name :			_35Red_black_tree
Last modified Date:		2024年1月6日18点17分
Last Version:			V1.0
Descriptions:			红黑树模板类
*/

#ifndef _35RED_BLACK_TREE_REDBLACKTREE_H
#define _35RED_BLACK_TREE_REDBLACKTREE_H

#include "RedBlackTreeNode.h"
#include "dictionary.h"
#include <stack>

void RedBlackTreeTest();

using namespace std;

template<class K, class E>
class RedBlackTree : public dictionary<K, E> {
public:
    RedBlackTree() {
        root = nullptr;
        treeSize = 0;
    }

    [[nodiscard]] bool empty() const { return treeSize == 0; }

    [[nodiscard]] int size() const { return treeSize; }

    pair<K, E> *find(K theKey) const;

    void insert(pair<K, E> &thePair);

    void erase(K theKey);

    /*中序遍历二叉树，使用函数指针的目的是是的本函数可以实现多种目的*/
    void inOrder(void(*theVisit)(RedBlackTreeNode<pair<K, E>> *)) {
        visit = theVisit;
        /*是因为递归，所以才要这样的*/
        inOrder(root);/*这里调用的是静态成员函数inOrder()*/
    }

    /*中序遍历---输出endl*/
    void inOrderOutput() {
        inOrder(output);
        cout << endl;
    }

    /*前序遍历二叉树，使用函数指针的目的是是的本函数可以实现多种目的*/
    void preOrder(void(*theVisit)(RedBlackTreeNode<pair<K, E>> *)) {
        visit = theVisit;
        int num = 0;
        /*是因为递归，所以才要这样的*/
        preOrder(root, num);/*这里调用的是静态成员函数preOrder()*/
        cout << "num = " << num << endl;
    }

    /*中序遍历---输出endl*/
    void preOrderOutput() {
        preOrder(output);
        cout << endl;
    }
    bool ISRBTree();

private:
    RedBlackTreeNode<pair<K, E>> *root;// 指向根的指针
    int treeSize;// 树的结点个数
    static void (*visit)(RedBlackTreeNode<pair<K, E>> *);//是一个函数指针,返回值为void 函数参数为binaryTreeNode<pair<K, E>>*
    static void output(RedBlackTreeNode<pair<K, E>> *t) { cout << *t << endl; }

    static void inOrder(RedBlackTreeNode<pair<K, E>> *t);

    static void preOrder(RedBlackTreeNode<pair<K, E>> *t, int& num);

    void rotateLL(RedBlackTreeNode<pair<K, E>> *&x);

    void rotateLR(RedBlackTreeNode<pair<K, E>> *&x);

    void rotateRR(RedBlackTreeNode<pair<K, E>> *&x);

    void rotateRL(RedBlackTreeNode<pair<K, E>> *&x);

    void rotateRr1_2and2(RedBlackTreeNode<pair<K, E>> *&pp);

    void rotateLr1_2and2(RedBlackTreeNode<pair<K, E>> *&pp);

    bool _ISRBTree(RedBlackTreeNode<pair<K, E> > * root, int count, int BlackCount);
};

/*私有静态成员初始化*/
/*这里是静态函数指针成员的初始化，不初始化会引发LINK错误*/
template<class K, class E>
void (*RedBlackTree<K, E>::visit)(RedBlackTreeNode<pair<K, E>> *) = 0;      // visit function

/*中序遍历 递归*/
template<class K, class E>
void RedBlackTree<K, E>::inOrder(RedBlackTreeNode<pair<K, E>> *t) {
    if (t != nullptr) {
        inOrder(t->leftChild);/*中序遍历左子树*/
        visit(t);/*访问树根*/
        inOrder(t->rightChild);/*中序遍历右子树*/
    }
}

/*前序遍历 递归*/
template<class K, class E>
void RedBlackTree<K, E>::preOrder(RedBlackTreeNode<pair<K, E>> *t, int& num) {
    if (t != nullptr) {
        visit(t);/*访问树根*/
        num++;
        preOrder(t->leftChild, num);/*中序遍历左子树*/
        preOrder(t->rightChild, num);/*中序遍历右子树*/
    }
}

/*  查找元素
 *  输入：theKey表示需要查找元素的键值
 *  输出：键值为theKey的节点的pair地址
 *  时间复杂度：O(logn)，n表示节点个数
 */
template<class K, class E>
pair<K, E> *RedBlackTree<K, E>::find(K theKey) const {
    // 返回值是匹配数对的指针
    // 如果没有匹配的数对，返回值为nullptr
    // p从根节点开始搜索，寻找关键字等于theKey的一个元素
    RedBlackTreeNode<pair<K, E> > *p = root;
    while (p != nullptr)
        // 检查元素 p->element
        if (theKey < p->element.first)
            p = p->leftChild;
        else if (theKey > p->element.first)
            p = p->rightChild;
        else // 找到匹配的元素
            return &p->element;

    // 没找到匹配的元素
    return nullptr;
}

/*
 *  LL旋转
 *  输入：x是第一个L的父亲节点，插入元素和删除元素都会用到
 *  输出：void
 *  时间复杂度：O(1)
 *  注意事项：执行本函数前后x指向的元素会改变为新的该子树的根节点
 */
template<class K, class E>
void RedBlackTree<K, E>::rotateLL(RedBlackTreeNode<pair<K, E>> *&x) {
    // 记录祖父节点的父亲节点
    RedBlackTreeNode<pair<K, E>> *Parent = x->parent;
    RedBlackTreeNode<pair<K, E>> *b = x->leftChild;
    x->leftChild = b->rightChild;
    if(b->rightChild)
        b->rightChild->parent = x;

    b->rightChild = x;
    // x的父亲节点变为b
    x->parent = b;
    // b的父亲节点变为原来x的父亲节点
    b->parent = Parent;
    // 这里就是原来祖父节点的父亲现在需要作为b的父亲，前提是祖父节点的父亲存在
    if (Parent != nullptr) {
        if (x == Parent->leftChild)
            Parent->leftChild = b;
        else
            Parent->rightChild = b;
    } else
        root = b;// 祖父节点如果没有父亲的话就是根节点
    x = b;// b节点将替换x节点
}

/*
 *  RR旋转
 *  输入：x表示第一个R的父亲节点，在插入和删除时都会用到
 *  输出：void
 *  时间复杂度：O(1)
 *  注意事项：执行本函数前后x指向的元素会改变为新的该子树的根节点
 */
template<class K, class E>
void RedBlackTree<K, E>::rotateRR(RedBlackTreeNode<pair<K, E>> *&x) {
    // 记录祖父节点的父亲节点
    RedBlackTreeNode<pair<K, E>> *Parent = x->parent;
    RedBlackTreeNode<pair<K, E>> *b = x->rightChild;
    x->rightChild = b->leftChild;
    if(b->leftChild)
        b->leftChild->parent = x;

    b->leftChild = x;
    x->parent = b;// x的父亲节点为b
    // b的父亲节点为祖父节点的父亲节点
    b->parent = Parent;
    // 这里就是原来祖父节点的父亲现在需要作为b的父亲，前提是祖父节点的父亲存在
    if (Parent != nullptr) {
        if (x == Parent->leftChild)
            Parent->leftChild = b;
        else
            Parent->rightChild = b;
    } else
        root = b;// 祖父节点如果没有父亲的话就是根节点
    x = b;
}

/*
 *  LR旋转
 *  输入：x表示L的父亲节点，插入元素和删除元素时都会用到
 *  输出：void
 *  时间复杂度：O(1)
 *  注意事项：执行本函数前后x指向的元素会改变为新的该子树的根节点
 */
template<class K, class E>
void RedBlackTree<K, E>::rotateLR(RedBlackTreeNode<pair<K, E>> *&x) {
    rotateRR(x->leftChild);
    rotateLL(x);
}

/*
 *  RL旋转
 *  输入：x表示R的父亲节点，插入元素和删除元素都会用到
 *  输出：void
 *  时间复杂度：O(1)
 *  注意事项：执行本函数前后x指向的元素会改变为新的该子树的根节点
 */
template<class K, class E>
void RedBlackTree<K, E>::rotateRL(RedBlackTreeNode<pair<K, E>> *&x) {
    rotateLL(x->rightChild);
    rotateRR(x);
}

/*
 * 删除节点时：对于Rr1(2)型和Rr2型的旋转使用
 * 输入：替换被删除节点的y节点的父亲节点
 * 输出：void
 * 时间复杂度：O(1)
 */
template<class K, class E>
void RedBlackTree<K, E>::rotateRr1_2and2(RedBlackTreeNode<pair<K, E>> *&pp) {
    RedBlackTreeNode<pair<K, E>> *Parent = pp->parent;
    RedBlackTreeNode<pair<K, E>> *w = pp->leftChild->rightChild;
    RedBlackTreeNode<pair<K, E>> *x = w->rightChild;
    if(x != nullptr){
        w->rightChild = x->leftChild;
        if(x->leftChild)
            x->leftChild->parent = w;// 父亲节点要及时更改
    }
    else{
        cout << "rotateRr1_2and2 error!" << endl;
    }
    x->leftChild = pp->leftChild;
    pp->leftChild->parent = x;

    pp->leftChild = x->rightChild;
    if(x->rightChild)
        x->rightChild->parent = pp;
    x->rightChild = pp;
    pp->parent = x;
    if(Parent->leftChild == pp)
        Parent->leftChild = x;
    else
        Parent->rightChild = x;
    x->parent = Parent;
    pp = x;
}

/*
 * 删除节点时，对于Lr1(2)型和Lr2型的旋转使用
 * 输入：替换被删除节点的y节点的父亲节点
 * 输出：void
 * 时间复杂度：O(1)
 */
template<class K, class E>
void RedBlackTree<K, E>::rotateLr1_2and2(RedBlackTreeNode<pair<K, E>> *&pp) {
    RedBlackTreeNode<pair<K, E>> *Parent = pp->parent;
    RedBlackTreeNode<pair<K, E>> *w = pp->rightChild->leftChild;
    RedBlackTreeNode<pair<K, E>> *x = w->leftChild;
    if(x != nullptr){
        w->leftChild = x->rightChild;
        if(x->rightChild)
            x->rightChild->parent = w;// 父亲节点要及时更改
    }
    else{
        cout << "rotateLr1_2and2 error!" << endl;
    }
    x->rightChild = pp->rightChild;
    pp->rightChild->parent = x;

    pp->rightChild = x->leftChild;
    if(x->leftChild)
        x->leftChild->parent = pp;
    x->leftChild = pp;
    pp->parent = x;
    if(Parent->leftChild == pp)
        Parent->leftChild = x;
    else
        Parent->rightChild = x;
    x->parent = Parent;
    pp = x;
}

/*
 *  插入元素
 *  输入：const pair<K, E> thePair表示需要插入的键值对
 *  输出：void
 *  时间复杂度：O(logn)，表示节点个数
 */
template<class K, class E>
void RedBlackTree<K, E>::insert(pair<K, E> &thePair) {

    // 当红黑树为空时，插入节点直接作为根节点，且其颜色为黑色
    if (root == nullptr) {
        root = new RedBlackTreeNode<pair<K, E> >(thePair, nullptr, nullptr, nullptr, false);
        treeSize++;
        return;
    }
    // 如果树非空. 如果该键值存在则覆盖元素
    // 寻找插入位置
    RedBlackTreeNode<pair<K, E> > *p = root,
            *pp = nullptr;
    while (p != nullptr) {// 检查元素 p->element
        pp = p;
        // 如果当前键值小于p的键值，则移到p的左孩子
        if (thePair.first < p->element.first)
            p = p->leftChild;
        else// 如果当前键值大于p的键值，则移到p的右孩子
        if (thePair.first > p->element.first)
            p = p->rightChild;
        else {// 如果键值相等，覆盖旧的值
            p->element.second = thePair.second;
            return;
        }
    }

    // 为thePair建立一个节点，然后与pp链接，此时pp是叶子节，默认插入为红色节点
    auto *newNode = new RedBlackTreeNode<pair<K, E> >(thePair);
    // 如果thePair的键值小于pp的键值，则将thePair作为pp的左孩子，反之将其作为右孩子
    if (thePair.first < pp->element.first) {
        pp->leftChild = newNode;
        newNode->parent = pp;
    } else {
        pp->rightChild = newNode;
        newNode->parent = pp;
    }
    treeSize++;
    p = newNode;
    // 如果父亲节点存在且父亲节点是红色的，则需要对红黑树进行调整
    while (pp && pp->isRed == true) {
        // parent是红色，则其父节点一定存在
        RedBlackTreeNode<pair<K, E> > *grandfather = pp->parent;
        if (pp == grandfather->leftChild) {// parent是grandfather的左孩子
            // LYr(Y可以是L或R)的情况
            RedBlackTreeNode<pair<K, E> > *uncle = grandfather->rightChild;// 找到grandfather的右孩子，可以称为叔叔
            if (uncle && uncle->isRed == true) {// 如果叔叔存在且为红色
                // 将父亲节点和其叔叔节点的颜色更改为黑色
                pp->isRed = uncle->isRed = false;
                // 只有在祖父节点不为根节点时，将祖父节点的颜色更改为红色
                if (grandfather != root)
                    grandfather->isRed = true;
                else // 如果祖父节点已经是根节点了，那么就直接终止循环，因为不可能再向上处理了
                    break;
                // 继续往上处理
                p = grandfather;
                pp = p->parent;
            } else {// uncle不存在或者uncle存在且为黑色
                // 如果当前节点是其父亲节点的左孩子
                // LLb的情况：左孩子的左孩子
                if (p == pp->leftChild) {
                    rotateLL(grandfather);// LL单旋
                    // 调整颜色
                    // 现在的grandfather指向的是原来的父亲节点，grandfather的右孩子指向的是原祖父节点
                    grandfather->isRed = false;
                    grandfather->rightChild->isRed = true;
                } else {// LRb的情况
                    rotateLR(grandfather);
                    // 调整颜色
                    // 现在的grandfather指向的是原来的新节点u，u的左孩子是原来的父亲节点pu，u的右孩子是原来的祖父节点gu
                    grandfather->isRed = false;
                    grandfather->rightChild->isRed = true;
                }
                break;// 无需继续向上进行处理
            }
        } else {// parent是grandfather的右孩子
            // RYr(Y可以是L或R)的情况
            RedBlackTreeNode<pair<K, E> > *uncle = grandfather->leftChild;// 找到grandfather的左孩子，可以称为叔叔
            if (uncle && uncle->isRed == true) {// 如果叔叔存在且为红色
                // 将父亲节点和其叔叔节点的颜色更改为黑色
                pp->isRed = uncle->isRed = false;
                // 只有在祖父节点不为根节点时，将祖父节点的颜色更改为红色
                if (grandfather != root)
                    grandfather->isRed = true;
                else // 如果祖父节点已经是根节点了，那么就直接终止循环，因为不可能再向上处理了
                    break;
                // 继续往上处理
                p = grandfather;
                pp = p->parent;
            } else {// uncle不存在或者uncle存在且为黑色
                // 如果当前节点是其父亲节点的右孩子
                // RRb的情况：右孩子的右孩子
                if (p == pp->rightChild) {
                    rotateRR(grandfather);// RR单旋
                    // 调整颜色
                    // 现在的grandfather指向的是原来的父亲节点，grandfather的左孩子指向的是原祖父节点
                    grandfather->isRed = false;
                    grandfather->leftChild->isRed = true;
                } else {// LRb的情况
                    rotateRL(grandfather);
                    // 调整颜色
                    // 现在的grandfather指向的是原来的新节点u，u的右孩子是原来的父亲节点pu，u的左孩子是原来的祖父节点gu
                    grandfather->isRed = false;
                    grandfather->leftChild->isRed = true;
                }
                break;// 无需继续向上进行处理
            }
        }

    }
}

/*
 *  删除元素
 *  输入：const K theKey表示需要删除元素的键值
 *  输出：void
 *  时间复杂度：O(logn)，n表示节点个数
 */
template<class K, class E>
void RedBlackTree<K, E>::erase(K theKey) {
    // 删除关键字等于theKey的数对
    // 查找关键字为theKey的节点
    RedBlackTreeNode<pair<K, E> > *p = root,
            *pp = nullptr;
    while (p != nullptr && p->element.first != theKey)
    {
        pp = p;
        if (theKey < p->element.first)
            p = p->leftChild;
        else
            p = p->rightChild;
    }
    if (p == nullptr){
        cout << theKey << " not exist!" << endl;
        return; // 不存在与关键字theKey匹配的数对
    }

    // 重新组织树结构
    // 当p有两个孩子时的处理
    if (p->leftChild != nullptr && p->rightChild != nullptr)
    {
        // 两个孩子
        // 在P的左子树中寻找最大元素
        RedBlackTreeNode<pair<K, E> > *s = p->leftChild,
                *ps = p;  // s的父节点
        while (s->rightChild != nullptr)
        {// 移动到更大的pair
            ps = s;
            s = s->rightChild;// 右孩子比较大
        }

        // 将最大元素s移到p
        // p->element = s->element 的键值是 const
        // 当最大值就是p的左孩子时，new的元素不能直接指向p的左孩子，而要指向p的左孩子的左孩子(此时p的左孩子没有右孩子)，因为到时候s会被delete掉,这个问题在后面的p至多有一个孩子那里解决的
        RedBlackTreeNode<pair<K, E> >* q = nullptr;
        // 值用s的值替换，颜色和其他指针的指向都是p的
        q = new RedBlackTreeNode<pair<K, E> >(s->element, p->leftChild, p->rightChild, p->parent, p->isRed);
        if(p->leftChild)
            p->leftChild->parent = q;
        if(p->rightChild)
            p->rightChild->parent = q;
        // pp是p的父节点
        // 如果p没有父节点
        if (pp == nullptr)
            root = q;
        else if (p == pp->leftChild)// 如果p是pp的左孩子
            pp->leftChild = q;
        else// 如果p是pp的右孩子
            pp->rightChild = q;
        // 如果s的父节点就是p，说明p节点的左子树只有左子树没有右子树
        // 那么删除p后pp就是其父节点
        if (ps == p) pp = q;
        else pp = ps;// 反之ps是其父节点
        delete p;
        p = s;
    }

    // p至多只有一个孩子
    // 把孩子的指针存放到c
    RedBlackTreeNode<pair<K, E> > *c;
    if (p->leftChild != nullptr)
        c = p->leftChild;
    else
        c = p->rightChild;

    // 删除p
    bool isLeft = false;// 记录p节点是左孩子还是右孩子
    if (p == root)
        root = c;
    else
    {// p是pp的左孩子还是右孩子
        if (p == pp->leftChild){
            pp->leftChild = c;
            // 更新一下c节点的父亲节点
            if(c != nullptr)
                c->parent = pp;
            isLeft = true;
        }
        else{
            pp->rightChild = c;
            // 更新一下c节点的父亲节点
            if(c != nullptr)
                c->parent = pp;
        }
    }
    treeSize--;

    // 之前就找到了y节点的父亲节点pp
    // 如果被删除节点是红色的，则红黑树还是平衡的；如果被删除节点是黑色的，则红黑树需要调整
    if(p->isRed == false){
        // 父亲节点不为空，说明还需要继续调整
        while(pp){
            // 如果c节点不为空，则需要判断c节点是左孩子还是右孩子
            // 这个主要是用于第二轮调整平衡，也就是c节点此时不再是p的孩子节点
            if(c){
                if(c == pp->leftChild)
                    isLeft = true;
                else
                    isLeft = false;
            }

            if(isLeft){
                // 找到被删除节点的兄弟
                RedBlackTreeNode<pair<K, E> > *v = pp->rightChild;
                // 如果兄弟节点是黑色节点 Lb型
                // 如果c和v都为空的话，那么不用调整平衡
                if(!c && !v)
                    break;
                if(!v->isRed){
                    // 如果v的左右孩子都是红色节点，Lb2型;或者v的左孩子是红色节点，Lb1(2)型
                    if(v->leftChild && v->leftChild->isRed){
                        rotateRL(pp);// OK1
                        pp->isRed = pp->leftChild->isRed;
                        pp->leftChild->isRed = false;
                        break;
                    }
                    else if(v->rightChild && v->rightChild->isRed){// 如果v的左孩子是红色节点，Lb1(1)型
                        rotateRR(pp);// OK1
                        pp->isRed = pp->leftChild->isRed;// 这个节点的颜色不变
                        pp->leftChild->isRed = false;// 原来的祖先节点的颜色变为黑色节点
                        v->rightChild->isRed = false;// 将v的左孩子更改为黑色节点
                        break;// 不需要继续调整了
                    }
                    else{// 如果v的左右孩子都是黑色节点，Lb0型
                        // pp是红色节点，改变pp为黑色节点，改变v为红色节点
                        if(pp->isRed){
                            pp->isRed = false;// OK1
                            v->isRed = true;
                            break;// 终止循环，不需要再继续调整了
                        }
                        else{// pp是黑色节点，将v节点改变为红色节点，然后将pp节点作为新的y节点，也就是程序中的p节点
                            v->isRed = true;//OK1
                            // 继续调整平衡
                            c = pp;
                            pp = c->parent;
                        }
                    }
                }
                else{// 如果兄弟节点是红色节点 Lr型，则兄弟节点一定有左右孩子
                    // 找到被删除节点的兄弟的左孩子
                    RedBlackTreeNode<pair<K, E> > *vL = v->leftChild;
                    // 如果vL的左右孩子都是红色节点，Lr2型 或者 如果v的左孩子是红色节点，Lr1(2)型
                    if(vL && vL->leftChild && vL->leftChild->isRed){
                        rotateLr1_2and2(pp);// OK1
                        pp->isRed = false;
                        break;
                    }
                    else if(vL && vL->rightChild && vL->rightChild->isRed){// 如果v的右孩子是红色节点，Lr1(1)型
                        rotateRL(pp);// OK1
                        if(vL->rightChild->leftChild)
                            vL->rightChild->leftChild->isRed = false;
                        break;
                    }
                    else{// 如果v的左右孩子都是黑色节点，Lr0型
                        rotateRR(pp);// OK1
                        pp->isRed = false;// 更改原来的v节点为黑色节点
                        if(pp->leftChild->rightChild)
                            pp->leftChild->rightChild->isRed = true;
                        break;
                    }
                }
            }
            else{// 否则是R型
                // 找到被删除节点的兄弟
                RedBlackTreeNode<pair<K, E> > *v = pp->leftChild;
                // 如果c和v都为空的话，那么树本身就是平衡的
                if((!c && !v))
                    break;
                // 如果兄弟节点是黑色节点 Rb型
                if(!v->isRed){
                    // 如果v的左右孩子都是红色节点，Rb2型；或者v的右孩子是红色节点，Rb1(2)型
                    if(v->rightChild && v->rightChild->isRed){
                        rotateLR(pp);// OK1
                        pp->isRed = pp->rightChild->isRed;
                        pp->rightChild->isRed = false;
                        break;
                    }
                    else if(v->leftChild && v->leftChild->isRed){// 如果v的左孩子是红色节点，Rb1(1)型
                        rotateLL(pp);// OK1
                        pp->isRed = pp->rightChild->isRed;// 这个节点的颜色不变
                        pp->rightChild->isRed = false;// 原来的祖先节点的颜色变为黑色节点
                        v->leftChild->isRed = false;// 将v的左孩子更改为黑色节点
                        break;// 不需要继续调整了
                    }
                    else{// 如果v的左右孩子都是黑色节点，Rb0型
                        // pp是红色节点，改变pp为黑色节点，改变v为红色节点
                        if(pp->isRed){
                            pp->isRed = false;// OK1
                            v->isRed = true;
                            break;// 终止循环，不需要再继续调整了
                        }
                        else{// pp是黑色节点，将v节点改变为红色节点，然后将pp节点作为新的y节点，也就是程序中的p节点
                            // 这个没有找到合适的节点去测试
                            v->isRed = true;//OK1
                            c = pp;
                            pp = c->parent;
                        }
                    }
                }
                else{// 如果兄弟节点v是红色节点 Rr型，则兄弟节点v一定有左右孩子
                    // 找到被删除节点的兄弟的右孩子
                    RedBlackTreeNode<pair<K, E> > *vR = v->rightChild;
                    // 如果vR的左右孩子都是红色节点，Rr2型 或者 vR的右孩子是红色节点，Rr1(2)型 两个合起来就是vR的右孩子存在且是红色节点
                    // 两种操作都是一样的
                    if(vR && vR->rightChild && vR->rightChild->isRed){
                        rotateRr1_2and2(pp);// OK1
                        pp->isRed = false;
                        break;
                    }
                    else if(vR && vR->leftChild && vR->leftChild->isRed){// 如果vR的左孩子是红色节点，Rr1(1)型
                        rotateLR(pp);// OK1
                        if(vR->leftChild->rightChild)
                            vR->leftChild->rightChild->isRed = false;
                        break;
                    }
                    else{// 如果v的左右孩子都是黑色节点，Rr0型，没找到合适的树来测试
                        // 如果c节点是nullptr的话，树本来就是平衡的，不需要调整了
                        // OK1
                        rotateLL(pp);
                        pp->isRed = false;// 更改原来的v节点为黑色节点
                        if(pp->rightChild->leftChild)
                            pp->rightChild->leftChild->isRed = true;
                        break;
                    }
                }
            }
        }

    }
    if(root && root->isRed == true)
        root->isRed = false;
    delete p;
}

//判断是否为红黑树
template<class K, class E>
bool RedBlackTree<K, E>::ISRBTree()
{
    if (root == nullptr) //空树是红黑树
    {
        return true;
    }
    if (root->isRed == true)
    {
        cout << "error: root is red" << endl;
        return false;
    }

    //找最左路径作为黑色结点数目的参考值
    RedBlackTreeNode<pair<K, E> > *cur = root;
    int BlackCount = 0;
    while (cur)
    {
        if (cur->isRed == false)
            BlackCount++;
        cur = cur->leftChild;
    }

    int count = 0;
    return _ISRBTree(root, count, BlackCount);
}
//判断是否为红黑树的子函数
template<class K, class E>
bool RedBlackTree<K, E>::_ISRBTree(RedBlackTreeNode<pair<K, E> > * cur, int count, int BlackCount)
{
    if (cur == nullptr) //该路径已经走完了
    {
        if (count != BlackCount)
        {
            cout << "error: black nodes nums not equal" << endl;
            return false;
        }
        return true;
    }

    if (cur->isRed == true && cur->parent->isRed == true)
    {
        cout << "error: red and red nodes together" << endl;
        return false;
    }
    if (cur->isRed == false)
    {
        count++;
    }
    return _ISRBTree(cur->leftChild, count, BlackCount) && _ISRBTree(cur->rightChild, count, BlackCount);
}


// overload << for pair
template<class K, class E>
ostream &operator<<(ostream &out, const pair<K, E> &x) {
    out << x.first << ":" << x.second;
    return out;
}

template<class K, class E>
ostream &operator<<(ostream &out, const RedBlackTreeNode<pair<K, E>> &x) {
    out << x.element.first << ":" << x.element.second << "  isRed = " << x.isRed;
    return out;
}

#endif //_35RED_BLACK_TREE_REDBLACKTREE_H

RedBlackTree.cpp

/*
Project name :			_35Red_black_tree
Last modified Date:		2024年1月9日21点10分
Last Version:			V1.0
Descriptions:			红黑树测试函数
*/
#include "RedBlackTree.h"
#include<vector>

void RedBlackTreeTest() {
    cout << "*************************RedBlackTreeTest() begin*******************************" << endl;
    RedBlackTree<int, char> y;
    pair<int, char> data;
    for(int i = 1; i < 1000001; i++){
        data = pair<int, char>(i, 'e');
        y.insert(data);
    }

    // 第二种删除策略
    for(int i = 250000; i > 0; i--){
        cout << " Delete " << i << endl;
        y.erase(i);
        cout << "y.ISRBTree() = " << y.ISRBTree() << endl;
    }
    for(int i = 500000; i < 750001; i++){
        cout << " Delete " << i << endl;
        y.erase(i);
        cout << "y.ISRBTree() = " << y.ISRBTree() << endl;
    }
    for(int i = 250001; i < 500000; i++){
        cout << " Delete " << i << endl;
        y.erase(i);
        cout << "y.ISRBTree() = " << y.ISRBTree() << endl;
    }
    for(int i = 1000000; i > 750000; i--){
        cout << " Delete " << i << endl;
        y.erase(i);
        cout << "y.ISRBTree() = " << y.ISRBTree() << endl;
    }

    cout << "***************************RedBlackTreeTest() end*******************************" << endl;
}

RedBlackTreeNode.h

/*
Project name :			_35Red_black_tree
Last modified Date:		2024年1月5日21点00分
Last Version:			V1.0
Descriptions:			红黑树树节点模板类
*/

#ifndef _35RED_BLACK_TREE_REDBLACKTREENODE_H
#define _35RED_BLACK_TREE_REDBLACKTREENODE_H

template<class T>
struct RedBlackTreeNode {
    T element;// 存储键值对
    RedBlackTreeNode<T> *leftChild,   // 左子树
    *rightChild, // 右子树
    *parent;  // 父亲节点
    bool isRed; // true表示为红色，false表示为黑色

    RedBlackTreeNode() {
        leftChild = rightChild = parent = nullptr;
        isRed = true;
    }

    explicit RedBlackTreeNode(T &theElement) : element(theElement) {
        leftChild = rightChild = parent = nullptr;
        isRed = true;
    }

    explicit RedBlackTreeNode(T &theElement,
                              RedBlackTreeNode *theLeftChild,
                              RedBlackTreeNode *theRightChild,
                              RedBlackTreeNode *theParent)
            : element(theElement), leftChild(theLeftChild),
              rightChild(theRightChild), parent(theParent) {
        isRed = true;
    }

    explicit RedBlackTreeNode(T &theElement,
                              RedBlackTreeNode *theLeftChild,
                              RedBlackTreeNode *theRightChild,
                              RedBlackTreeNode *theParent, bool theIsRed)
            : element(theElement), leftChild(theLeftChild), rightChild(theRightChild), parent(theParent) {
        isRed = theIsRed;
    }
};

#endif //_35RED_BLACK_TREE_REDBLACKTREENODE_H

dictionary.h

/*
Project name :			_35Red_black_tree
Last modified Date:		2024年1月6日18点17分
Last Version:			V1.0
Descriptions:			红黑树模板类
*/

#ifndef _35RED_BLACK_TREE_REDBLACKTREE_H
#define _35RED_BLACK_TREE_REDBLACKTREE_H

#include "RedBlackTreeNode.h"
#include "dictionary.h"
#include <stack>

void RedBlackTreeTest();

using namespace std;

template<class K, class E>
class RedBlackTree : public dictionary<K, E> {
public:
    RedBlackTree() {
        root = nullptr;
        treeSize = 0;
    }

    [[nodiscard]] bool empty() const { return treeSize == 0; }

    [[nodiscard]] int size() const { return treeSize; }

    pair<K, E> *find(K theKey) const;

    void insert(pair<K, E> &thePair);

    void erase(K theKey);

    /*中序遍历二叉树，使用函数指针的目的是是的本函数可以实现多种目的*/
    void inOrder(void(*theVisit)(RedBlackTreeNode<pair<K, E>> *)) {
        visit = theVisit;
        /*是因为递归，所以才要这样的*/
        inOrder(root);/*这里调用的是静态成员函数inOrder()*/
    }

    /*中序遍历---输出endl*/
    void inOrderOutput() {
        inOrder(output);
        cout << endl;
    }

    /*前序遍历二叉树，使用函数指针的目的是是的本函数可以实现多种目的*/
    void preOrder(void(*theVisit)(RedBlackTreeNode<pair<K, E>> *)) {
        visit = theVisit;
        int num = 0;
        /*是因为递归，所以才要这样的*/
        preOrder(root, num);/*这里调用的是静态成员函数preOrder()*/
        cout << "num = " << num << endl;
    }

    /*中序遍历---输出endl*/
    void preOrderOutput() {
        preOrder(output);
        cout << endl;
    }
    bool ISRBTree();

private:
    RedBlackTreeNode<pair<K, E>> *root;// 指向根的指针
    int treeSize;// 树的结点个数
    static void (*visit)(RedBlackTreeNode<pair<K, E>> *);//是一个函数指针,返回值为void 函数参数为binaryTreeNode<pair<K, E>>*
    static void output(RedBlackTreeNode<pair<K, E>> *t) { cout << *t << endl; }

    static void inOrder(RedBlackTreeNode<pair<K, E>> *t);

    static void preOrder(RedBlackTreeNode<pair<K, E>> *t, int& num);

    void rotateLL(RedBlackTreeNode<pair<K, E>> *&x);

    void rotateLR(RedBlackTreeNode<pair<K, E>> *&x);

    void rotateRR(RedBlackTreeNode<pair<K, E>> *&x);

    void rotateRL(RedBlackTreeNode<pair<K, E>> *&x);

    void rotateRr1_2and2(RedBlackTreeNode<pair<K, E>> *&pp);

    void rotateLr1_2and2(RedBlackTreeNode<pair<K, E>> *&pp);

    bool _ISRBTree(RedBlackTreeNode<pair<K, E> > * root, int count, int BlackCount);
};

/*私有静态成员初始化*/
/*这里是静态函数指针成员的初始化，不初始化会引发LINK错误*/
template<class K, class E>
void (*RedBlackTree<K, E>::visit)(RedBlackTreeNode<pair<K, E>> *) = 0;      // visit function

/*中序遍历 递归*/
template<class K, class E>
void RedBlackTree<K, E>::inOrder(RedBlackTreeNode<pair<K, E>> *t) {
    if (t != nullptr) {
        inOrder(t->leftChild);/*中序遍历左子树*/
        visit(t);/*访问树根*/
        inOrder(t->rightChild);/*中序遍历右子树*/
    }
}

/*前序遍历 递归*/
template<class K, class E>
void RedBlackTree<K, E>::preOrder(RedBlackTreeNode<pair<K, E>> *t, int& num) {
    if (t != nullptr) {
        visit(t);/*访问树根*/
        num++;
        preOrder(t->leftChild, num);/*中序遍历左子树*/
        preOrder(t->rightChild, num);/*中序遍历右子树*/
    }
}

/*  查找元素
 *  输入：theKey表示需要查找元素的键值
 *  输出：键值为theKey的节点的pair地址
 *  时间复杂度：O(logn)，n表示节点个数
 */
template<class K, class E>
pair<K, E> *RedBlackTree<K, E>::find(K theKey) const {
    // 返回值是匹配数对的指针
    // 如果没有匹配的数对，返回值为nullptr
    // p从根节点开始搜索，寻找关键字等于theKey的一个元素
    RedBlackTreeNode<pair<K, E> > *p = root;
    while (p != nullptr)
        // 检查元素 p->element
        if (theKey < p->element.first)
            p = p->leftChild;
        else if (theKey > p->element.first)
            p = p->rightChild;
        else // 找到匹配的元素
            return &p->element;

    // 没找到匹配的元素
    return nullptr;
}

/*
 *  LL旋转
 *  输入：x是第一个L的父亲节点，插入元素和删除元素都会用到
 *  输出：void
 *  时间复杂度：O(1)
 *  注意事项：执行本函数前后x指向的元素会改变为新的该子树的根节点
 */
template<class K, class E>
void RedBlackTree<K, E>::rotateLL(RedBlackTreeNode<pair<K, E>> *&x) {
    // 记录祖父节点的父亲节点
    RedBlackTreeNode<pair<K, E>> *Parent = x->parent;
    RedBlackTreeNode<pair<K, E>> *b = x->leftChild;
    x->leftChild = b->rightChild;
    if(b->rightChild)
        b->rightChild->parent = x;

    b->rightChild = x;
    // x的父亲节点变为b
    x->parent = b;
    // b的父亲节点变为原来x的父亲节点
    b->parent = Parent;
    // 这里就是原来祖父节点的父亲现在需要作为b的父亲，前提是祖父节点的父亲存在
    if (Parent != nullptr) {
        if (x == Parent->leftChild)
            Parent->leftChild = b;
        else
            Parent->rightChild = b;
    } else
        root = b;// 祖父节点如果没有父亲的话就是根节点
    x = b;// b节点将替换x节点
}

/*
 *  RR旋转
 *  输入：x表示第一个R的父亲节点，在插入和删除时都会用到
 *  输出：void
 *  时间复杂度：O(1)
 *  注意事项：执行本函数前后x指向的元素会改变为新的该子树的根节点
 */
template<class K, class E>
void RedBlackTree<K, E>::rotateRR(RedBlackTreeNode<pair<K, E>> *&x) {
    // 记录祖父节点的父亲节点
    RedBlackTreeNode<pair<K, E>> *Parent = x->parent;
    RedBlackTreeNode<pair<K, E>> *b = x->rightChild;
    x->rightChild = b->leftChild;
    if(b->leftChild)
        b->leftChild->parent = x;

    b->leftChild = x;
    x->parent = b;// x的父亲节点为b
    // b的父亲节点为祖父节点的父亲节点
    b->parent = Parent;
    // 这里就是原来祖父节点的父亲现在需要作为b的父亲，前提是祖父节点的父亲存在
    if (Parent != nullptr) {
        if (x == Parent->leftChild)
            Parent->leftChild = b;
        else
            Parent->rightChild = b;
    } else
        root = b;// 祖父节点如果没有父亲的话就是根节点
    x = b;
}

/*
 *  LR旋转
 *  输入：x表示L的父亲节点，插入元素和删除元素时都会用到
 *  输出：void
 *  时间复杂度：O(1)
 *  注意事项：执行本函数前后x指向的元素会改变为新的该子树的根节点
 */
template<class K, class E>
void RedBlackTree<K, E>::rotateLR(RedBlackTreeNode<pair<K, E>> *&x) {
    rotateRR(x->leftChild);
    rotateLL(x);
}

/*
 *  RL旋转
 *  输入：x表示R的父亲节点，插入元素和删除元素都会用到
 *  输出：void
 *  时间复杂度：O(1)
 *  注意事项：执行本函数前后x指向的元素会改变为新的该子树的根节点
 */
template<class K, class E>
void RedBlackTree<K, E>::rotateRL(RedBlackTreeNode<pair<K, E>> *&x) {
    rotateLL(x->rightChild);
    rotateRR(x);
}

/*
 * 删除节点时：对于Rr1(2)型和Rr2型的旋转使用
 * 输入：替换被删除节点的y节点的父亲节点
 * 输出：void
 * 时间复杂度：O(1)
 */
template<class K, class E>
void RedBlackTree<K, E>::rotateRr1_2and2(RedBlackTreeNode<pair<K, E>> *&pp) {
    RedBlackTreeNode<pair<K, E>> *Parent = pp->parent;
    RedBlackTreeNode<pair<K, E>> *w = pp->leftChild->rightChild;
    RedBlackTreeNode<pair<K, E>> *x = w->rightChild;
    if(x != nullptr){
        w->rightChild = x->leftChild;
        if(x->leftChild)
            x->leftChild->parent = w;// 父亲节点要及时更改
    }
    else{
        cout << "rotateRr1_2and2 error!" << endl;
    }
    x->leftChild = pp->leftChild;
    pp->leftChild->parent = x;

    pp->leftChild = x->rightChild;
    if(x->rightChild)
        x->rightChild->parent = pp;
    x->rightChild = pp;
    pp->parent = x;
    if(Parent->leftChild == pp)
        Parent->leftChild = x;
    else
        Parent->rightChild = x;
    x->parent = Parent;
    pp = x;
}

/*
 * 删除节点时，对于Lr1(2)型和Lr2型的旋转使用
 * 输入：替换被删除节点的y节点的父亲节点
 * 输出：void
 * 时间复杂度：O(1)
 */
template<class K, class E>
void RedBlackTree<K, E>::rotateLr1_2and2(RedBlackTreeNode<pair<K, E>> *&pp) {
    RedBlackTreeNode<pair<K, E>> *Parent = pp->parent;
    RedBlackTreeNode<pair<K, E>> *w = pp->rightChild->leftChild;
    RedBlackTreeNode<pair<K, E>> *x = w->leftChild;
    if(x != nullptr){
        w->leftChild = x->rightChild;
        if(x->rightChild)
            x->rightChild->parent = w;// 父亲节点要及时更改
    }
    else{
        cout << "rotateLr1_2and2 error!" << endl;
    }
    x->rightChild = pp->rightChild;
    pp->rightChild->parent = x;

    pp->rightChild = x->leftChild;
    if(x->leftChild)
        x->leftChild->parent = pp;
    x->leftChild = pp;
    pp->parent = x;
    if(Parent->leftChild == pp)
        Parent->leftChild = x;
    else
        Parent->rightChild = x;
    x->parent = Parent;
    pp = x;
}

/*
 *  插入元素
 *  输入：const pair<K, E> thePair表示需要插入的键值对
 *  输出：void
 *  时间复杂度：O(logn)，表示节点个数
 */
template<class K, class E>
void RedBlackTree<K, E>::insert(pair<K, E> &thePair) {

    // 当红黑树为空时，插入节点直接作为根节点，且其颜色为黑色
    if (root == nullptr) {
        root = new RedBlackTreeNode<pair<K, E> >(thePair, nullptr, nullptr, nullptr, false);
        treeSize++;
        return;
    }
    // 如果树非空. 如果该键值存在则覆盖元素
    // 寻找插入位置
    RedBlackTreeNode<pair<K, E> > *p = root,
            *pp = nullptr;
    while (p != nullptr) {// 检查元素 p->element
        pp = p;
        // 如果当前键值小于p的键值，则移到p的左孩子
        if (thePair.first < p->element.first)
            p = p->leftChild;
        else// 如果当前键值大于p的键值，则移到p的右孩子
        if (thePair.first > p->element.first)
            p = p->rightChild;
        else {// 如果键值相等，覆盖旧的值
            p->element.second = thePair.second;
            return;
        }
    }

    // 为thePair建立一个节点，然后与pp链接，此时pp是叶子节，默认插入为红色节点
    auto *newNode = new RedBlackTreeNode<pair<K, E> >(thePair);
    // 如果thePair的键值小于pp的键值，则将thePair作为pp的左孩子，反之将其作为右孩子
    if (thePair.first < pp->element.first) {
        pp->leftChild = newNode;
        newNode->parent = pp;
    } else {
        pp->rightChild = newNode;
        newNode->parent = pp;
    }
    treeSize++;
    p = newNode;
    // 如果父亲节点存在且父亲节点是红色的，则需要对红黑树进行调整
    while (pp && pp->isRed == true) {
        // parent是红色，则其父节点一定存在
        RedBlackTreeNode<pair<K, E> > *grandfather = pp->parent;
        if (pp == grandfather->leftChild) {// parent是grandfather的左孩子
            // LYr(Y可以是L或R)的情况
            RedBlackTreeNode<pair<K, E> > *uncle = grandfather->rightChild;// 找到grandfather的右孩子，可以称为叔叔
            if (uncle && uncle->isRed == true) {// 如果叔叔存在且为红色
                // 将父亲节点和其叔叔节点的颜色更改为黑色
                pp->isRed = uncle->isRed = false;
                // 只有在祖父节点不为根节点时，将祖父节点的颜色更改为红色
                if (grandfather != root)
                    grandfather->isRed = true;
                else // 如果祖父节点已经是根节点了，那么就直接终止循环，因为不可能再向上处理了
                    break;
                // 继续往上处理
                p = grandfather;
                pp = p->parent;
            } else {// uncle不存在或者uncle存在且为黑色
                // 如果当前节点是其父亲节点的左孩子
                // LLb的情况：左孩子的左孩子
                if (p == pp->leftChild) {
                    rotateLL(grandfather);// LL单旋
                    // 调整颜色
                    // 现在的grandfather指向的是原来的父亲节点，grandfather的右孩子指向的是原祖父节点
                    grandfather->isRed = false;
                    grandfather->rightChild->isRed = true;
                } else {// LRb的情况
                    rotateLR(grandfather);
                    // 调整颜色
                    // 现在的grandfather指向的是原来的新节点u，u的左孩子是原来的父亲节点pu，u的右孩子是原来的祖父节点gu
                    grandfather->isRed = false;
                    grandfather->rightChild->isRed = true;
                }
                break;// 无需继续向上进行处理
            }
        } else {// parent是grandfather的右孩子
            // RYr(Y可以是L或R)的情况
            RedBlackTreeNode<pair<K, E> > *uncle = grandfather->leftChild;// 找到grandfather的左孩子，可以称为叔叔
            if (uncle && uncle->isRed == true) {// 如果叔叔存在且为红色
                // 将父亲节点和其叔叔节点的颜色更改为黑色
                pp->isRed = uncle->isRed = false;
                // 只有在祖父节点不为根节点时，将祖父节点的颜色更改为红色
                if (grandfather != root)
                    grandfather->isRed = true;
                else // 如果祖父节点已经是根节点了，那么就直接终止循环，因为不可能再向上处理了
                    break;
                // 继续往上处理
                p = grandfather;
                pp = p->parent;
            } else {// uncle不存在或者uncle存在且为黑色
                // 如果当前节点是其父亲节点的右孩子
                // RRb的情况：右孩子的右孩子
                if (p == pp->rightChild) {
                    rotateRR(grandfather);// RR单旋
                    // 调整颜色
                    // 现在的grandfather指向的是原来的父亲节点，grandfather的左孩子指向的是原祖父节点
                    grandfather->isRed = false;
                    grandfather->leftChild->isRed = true;
                } else {// LRb的情况
                    rotateRL(grandfather);
                    // 调整颜色
                    // 现在的grandfather指向的是原来的新节点u，u的右孩子是原来的父亲节点pu，u的左孩子是原来的祖父节点gu
                    grandfather->isRed = false;
                    grandfather->leftChild->isRed = true;
                }
                break;// 无需继续向上进行处理
            }
        }

    }
}

/*
 *  删除元素
 *  输入：const K theKey表示需要删除元素的键值
 *  输出：void
 *  时间复杂度：O(logn)，n表示节点个数
 */
template<class K, class E>
void RedBlackTree<K, E>::erase(K theKey) {
    // 删除关键字等于theKey的数对
    // 查找关键字为theKey的节点
    RedBlackTreeNode<pair<K, E> > *p = root,
            *pp = nullptr;
    while (p != nullptr && p->element.first != theKey)
    {
        pp = p;
        if (theKey < p->element.first)
            p = p->leftChild;
        else
            p = p->rightChild;
    }
    if (p == nullptr){
        cout << theKey << " not exist!" << endl;
        return; // 不存在与关键字theKey匹配的数对
    }

    // 重新组织树结构
    // 当p有两个孩子时的处理
    if (p->leftChild != nullptr && p->rightChild != nullptr)
    {
        // 两个孩子
        // 在P的左子树中寻找最大元素
        RedBlackTreeNode<pair<K, E> > *s = p->leftChild,
                *ps = p;  // s的父节点
        while (s->rightChild != nullptr)
        {// 移动到更大的pair
            ps = s;
            s = s->rightChild;// 右孩子比较大
        }

        // 将最大元素s移到p
        // p->element = s->element 的键值是 const
        // 当最大值就是p的左孩子时，new的元素不能直接指向p的左孩子，而要指向p的左孩子的左孩子(此时p的左孩子没有右孩子)，因为到时候s会被delete掉,这个问题在后面的p至多有一个孩子那里解决的
        RedBlackTreeNode<pair<K, E> >* q = nullptr;
        // 值用s的值替换，颜色和其他指针的指向都是p的
        q = new RedBlackTreeNode<pair<K, E> >(s->element, p->leftChild, p->rightChild, p->parent, p->isRed);
        if(p->leftChild)
            p->leftChild->parent = q;
        if(p->rightChild)
            p->rightChild->parent = q;
        // pp是p的父节点
        // 如果p没有父节点
        if (pp == nullptr)
            root = q;
        else if (p == pp->leftChild)// 如果p是pp的左孩子
            pp->leftChild = q;
        else// 如果p是pp的右孩子
            pp->rightChild = q;
        // 如果s的父节点就是p，说明p节点的左子树只有左子树没有右子树
        // 那么删除p后pp就是其父节点
        if (ps == p) pp = q;
        else pp = ps;// 反之ps是其父节点
        delete p;
        p = s;
    }

    // p至多只有一个孩子
    // 把孩子的指针存放到c
    RedBlackTreeNode<pair<K, E> > *c;
    if (p->leftChild != nullptr)
        c = p->leftChild;
    else
        c = p->rightChild;

    // 删除p
    bool isLeft = false;// 记录p节点是左孩子还是右孩子
    if (p == root)
        root = c;
    else
    {// p是pp的左孩子还是右孩子
        if (p == pp->leftChild){
            pp->leftChild = c;
            // 更新一下c节点的父亲节点
            if(c != nullptr)
                c->parent = pp;
            isLeft = true;
        }
        else{
            pp->rightChild = c;
            // 更新一下c节点的父亲节点
            if(c != nullptr)
                c->parent = pp;
        }
    }
    treeSize--;

    // 之前就找到了y节点的父亲节点pp
    // 如果被删除节点是红色的，则红黑树还是平衡的；如果被删除节点是黑色的，则红黑树需要调整
    if(p->isRed == false){
        // 父亲节点不为空，说明还需要继续调整
        while(pp){
            // 如果c节点不为空，则需要判断c节点是左孩子还是右孩子
            // 这个主要是用于第二轮调整平衡，也就是c节点此时不再是p的孩子节点
            if(c){
                if(c == pp->leftChild)
                    isLeft = true;
                else
                    isLeft = false;
            }

            if(isLeft){
                // 找到被删除节点的兄弟
                RedBlackTreeNode<pair<K, E> > *v = pp->rightChild;
                // 如果兄弟节点是黑色节点 Lb型
                // 如果c和v都为空的话，那么不用调整平衡
                if(!c && !v)
                    break;
                if(!v->isRed){
                    // 如果v的左右孩子都是红色节点，Lb2型;或者v的左孩子是红色节点，Lb1(2)型
                    if(v->leftChild && v->leftChild->isRed){
                        rotateRL(pp);// OK1
                        pp->isRed = pp->leftChild->isRed;
                        pp->leftChild->isRed = false;
                        break;
                    }
                    else if(v->rightChild && v->rightChild->isRed){// 如果v的左孩子是红色节点，Lb1(1)型
                        rotateRR(pp);// OK1
                        pp->isRed = pp->leftChild->isRed;// 这个节点的颜色不变
                        pp->leftChild->isRed = false;// 原来的祖先节点的颜色变为黑色节点
                        v->rightChild->isRed = false;// 将v的左孩子更改为黑色节点
                        break;// 不需要继续调整了
                    }
                    else{// 如果v的左右孩子都是黑色节点，Lb0型
                        // pp是红色节点，改变pp为黑色节点，改变v为红色节点
                        if(pp->isRed){
                            pp->isRed = false;// OK1
                            v->isRed = true;
                            break;// 终止循环，不需要再继续调整了
                        }
                        else{// pp是黑色节点，将v节点改变为红色节点，然后将pp节点作为新的y节点，也就是程序中的p节点
                            v->isRed = true;//OK1
                            // 继续调整平衡
                            c = pp;
                            pp = c->parent;
                        }
                    }
                }
                else{// 如果兄弟节点是红色节点 Lr型，则兄弟节点一定有左右孩子
                    // 找到被删除节点的兄弟的左孩子
                    RedBlackTreeNode<pair<K, E> > *vL = v->leftChild;
                    // 如果vL的左右孩子都是红色节点，Lr2型 或者 如果v的左孩子是红色节点，Lr1(2)型
                    if(vL && vL->leftChild && vL->leftChild->isRed){
                        rotateLr1_2and2(pp);// OK1
                        pp->isRed = false;
                        break;
                    }
                    else if(vL && vL->rightChild && vL->rightChild->isRed){// 如果v的右孩子是红色节点，Lr1(1)型
                        rotateRL(pp);// OK1
                        if(vL->rightChild->leftChild)
                            vL->rightChild->leftChild->isRed = false;
                        break;
                    }
                    else{// 如果v的左右孩子都是黑色节点，Lr0型
                        rotateRR(pp);// OK1
                        pp->isRed = false;// 更改原来的v节点为黑色节点
                        if(pp->leftChild->rightChild)
                            pp->leftChild->rightChild->isRed = true;
                        break;
                    }
                }
            }
            else{// 否则是R型
                // 找到被删除节点的兄弟
                RedBlackTreeNode<pair<K, E> > *v = pp->leftChild;
                // 如果c和v都为空的话，那么树本身就是平衡的
                if((!c && !v))
                    break;
                // 如果兄弟节点是黑色节点 Rb型
                if(!v->isRed){
                    // 如果v的左右孩子都是红色节点，Rb2型；或者v的右孩子是红色节点，Rb1(2)型
                    if(v->rightChild && v->rightChild->isRed){
                        rotateLR(pp);// OK1
                        pp->isRed = pp->rightChild->isRed;
                        pp->rightChild->isRed = false;
                        break;
                    }
                    else if(v->leftChild && v->leftChild->isRed){// 如果v的左孩子是红色节点，Rb1(1)型
                        rotateLL(pp);// OK1
                        pp->isRed = pp->rightChild->isRed;// 这个节点的颜色不变
                        pp->rightChild->isRed = false;// 原来的祖先节点的颜色变为黑色节点
                        v->leftChild->isRed = false;// 将v的左孩子更改为黑色节点
                        break;// 不需要继续调整了
                    }
                    else{// 如果v的左右孩子都是黑色节点，Rb0型
                        // pp是红色节点，改变pp为黑色节点，改变v为红色节点
                        if(pp->isRed){
                            pp->isRed = false;// OK1
                            v->isRed = true;
                            break;// 终止循环，不需要再继续调整了
                        }
                        else{// pp是黑色节点，将v节点改变为红色节点，然后将pp节点作为新的y节点，也就是程序中的p节点
                            // 这个没有找到合适的节点去测试
                            v->isRed = true;//OK1
                            c = pp;
                            pp = c->parent;
                        }
                    }
                }
                else{// 如果兄弟节点v是红色节点 Rr型，则兄弟节点v一定有左右孩子
                    // 找到被删除节点的兄弟的右孩子
                    RedBlackTreeNode<pair<K, E> > *vR = v->rightChild;
                    // 如果vR的左右孩子都是红色节点，Rr2型 或者 vR的右孩子是红色节点，Rr1(2)型 两个合起来就是vR的右孩子存在且是红色节点
                    // 两种操作都是一样的
                    if(vR && vR->rightChild && vR->rightChild->isRed){
                        rotateRr1_2and2(pp);// OK1
                        pp->isRed = false;
                        break;
                    }
                    else if(vR && vR->leftChild && vR->leftChild->isRed){// 如果vR的左孩子是红色节点，Rr1(1)型
                        rotateLR(pp);// OK1
                        if(vR->leftChild->rightChild)
                            vR->leftChild->rightChild->isRed = false;
                        break;
                    }
                    else{// 如果v的左右孩子都是黑色节点，Rr0型，没找到合适的树来测试
                        // 如果c节点是nullptr的话，树本来就是平衡的，不需要调整了
                        // OK1
                        rotateLL(pp);
                        pp->isRed = false;// 更改原来的v节点为黑色节点
                        if(pp->rightChild->leftChild)
                            pp->rightChild->leftChild->isRed = true;
                        break;
                    }
                }
            }
        }

    }
    if(root && root->isRed == true)
        root->isRed = false;
    delete p;
}

//判断是否为红黑树
template<class K, class E>
bool RedBlackTree<K, E>::ISRBTree()
{
    if (root == nullptr) //空树是红黑树
    {
        return true;
    }
    if (root->isRed == true)
    {
        cout << "error: root is red" << endl;
        return false;
    }

    //找最左路径作为黑色结点数目的参考值
    RedBlackTreeNode<pair<K, E> > *cur = root;
    int BlackCount = 0;
    while (cur)
    {
        if (cur->isRed == false)
            BlackCount++;
        cur = cur->leftChild;
    }

    int count = 0;
    return _ISRBTree(root, count, BlackCount);
}
//判断是否为红黑树的子函数
template<class K, class E>
bool RedBlackTree<K, E>::_ISRBTree(RedBlackTreeNode<pair<K, E> > * cur, int count, int BlackCount)
{
    if (cur == nullptr) //该路径已经走完了
    {
        if (count != BlackCount)
        {
            cout << "error: black nodes nums not equal" << endl;
            return false;
        }
        return true;
    }

    if (cur->isRed == true && cur->parent->isRed == true)
    {
        cout << "error: red and red nodes together" << endl;
        return false;
    }
    if (cur->isRed == false)
    {
        count++;
    }
    return _ISRBTree(cur->leftChild, count, BlackCount) && _ISRBTree(cur->rightChild, count, BlackCount);
}


// overload << for pair
template<class K, class E>
ostream &operator<<(ostream &out, const pair<K, E> &x) {
    out << x.first << ":" << x.second;
    return out;
}

template<class K, class E>
ostream &operator<<(ostream &out, const RedBlackTreeNode<pair<K, E>> &x) {
    out << x.element.first << ":" << x.element.second << "  isRed = " << x.isRed;
    return out;
}

#endif //_35RED_BLACK_TREE_REDBLACKTREE_H

完整可编译运行代码见仓库：GitHub - Jasmine-up/Data-Structures-Algorithms-and-Applications/_35Red black tree。
如有问题请在评论区指出。另外，Github仓库会根据我的学习情况持续更新，欢迎大家点star，谢谢。

Jasmine-Lily
关注
专栏目录
【C++】红黑树（Red Black Tree）
knous
08-04 506
红黑树的一些操作
数据结构 算法与应用（c++ 描述） 自练答案
qq_57065913的博客
09-12 4635
有不正确请提出 第一章 1.1 应该把形参 换成引用 int x--> int &x 1.2 #include<iostream> using namespace std; template <class T,class T1> //模板形参的类型 int count (T array,int end,T1 value){ int i =0,count=0; while(i<...
1135 Is It A Red-Black Tree （30 分）（C++）
qq_41562704的博客
02-07 238
There is a kind of balanced binary search tree namedred-black treein the data structure. It has the following 5 properties: (1) Every node is either red or black. (2) The root is black. (3) Every...
数据结构-红黑树(Red-Black Tree)的C++实现模板
weixin_34290352的博客
08-21 143
2019独角兽企业重金招聘Python工程师标准>>> ...
算法导论之Red-Black-Tree(C语言实现)&&平衡二叉树(C++实现)
struver的博客
10-19 392
**算法导论之红黑树（C语言实现）** **与平衡二叉树（C++实现）** 红黑树： /********************************************** 红黑树有如下五个性质： 1-3：每个结点或红或黑、根节点黑、叶结点（NULL）黑 4： 若结点是红的，则孩子是黑的...
RedBlackTree.rar
07-27
此工程主要包含红黑树的插入和删除，采用C++编写，有单独的.h和.cpp文件，方便移植
数据结构、算法与应用 C++语言描述 原书第2版.pdf
最新发布
12-14
《数据结构、算法与应用 C++语言描述》第二版是一本深入探讨数据结构、算法及其在C++编程中的实现的经典著作。这本书旨在帮助读者理解和掌握数据结构和算法的基础知识，并通过C++语言来实践这些概念，提升编程能力。...
数据结构、算法与应用 C++语言描述
12-24
《数据结构、算法与应用 C++语言描述》是学习计算机科学和软件工程不可或缺的经典教材，尤其对于深入理解和实践数据结构及算法有着极其重要的作用。原书的第二版更是在第一版的基础上进行了修订和完善，旨在为读者...
数据结构算法与应用-C++语言描述.rar
02-11
本书"数据结构算法与应用-C++语言描述"很可能详细阐述了上述数据结构和算法，并提供了C++实现示例。读者通过学习，不仅可以掌握基本理论，还能了解到如何在实际编程中应用这些知识。此外，书中可能还会涵盖一些高级...
数据结构算法与应用-C++语言描述
02-25
《数据结构算法与应用-C++语言描述》是一本深度探讨数据结构和算法的书籍，它专为学习面向对象编程（OOP）的程序员设计，旨在提升他们在程序设计领域的专业技能。数据结构是计算机科学的基础，它研究如何组织和存储...
数据结构-----红黑树的插入操作
一个程序渣渣的小后院
01-05 710
红黑树是一棵二叉搜索树；树种每一个节点的颜色不是黑色就是红色。本篇中只实现用节点的颜色来描述红黑树，性质如下： RB1：根节点和所有外部节点都是黑色； RB2：在根至外部节点路径上，没有连续两个节点是红色； RB3：在所有根至外部节点的路径上，黑色节点的数目都相同； 实现红黑树，首先需要定义树节点，节点包括： 1：节点颜色，黑色或者白色，用整型或者布尔类型表示，也可以预设两个宏；
数据结构与算法——RB树简介
Be The Best！
03-28 3549
红黑树简介(RB-tree)
红黑树笔记
跨世纪逃兵的专栏
02-12 442
红黑树学习   rb1:根结点必须是黑色，空叶子结点视为是黑色 rb2:不能有两个相邻的红色节点（父节点和子节点不能同时为红色） rb3:从根结点到任意空叶子结点的路径的黑色结点数相等。 衍生推论： 1.红黑树从根结点起，最长路径比最短路径节点数比，不会超过2:1 2.以红黑树任意黑色节点为根，都是一颗红黑树 3.任意节点到外部节点的所有路径中，黑色节点数是一致的。   术语：...
RB树
yangshuangtao的专栏
07-16 1419
之前看了很多写红黑树的博客，但是感觉都讲的不太清楚！没说这样操作如何使他保持平衡的，于是疑惑重重，就看不下去了，一次不经意看到一个人说维基百科的红黑树讲的好，我就随便点了一下一看——这下疯了~，怎么讲的这么好！可以说是把一个复杂的问题，讲得简单化！这太幸福了！ 于是我就慢慢学会了！强烈推荐维基的这个讲解，再也找不到比这还好的讲解了！不知道它上边其它的怎么样，反正这个很好！！既然学会了，走过来了，我
【红黑树】RB树的实现原理
菜鸟成长记
08-18 2227
定义红黑树是一棵二叉搜索树，它在每个结点上增加了一个存储位来表示结点的颜色，可以是red或者black，通过对任何一条从根节点到叶子结点上的简单路径来约束，红黑树保证最长路径不超过最短路径的两倍，因而近似平衡。性质1. 每个结点不是红色就是黑色 2. 根节点是黑色的 3. 如果一个根节点是红色的，则它的两个叶子结点是黑色的(没有两个连续的红色结点) 4. 对于每个结点，从该结点到其所有后代叶结
红黑树结构完整实现与详解
大昱的博客
06-27 8574
红黑树结构以平衡、高效的随机访问著称。实际使用过程中，其效率超出想象(节点数量越多，效率越高)，大部分情况下查找的节点数量小于节点总量的二分之一，最长的查询路径也才是总量的二分之一加一个节点的距离。 红黑树以黑色和红色用来标记根节点、枝节点与叶节点既有优势也有劣势(当然优势大于劣势)： 优势：在多次查询节点时高度保持树型的平衡(旋转情况下，不超过三次旋转，插入数据不超过两次旋转)； ...
红-黑树——C++实现
Mind_V的博客
05-27 778
一、红-黑树基本概念红-黑树(Red-Black tree)是一种特殊的二叉查找树，因此具有二叉查找树的特征：任意一个节点所包含的关键字，大于左孩子的关键字，小于右孩子的关键字。树中每一个节点的颜色或者是黑色或者是红色，和AVL树一样具有平衡性。每一个空指针用一个外部结点来替代，红-黑树的性质可以描述为：RB1：根节点和外部节点都是黑色。 RB2：在根至外部节点路径上，没有连续两个节点是红色。
终于搞懂红黑树！--红黑树的原理及操作
lzzw的学习之路
07-30 9521
红-黑-树 介绍： 红黑树（ Red black tree）是种自平衡二叉查找树，在计算机科学中用到的一种数据结构。 它是在1972年由 Rudolf Bayer发明的当时被称为平衡二叉B树（ symmetric binary B-trees）。后来，在1978年被 Leo. guibas和 Robert sedgewick修改为如今的红黑树R-B Tree，全称是Red- Blac...
C++实现数据结构算法：链表、树、堆、图与排序
"该资源是关于使用C++实现数据结构中常见算法的详细教程，涵盖了从基础的数据结构如链表、队列到复杂的红黑树、堆和哈夫曼树等，同时也包括了排序算法的实现。每个数据结构都有对应的头文件、实现文件以及测试文件，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jasmine-Lily

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值