【C++进阶5-红黑树】噩梦般的存在？手提AVLTree暴揍红黑树！

已于 2023-06-06 13:25:32 修改
阅读量276 收藏 13
点赞数 17
分类专栏： C++ 文章标签： c++ 数据结构 算法
于 2023-06-01 21:38:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BaconZzz/article/details/130996368
版权

今天，带来无数人的噩梦——红黑树的讲解。文中不足错漏之处望请斧正！

如果还没看过AVLTree讲解的一定要去看看，看完才能更好理解红黑树！

是什么

红黑树是自平衡的二叉搜索树。

红黑树的规则:

  1. 每个结点非黑即红
    1. 根结点为黑
    2. 叶子结点为黑（此处的叶子结点指空结点）
  2. 不能有连续的红结点，但可以有连续的黑结点
  3. 每条简单路径上的黑结点数量相同

满足以上规则，就能保证最长路径不超过最短路径的二倍，保持了一种相对宽松的平衡。

实现

*为了降低学习成本，部分细节先略过，等封装map和set再添上。

结构

enum Color
{
    RED, BLACK
};

template<class K, class V>
struct RBTreeNode
{
    pair<K, V> _kv;
    RBTreeNode<K, V>* _left;
    RBTreeNode<K, V>* _right;
    RBTreeNode<K, V>* _parent;
    Color _clr;
    
    RBTreeNode(const pair<K, V>& kv)
    :_left(nullptr),
    _right(nullptr),
    _parent(nullptr),
    _kv(kv),
    _clr(RED)
    {}
};

template<class K, class V>
class RBTree
{
    typedef RBTreeNode<K, V> Node;
public:
		...
private:
		Node* _root = nullptr;
};

结点默认红色？往后看。

Insert

实现思路

BST插入总是找位置+插入，插入后只要保持红黑树的规则不被打破就可以。

新插入的结点设为什么颜色？

设为黑色：必然打破“黑结点数量相同”的规则。

设为红色：可能打破“不能有连续的红节点”的规则。（如果父亲是黑，就不会打破规则）

那自然设为红色。

我们要维持的规则主要就是上面两条。

注：

  • 称新插入的结点为cur
  • 称cur的父结点为parent
  • 称parent除cur外的另一孩子为uncle
  • 称parent的父结点为grandParent

插入新结点cur后：

  1. parent为黑：不打破规则，插入结束
  2. parent为红：打破规则，调整
    1. uncle为红：直接着色
    2. uncle不存在/为黑：旋转+着色

为什么根据uncle就能判断？

若插入后需要调整：

  1. parent必然为红
  2. grandParent必然为黑（不能有连续的红结点）

既然cur、parent、grandParent都确定了，那我们只用根据u来分类即可。

  1. uncle为红
  2. uncle不存在
  3. uncle为黑

情况1：u为红（抽象图）

u为红，直接改色。

在这里插入图片描述

  1. cur为红，parent为红打破了“不能有连续红节点”，所以p必须变黑
  2. parent变黑，到parent的简单路径上都增加了一个黑节点，因为“每条简单路径上黑节点数量相同”，所以到uncle的简单路径上也需要多一个黑节点
  3. 我们还需要考虑g是子树还是根
    1. 若是子树，变红没毛病，但g变红可能向上影响（如果g的parent是红，就打破“不能有连续红结点的规则”），所以我们需要把g当做新一轮的cur继续往后看是否需要调整
    2. 若是根，需要重新变黑（根结点必须是黑色）

在这里插入图片描述

u为红直接变色：p变黑、u变黑、g变红

  1. 当g为根→g变黑
  2. 当g不为根→g作新cur往上走
  3. 当p为黑就停（最差走到默认为黑的根结点）

情况2：u不存在

u不存在，单旋+变色。

u不存在，则cur一定是新增。因为u不存在，就代表右边没有黑，那左边也没有黑：p为红，cur也为红，且没有其他黑，那么cur一定是新增。

在这里插入图片描述

  • p是g的左孩子 = 左高 = 右单旋+变色（g变红，p变黑）
  • p是g的右孩子 = 右高 = 左单旋+变色（g变红，p变黑）
  • 旋转后不向上影响，调整结束

情况3：u为黑，整体过高

*有了AVLTree的积累，我们这就只讲一种单旋，另一种同理，反过来而已

在这里插入图片描述

  • p是g的左孩子、cur是p的左孩子 = 整体左高 = 右单旋+变色（g变红，p变黑）
  • p是g的右孩子、cur是p的右孩子 = 整体右高 = 左单旋+变色（g变红，p变黑）
  • 旋转后不向上影响（不会导致和上面出现连续的红节点，被旋转的部分也没有徒增给节点），调整结束

情况4：u为黑，整体过高且局部过高

在这里插入图片描述

  • p是g的左，cur是p的右 = 高左中右高 = 先对p左单旋，再对g右单旋，最后变色（cur变黑、g变红）
  • p是g的右，cur是p的左 = 高右中左高 = 先对p右单旋，再对g左单旋，最后变色（cur变黑、g变红）
  • 旋转后不向上影响，调整结束

旋转总结

到这里我们发现情况2、3、4有些相似之处，所以我们可以进一步分类：

  1. 种类1：
    1. u为红——直接变色并向上调整
  2. 种类2：
    1. u不存在/u为黑且规则高——单旋+变色解决
    2. u为黑且不规则高——双旋+变色解决

最后，我们要推理一个结论来圆满RBTree调平衡的合理性：种类2一定是由种类1变化而来的。

在这里插入图片描述

依照这个结论：种类1通过变色后向上调整，要么直接解决问题，要么演变为种类2，而种类2旋转后必然能解决问题，那么红黑树的调整我们也就必然解决干净了。

调整参考代码

while (parent && parent->_clr == RED) {
    Node *grandParent = parent->_parent;

    if(parent == grandParent->_left) {
        Node *uncle = grandParent->_right;
        //种类1: 直接变色
        if (uncle && uncle->_clr == RED) {
            parent->_clr = uncle->_clr = BLACK;
            grandParent->_clr = RED;

            cur = grandParent;
            parent = cur->_parent;
        } else { //种类2: 旋转+变色
            if(cur == parent->_left) { //整体过高: 单旋
                rotateR(grandParent);
                parent->_clr = BLACK;
                grandParent->_clr = RED;
            } else { //整体过高+局部过高: 双旋
                rotateL(parent);
                rotateR(grandParent);
                cur->_clr = BLACK;
                grandParent->_clr = RED;
            }
            break; //旋转后不再向上影响，结束调整
        }
    } else { //相反而已
        Node *uncle = grandParent->_left;

        if (uncle && uncle->_clr == RED) {
            parent->_clr = uncle->_clr = BLACK;
            grandParent->_clr = RED;

            cur = grandParent;
            parent = cur->_parent;
        } else {
            if(cur == parent->_right) {
                rotateL(grandParent);
                parent->_clr = BLACK;
                grandParent->_clr = RED;
            } else {
                rotateR(parent);
                rotateL(grandParent);
                cur->_clr = BLACK;
                grandParent->_clr = RED;
            }
            break;
        }
    }
}

旋转参考代码

	void rotateL(Node *parent) {
        Node *subR = parent->_right;
        Node *subRL = subR->_left;
        Node *grandParent = parent->_parent;

        //1. subRL变成parent的右子树
        parent->_right = subRL;
        if (subRL) subRL->_parent = parent;

        //2. parent变成subR的左子树
        subR->_left = parent;
        parent->_parent = subR;

        //3. subR变成局部根或整体根
        if (grandParent == nullptr) { //整体根
            _root = subR;
            _root->_parent = nullptr;
        } else { //局部根
            subR->_parent = grandParent;
            if (parent == grandParent->_left) grandParent->_left = subR;
            if (parent == grandParent->_right) grandParent->_right = subR;
        }
    }

    void rotateR(Node *parent) {
        Node *subL = parent->_left;
        Node *subLR = subL->_right;
        Node *grandParent = parent->_parent;

        //1. subLR变成parent的左
        parent->_left = subLR;
        if (subLR) subLR->_parent = parent;

        //2. parent变成subL的右
        subL->_right = parent;
        parent->_parent = subL;

        //3. subL变成局部根或整体根
        if (grandParent == nullptr) { //整体根
            _root = subL;
            _root->_parent = nullptr;
        } else { //局部根
            subL->_parent = grandParent;
            if (parent == grandParent->_left) grandParent->_left = subL;
            if (parent == grandParent->_right) grandParent->_right = subL;
        }
    }

Insert参考代码

	bool insert(const pair <K, V> &kv) {
        if (_root == nullptr) {
            _root = new Node(kv, BLACK); //根节点必须是黑的
            return true;
        }

        //1. 找位置
        Node *cur = _root;
        Node *parent = nullptr;
        while (cur) {
            parent = cur;
            if (kv.first < cur->_kv.first) {
                cur = cur->_left;
            } else if (kv.first > cur->_kv.first) {
                cur = cur->_right;
            } else if (kv.first == cur->_kv.first) {
                return false;
            } else { assert(false);}
        }

        //2. 插入
        cur = new Node(kv); //默认红色
        cur->_parent = parent;
        if (kv.first < parent->_kv.first)
            parent->_left = cur;
        else
            parent->_right = cur;

        //3. parent的clr为红，向上影响了，需要调整
        while (parent && parent->_clr == RED) {
            Node *grandParent = parent->_parent;

            if(parent == grandParent->_left) {
                Node *uncle = grandParent->_right;
                //种类1: 直接变色
                if (uncle && uncle->_clr == RED) {
                    parent->_clr = uncle->_clr = BLACK;
                    grandParent->_clr = RED;

                    cur = grandParent;
                    parent = cur->_parent;
                } else { //种类2: 旋转+变色
                    if(cur == parent->_left) { //整体过高: 单旋
                        rotateR(grandParent);
                        parent->_clr = BLACK;
                        grandParent->_clr = RED;
                    } else { //整体过高+局部过高: 双旋
                        rotateL(parent);
                        rotateR(grandParent);
                        cur->_clr = BLACK;
                        grandParent->_clr = RED;
                    }
                    break; //旋转后不再向上影响，结束调整
                }
            } else { //相反而已
                Node *uncle = grandParent->_left;

                if (uncle && uncle->_clr == RED) {
                    parent->_clr = uncle->_clr = BLACK;
                    grandParent->_clr = RED;

                    cur = grandParent;
                    parent = cur->_parent;
                } else {
                    if(cur == parent->_right) {
                        rotateL(grandParent);
                        parent->_clr = BLACK;
                        grandParent->_clr = RED;
                    } else {
                        rotateR(parent);
                        rotateL(grandParent);
                        cur->_clr = BLACK;
                        grandParent->_clr = RED;
                    }
                    break;
                }
            }
        }

        _root->_clr = BLACK; //根节点始终为黑
        return true;
    }

其实红黑树还有multi版本，允许重复，有insert_unique和insert_equal，至于相同的插入在左边还是右边就无所谓了，因为高度过大后需要旋转，而不管是插入哪边旋转后的结果都一样。

测试

红黑树的测试不像以前那样打印点信息就能解决，而是要写个方法来确定我们的树100%没问题——颜色没问题、路径长度也没问题。


...
//测试
public:
    //测试RBTree：
    //颜色正确 == 路径长度正确
    //路径长度正确 != 颜色正确
    void inorder() { inorder(_root);}

    bool isBlance()
    {
        if(_root == nullptr) return true;

        if(_root->_clr == RED)
        {
            cout << "违反规则：根为红" << endl;
            return false;
        }

        int refVal = 0;
        Node* left = _root;
        while(left)
        {
            if(left->_clr == BLACK) ++refVal;
            left = left->_left;
        }

        return check(_root, 0, refVal);
    }

private:
    void inorder(Node* root)
    {
        if(root == nullptr) return;

        inorder(root->_left);
        cout << root->_kv.first << ":" << root->_kv.second << endl;
        inorder(root->_right);
    }

    bool check(Node* root, int blackCnt, const int& refVal)
    {
        if(root == nullptr)
        {
            if(blackCnt != refVal)
            {
                cout << "违反规则：黑色结点数量不同" << endl;
                return false;
            }
            return true;
        }

        if(root->_clr == RED && root->_parent->_clr == RED)
        {
            cout << "违反规则：出现了连续红色节点" << endl;
            return false;
        }

        if(root->_clr == BLACK) ++blackCnt;

        return check(root->_left, blackCnt, refVal)
               && check(root->_right, blackCnt, refVal);
    }
};

void testRBTree()
{
//    int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};
    int a[] = {16, 3, 7, 11, 9, 26, 18, 14, 15};
//    int a[] = {4, 2, 6, 1, 3, 5, 15, 7, 16, 14};

    RBTree<int, int> t;
    for(auto e : a) {
        t.insert(make_pair(e, e));
    }
    t.inorder();
    cout << t.isBlance() << endl;
}

#include <iostream>
using namespace std;
#include "RBTree.h"

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

3:3
7:7
9:9
11:11
14:14
15:15
16:16
18:18
26:26
1

为什么Inorder要弄成子函数或者函数重载？

因为类外调用Inorder时得传参，_root是私有成员，想传也没办法访问到私有成员。

对比AVLTree

对平衡的要求没那么严格，插入删除的时候就会少很多旋转。虽然单次查找效率效率是2logN，但对于CPU来说logN和2logN区别很小，红黑树总体来说效率是更高的。

性能分析

红黑树是近似平衡的树，没有什么最坏情况，插入的时间复杂度为O(log(N))，查找也是。

应用场景

  1. C++的STL
  2. Java的库
  3. Linux内核
  4. 其他库
  5. …

今天的分享就到这里了，感谢您能看到这里。

这里是培根的blog，期待与你共同进步！

周杰偷奶茶
关注
  • 17
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 21
    评论
专栏目录
AVL-红黑树-前缀树
05-16
AVL树、红黑树和前缀树是数据结构与算法中的重要概念，它们在高效地存储和检索数据方面有着广泛的应用。以下是关于这三种数据结构的详细解释： 1. AVL树： AVL树是一种自平衡二叉搜索树，由G. M. Adelson-Velsky和E...
map与set的底层大概框架-红黑树
04-04
这是一个红黑树大框架， 红黑树之中比较重要的就是旋转操作。 在本文件中， 两个旋转操作都包含在内。 接口主要有插入， 寻找， 判断是否为一棵红黑树等等的代码。 一共五百行左右。 学习map和set的友友们如果对红黑...
AVL 红黑树 SBT-2020.12.11.pdf
12-11
虽然AVL树和红黑树都是自平衡二叉搜索树，但它们在某些方面存在差异： - **平衡程度**：AVL树的高度平衡程度更高，而红黑树则更宽松一些。 - **插入删除效率**：由于AVL树需要更多的旋转来保持高度平衡，因此在插入...
红黑树-基于Java实现的红黑树数据结构.zip
03-21
红黑树是一种自平衡二叉查找树，由计算机科学家Rudolf Bayer在1972年提出，它的设计目标是兼顾查找、插入和删除等操作的高效性。红黑树的每个节点都带有颜色属性，可以是红色或黑色，通过颜色规则确保了树的平衡，...
用python实现AVL树、B树、红黑树的插入、查找和删除操作
10-16
在计算机科学中，数据结构是程序设计的基础，而平衡查找树（如AVL树、B树和红黑树）是高效存储和检索数据的关键结构。本文将深入探讨如何使用Python实现这三种平衡查找树的插入、查找和删除操作，并通过实际运行测试...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1175
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 258
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1121
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
C++ | Leetcode C++题解之第275题H指数II
Ddddddd_158的博客
07-23 361
C++ | Leetcode C++题解之第275题H指数II
Delphi5实现鱼C屏幕保护程序
weixin_52116519的博客
07-24 342
使用Form1的events的oncreate事件，双击命名为FormCreate。即上面的“- □ ×”不显示。
C++ 红黑树
wxk2227814847的博客
07-22 1097
在之前的文章中，我们介绍了 C++ 标准库中的 map 和 set 容器的使用，以及 AVL 树的实现。尽管 AVL 树在平衡性方面表现优异，但在插入和删除操作频繁的应用中，红黑树（Red-Black Tree）由于其较少的旋转操作次数，往往能提供更优的性能。本篇博客将详细介绍红黑树的概念、性质、节点定义、结构、插入与删除操作、性能、迭代器设计，并展示基于红黑树的模拟实现代码及其在 map 容器中的应用。
C++中的模板函数和模板类
2302_81171591的博客
07-22 672
T1 ,classT2 ,... ,classTnclass类模板名//类内成员定义。
linux C++ onnxruntime yolov8 视频检测Demo
.NET 人工智能实践
07-23 702
linux C++ onnxruntime yolov8 视频检测Demo
＜＜C++ Primer Plus（第6版）＞＞12.1 动态内存和类：知识记录
最新发布
gsp1004的博客
07-25 826
虽然原书中提到用等号来初始化值可能会导致调用赋值运算符(多执行赋值的步骤，效率低)，但是我实测并没有此问题。当然，这个结果是符合预期的，毕竟明明是没必要去多执行一次赋值运算符来赋值的。但是不排除别的环境，别的VS版本，甚至在别的优化等级下表现不同。所以建议自行测试。即便如此，还是建议初始化一个对象使用变量后面用括号赋值初始化的值的方式: StringBad ditto(motto);来规避可能的歧义和不确定的执行流程。默认的复制构造函数和默认的赋值运算符都是浅拷贝/浅复制。
【C++】详解 set | multiset
2301_80171004的博客
07-22 1325
本文探讨了C++标准模板库中set与multiset容器的使用，涵盖构造、插入、查找、删除等基本操作，并解析lower_bound、upper_bound及equal_range函数的高效区间搜索机制，为高效数据管理提供实战指南。
洛谷 P10732 [NOISG2019 Prelim] Palindromic FizzBuzz
wang__1233的博客
07-23 435
这题是判断 S 和 E 的区间的数是否为回文数，而回文数有一个非常简单的判断方法，那就是把数字用 to_string 转成然后复制下来，接着将复制来的通过 reverse 反转，最后判断两个字符串是否相同即可。
学懂C语言（十五）：C语言递归函数在实际应用中的要点，关键点
martian665的专栏
07-22 962
C语言递归函数在实际应用中的要点，关键点
[C++]友元
weixin_45843323的博客
07-22 586
友元提供了一种机制，允许特定的函数或类访问另一个类的私有和保护成员。友元函数不是类的成员函数，但可以通过对象访问类的私有成员。友元类可以访问另一个类的所有私有和保护成员。友元关系破坏了封装性，应谨慎使用。友元函数和友元类都可以被重载。
STL 哈希 学习总结
gma999的博客
07-23 689
哈希是通过特定的算法，将任意长度的数据映射为固定长度的数据串中。该映射的结果就被称为哈希值，也可以称为散列值。例如在存储一个10000这个数据的时候，如果使用数组的话，则需要开辟对应大小空间内存，其他位置又不一定存储数据，所以这样就会造成数据的浪费。那么此时如果将这个数除以一个特定的数字，然后再将其存储到除数的结果下标中去，这样就避免了空间的浪费。哈希函数哈希值。
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

周杰偷奶茶

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

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

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

打赏作者

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

抵扣说明：

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

余额充值