数据结构——手撕红黑树（开肝！）

最新推荐文章于 2023-02-22 19:21:54 发布
最新推荐文章于 2023-02-22 19:21:54 发布
阅读量502 收藏 3
点赞数 5
分类专栏： 数据结构学习 文章标签： 数据结构 c++ 树结构 算法 其他
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48201696/article/details/119456759
版权

数据结构——红黑树（开撕！）

红黑树介绍

在查找算法中，二叉搜索树是一种查找速度非常快的数据结构，平均查找事件复杂度可以达到O(log2(n))但是对于二叉搜索树，其查找性能还是不太稳定,如下面一颗二叉搜索树，如果要查找5这个结点所在的位置，查找过程依然要达到5次，也即线性查找时间，要保证查找速度稳定控制在**O(log2(n))**左右，就需要对这颗二叉搜索树维持平衡，保证其查找速度

在这里插入图片描述

所以在二叉搜索树的基础上，有了红黑树这种维护二叉搜索树平衡，保证查找速度保持在对数级别的数据结构，对于红黑树，其结点定义除了二叉搜索树的配置之外，还有一个本身颜色的标识，一颗红黑树首先必须满足是二叉搜索树，然后它有下列的规定，这是笔者在一个教程中摘录下来的

1、Every Node is BLACK or RED

2、Root node must be BLACK

3、New insections are always RED

4、Every path from root to leaf has the same number of BLACK nodes

5、No path can have two consecutive RED nodes

6、Every null node is BLACK node

总结下来就是

  • 红黑树结点只有两种颜色，红色和黑色
  • 根结点必须为黑色
  • 所有新插入的结点在重构红黑树之前都是红色
  • 从根结点到每一个叶子结点所经过的路径黑色结点的个数相同
  • 任意一条路径中都不会存在两个相连的红色结点（即红色结点的孩子结点颜色必定是黑色）
  • 空的结点被认定为黑色结点

下面有一个动画，演示了依次插入(3,1,5,7,8,9,10)这几个关键字，红黑树的变化过程
在这里插入图片描述

从上面的动画中，红黑树的重构大致细分为一些下列情况

  1. 异常出现在祖母结点的左边

    • 在父亲结点左侧插入结点

      • 父亲结点与叔叔结点颜色不同

    在这里插入图片描述

    • 父亲结点与叔叔结点颜色相同

在这里插入图片描述

  • 在父亲结点的右侧插入结点

    • 父亲结点与叔叔结点颜色不同

在这里插入图片描述

  • 父亲结点与叔叔结点颜色相同

在这里插入图片描述

  1. 异常出先在祖母结点的右边

    • 在父亲结点左侧插入结点

      • 父亲结点与叔叔结点颜色不同

在这里插入图片描述

 父亲结点与叔叔结点颜色相同

在这里插入图片描述

  • 在父亲结点右侧插入结点

    • 父亲结点与叔叔结点颜色不同

在这里插入图片描述

 父亲结点与叔叔结点颜色不同

、在这里插入图片描述

肝代码

红黑树的冲突判断情况涉及到一共四个结点的判断，分别是冲突结点x，最上层结点祖母结点g，祖母结点的儿子，冲突结点的父亲父亲结点p，以及祖母结点的儿子，冲突结点的叔叔叔叔结点u，总结上述的八种情况，可以总结出一个更一般的规律，在发生冲突的情况下

  • 叔叔结点与父亲结点不同色，需要进行旋转操作
  • 叔叔结点与父亲结点同色，则需要将祖母结点与父亲结点和叔叔结点的颜色进行翻转

更复杂的红黑树的构造，也不过只是将这些步骤整合到一起，去构造一颗更复杂的红黑树，下面来分析代码实现,首先用C++来试试水

为了突出红黑树的特性，就不用泛型编程了，能省一个是一个哈哈哈,不这不是博主不会，这是为突出重心哈哈哈哈

在这里插入图片描述

数据组织

# include<iostream>
# define RED true  //树结点颜色的标识宏定义
# define BLACK false

using KeyType = int;  //关键字

typedef struct node{
    KeyType key;  
    bool color; //结点颜色标识
    node* left; //左孩子
    node* right; //右孩子
    node(KeyType key):key(key){
        color = RED;
        left = nullptr;
        right = nullptr;
    }
} RbtTree;

往红黑树中插入结点

从上面的情况分析中可以看到，需要重建红黑树的情况只有一种，那就是***往红色结点下面插入结点时***会导致冲突，需要重新平衡红黑树，即rebalance操作，当

  • 叔叔结点与父亲结点颜色不相同时，需要进行旋转操作
  • 叔叔结点与父亲结点颜色相同时，需要进行颜色翻转操作

实现这个思路，需要一些步骤

1、怎么去找到冲突位置？

  • 这个问题很好理解，当往一个红黑树的红色结点处插入一个结点时，就出现了冲突，也就是说，一条路径上不可能存在两个连着的红色结点

2、怎么对冲突情况进行区分？

  • 也就是前面说的，颜色相同与颜色不相同的问题

3、怎么在恢复当前冲突位置之后，去检查上层是否条件满足，逐级检查上去？

  • 可以从上到下，逐级恢复上去

那么大致思路就是这样，首先按照二叉搜索树的插入方法，将一颗红色结点插入，然后对这棵树进行rebalance，从根往下找冲突，并且从下面往上面解决冲突

1、首先是集成起来的外部接口，传入的参数root一定是根结点，在中间调用了插入二叉搜索树结点和重新恢复红黑树的方法，并在最后维护根结点为黑色

//首先是insertNode，它的结构如下
void insertNode(RbtTree *&root,KeyType key){
    if(root == nullptr){
        root = new RbtTree(key);
    }else{
        if(key < root->key){
            insert(root->left,key); //依照二叉搜索树的形式先插入结点
        }else if(key > root->key){
            insert(root->right,key);
        }
    }
    rebalance(root);  //对以root为根结点的红黑树进行维护
    //维护根结点为黑色的情况
    root->color = BLACK;
}

2、insert就是简简单单的插入二叉搜索树的方法

void insert(RbtTree *&root,KeyType key){
    if(root == nullptr){
        root = new RbtTree(key);
    }else{
        if(key < root->key){
            insert(root->left,key);
        }else if(key > root->key){
            insert(root->right,key);
        }
    }
}

3、第三个也是最难理解的，代码也是最长的…

img

依照当前的思路，从下往上维护红黑树，下面的语句也就是对上面分析的八种情况的操作，可能这样的写法有的不太简洁，但是按照逻辑来还是比较好理解

img

void rebalance(RbtTree *&root){
    //从根结点开始查找冲突结点
    if(root == nullptr)
        return;
    else{
        rebalance(root->left);  
        rebalance(root->right);
        //(1)、在祖母的左边插入结点导致的不平衡
          //a、在(1)的条件下在父亲的左边插入结点
            //1、在(1)a的条件下父亲与叔叔的颜色不同，叔叔为nil
        if(root->left != nullptr && root->color == RED
        && root->left->left != nullptr&& root->left->left->color == RED
        && (root->right == nullptr)){
            //先进行父祖换色，然后进行右旋操作
            root->left->color = BLACK;
            root->color = RED;
            RbtTree *p = root->left;
            root->left = p->right;
            p->right = root;
            root = p;
        }
            //2、在(1)a的条件下，父亲与叔叔的颜色相同，都为红色结点
        else if(root->left != nullptr && root->color == RED
        && root->left->left != nullptr&& root->left->left->color == RED
        && root->right != nullptr && root->right->color == RED){
            //进行颜色翻转
            root->color = RED;
            root->left->color = BLACK;
            root->right->color = BLACK;
        }
          //b、在(1)的条件下，在父亲的右边插入结点
            //1、在(1)b的条件下，父亲与叔叔的颜色不同，叔叔为nil或者黑色结点
        else if(root->left != nullptr && root->left->color == RED
        && root->left->right != nullptr && root->left->right->color == RED
        && root->right == nullptr){
            //先交换子祖颜色，然后左旋再右旋
            root->color = RED;
            root->left->right->color = BLACK;
            RbtTree *p = root->left->right;
            root->left->right = root->left->right->left;
            root->left = p->right;
            p->left = root->left;
            p->right = root;
            root = p;
        }
            //2、在(1)b的条件下，父亲与叔叔颜色相同，都为红色
        else if(root->left != nullptr && root->left->color == RED
        && root->left->right != nullptr && root->left->right->color == RED
        && root->right != nullptr && root->right->color == RED){
            //颜色翻转
            root->color = RED;
            root->left->color = BLACK;
            root->right->color = BLACK;
        }
        //(2)、在祖母的右边插入结点导致的不平衡
          //a、在(2)的条件下在父亲的右边插入结点
            //1、在(2)a的条件下，父亲与叔叔的颜色不同，叔叔为nil
        else if(root->right != nullptr && root->right->color == RED
        && root->right->right != nullptr && root->right->right->color == RED
        && root->left == nullptr){
            //父祖换色，左旋操作
            root->color = RED;
            root->right->color = BLACK;
            RbtTree *p = root->right;
            root->right = p->left;
            p->left = root;
            root = p;
        }
            //2、在(2)a的条件下，父亲与叔叔的颜色相同，都为红色
        else if(root->right != nullptr && root->right->color == RED
        &&root->right->right != nullptr && root->right->right->color == RED
        &&root->left != nullptr && root->left->color == RED)  {
            //颜色翻转
            root->color = RED;
            root->left->color = BLACK;
            root->right->color = BLACK;
        }
          //b、在(2)的条件下，在父亲的左边插入结点
            //1、在(2)b的条件下，父亲与叔叔的颜色不同，叔叔为nil
        else if(root->right != nullptr && root->right->color == RED
        &&root->right->left != nullptr && root->right->left->color == RED
        &&root->left == nullptr){
            //子祖换色，先右旋再左旋操作
            root->color = RED;
            root->right->left->color = BLACK;
            RbtTree *p = root->right->left;
            root->right->left = p->right;
            p->right = root->right;
            root->right = p->left;
            p->left = root;
            root = p;
        }
            //2、在(2)b的条件下，父亲与叔叔的颜色相同，都为红色
        else if(root->right != nullptr && root->right->color == RED
        && root->right->left != nullptr && root->right->left->color == RED
        &&root->left != nullptr && root->left->color == RED){
            //颜色翻转
            root->color = RED;
            root->left->color = BLACK;
            root->right->color = BLACK;
        }
        else
            return;
    }
}

4、然后就是测试方法了，我写了三个遍历,先序、中序、后序

void midOrder(RbtTree *root){
    if(root == nullptr)
        return;
    midOrder(root->left);
    if(root->color){
        cout<<"("<<root->key<<" , "<<"RED)  ";
    }else{
        cout<<"("<<root->key<<" , "<<"BLACK)  ";
    }
    midOrder(root->right);
}

void prevOrder(RbtTree *root){
    if(root == nullptr)
        return;
    if(root->color){
        cout<<"("<<root->key<<" , "<<"RED)  ";
    }else{
        cout<<"("<<root->key<<" , "<<"BLACK)  ";
    }
    prevOrder(root->left);
    prevOrder(root->right);
}

void lasteOrder(RbtTree *root){
    if(root == nullptr)
        return;
    lasteOrder(root->left);
    lasteOrder(root->right);
    if(root->color){
        cout<<"("<<root->key<<" , "<<"RED)  ";
    }else{
        cout<<"("<<root->key<<" , "<<"BLACK)  ";
    }
}

5、最后在main函数上测试上面git动图上面的红黑树插入状态，并观察其插入情况，发现运行结果与gif动图中演示的红黑树插入过程十分吻合

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

void shuchu(RbtTree *roots){
    RbtTree *root = roots;
    cout<<"##############\n";
    prevOrder(root);
    cout<<endl;
}

int main(){
    RbtTree *root = nullptr;
    insertNode(root,3);
    shuchu(root);
    insertNode(root,1);
    shuchu(root);
    insertNode(root,5);
    shuchu(root);
    insertNode(root,7);
    shuchu(root);
    insertNode(root,8);
    shuchu(root);
    insertNode(root,9);
    shuchu(root);
    insertNode(root,10);
    shuchu(root);
    return 0;
}

运行结果

在这里插入图片描述

如何去验证一颗树是红黑树？

对于这个问题，抓住前面对红黑树性质的规定，对于一颗红黑树

  • 任意一条路径不会存在两个相连的红色结点
  • 从根结点出发到叶子结点总会经过相同的黑色结点数量

也就是说，一颗树要满足红黑树，也就必须满足上面两个条件，缺一不可，相当于这两个条件求与，可以先写两个判断方法，一个方法判断一个条件，最后综合到一起

//判断任意一条路径是否存在相连的两个红色结点，如果存在返回true，如果不存在返回false
bool hasConnectRedNode(RbtTree *root){
    if(root == nullptr)
        return false;
    else{
        if(root->color == BLACK){
            return hasConnectRedNode(root->left) || hasConnectRedNode(root->right);
        }else{
            if(root->left != nullptr && root->left->color == RED){
                return true;
            }else if(root->right != nullptr && root->right->color == RED){
                return true;
            }else{
                return hasConnectRedNode(root->right) || hasConnectRedNode(root->left);
            }
        }
    }
}

//从根结点出发，访问所有叶子结点，看经过的黑色结点数量是否都相等
/**
 * 因为要满足从根结点出发到叶子结点的所有路径经过的黑色结点的数量必须是一个常数
 * 那么先走一条路径，把这个常数求出来，然后再去跟其它路径对比
 * @param root
 * @return
 */
bool isPathCommonBlackNode(RbtTree *root){
    if(root == nullptr)
        return true;
    int nodecount = 0;
    RbtTree *q = root;
    while(q != nullptr){
        if(q->color == BLACK)
            nodecount++;
        q = q->left;
    }
    return isPathCommonBlackNode(root,0,nodecount);
}


bool isPathCommonBlackNode(RbtTree *root, int i, const int nodecount) {
    if(root == nullptr){
        return true;
    }
    else{
        if(root->color == BLACK){
            i++;
        }
        if(root->left == nullptr && root->right == nullptr){
            if(i != nodecount)
                return false;
            else
                return true;
        }else{
            return isPathCommonBlackNode(root->left,i,nodecount) && isPathCommonBlackNode(root->right,i,nodecount);
        }
    }
}

最后将这两个方法综合到一起

//判断一个结点是不是红黑树
bool isRBTree(RbtTree *root){
    return !hasConnectRedNode(root) && isPathCommonBlackNode(root);
}

然后把添加的方法再次放到main函数中进行测试

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

void shuchu(RbtTree *root){
    cout<<"##############\n";
    prevOrder(root);
    cout<<endl;
    if(isRBTree(root)){
        cout<<"is RBTree\n";
    }else{
        cout<<"isn't RBTree\n";
    }
}

int main(){
    RbtTree *root = nullptr;
    insertNode(root,3);
    shuchu(root);
    insertNode(root,1);
    shuchu(root);
    insertNode(root,5);
    shuchu(root);
    insertNode(root,7);
    shuchu(root);
    insertNode(root,8);
    shuchu(root);
    insertNode(root,9);
    shuchu(root);
    insertNode(root,10);
    shuchu(root);
    return 0;
}

得到的结果为

在这里插入图片描述

在写的过程中，笔者又对上面红黑树插入结点的代码进行了优化，因为有些条件可以整合到一起，因为他们的操作是一样的,但是保留了上面的代码，是为了让思路清晰一点,从上面分析的条件中可以看到，对于叔叔和父亲相同颜色的情况，只需要将颜色翻转即可

在这里插入图片描述

void rebalance1(RbtTree *&root){
    //从根结点开始查找冲突结点
    if(root == nullptr)
        return;
    else{
        rebalance(root->left);
        rebalance(root->right);
        //(1)、在祖母的左边插入结点导致的不平衡
        //a、在(1)的条件下在父亲的左边插入结点
        //1、在(1)a的条件下父亲与叔叔的颜色不同，叔叔为nil
        if(root->left != nullptr && root->color == RED
        && root->left->left != nullptr&& root->left->left->color == RED
        && (root->right == nullptr)){
            //先进行父祖换色，然后进行右旋操作
            root->left->color = BLACK;
            root->color = RED;
            RbtTree *p = root->left;
            root->left = p->right;
            p->right = root;
            root = p;
        }
        //b、在(1)的条件下，在父亲的右边插入结点
        //1、在(1)b的条件下，父亲与叔叔的颜色不同，叔叔为nil或者黑色结点
        else if(root->left != nullptr && root->left->color == RED
        && root->left->right != nullptr && root->left->right->color == RED
        && root->right == nullptr){
            //先交换子祖颜色，然后左旋再右旋
            root->color = RED;
            root->left->right->color = BLACK;
            RbtTree *p = root->left->right;
            root->left->right = root->left->right->left;
            root->left = p->right;
            p->left = root->left;
            p->right = root;
            root = p;
        }
        //(2)、在祖母的右边插入结点导致的不平衡
        //a、在(2)的条件下在父亲的右边插入结点
        //1、在(2)a的条件下，父亲与叔叔的颜色不同，叔叔为nil
        else if(root->right != nullptr && root->right->color == RED
        && root->right->right != nullptr && root->right->right->color == RED
        && root->left == nullptr){
            //父祖换色，左旋操作
            root->color = RED;
            root->right->color = BLACK;
            RbtTree *p = root->right;
            root->right = p->left;
            p->left = root;
            root = p;
        }
        //b、在(2)的条件下，在父亲的左边插入结点
        //1、在(2)b的条件下，父亲与叔叔的颜色不同，叔叔为nil
        else if(root->right != nullptr && root->right->color == RED
        &&root->right->left != nullptr && root->right->left->color == RED
        &&root->left == nullptr){
            //子祖换色，先右旋再左旋操作
            root->color = RED;
            root->right->left->color = BLACK;
            RbtTree *p = root->right->left;
            root->right->left = p->right;
            p->right = root->right;
            root->right = p->left;
            p->left = root;
            root = p;
        }
        else if(root->left != nullptr && root->left->color == RED
        && root->right != nullptr && root->right->color == RED
        &&((root->right->left != nullptr && root->right->left->color == RED)
        ||(root->right->right != nullptr && root->right->right->color == RED)
        ||(root->left->right != nullptr && root->left->right->color == RED)
        ||(root->left->left != nullptr && root->left->left->color == RED)
        )){
            //进行颜色翻转
            root->color = RED;
            root->left->color = BLACK;
            root->right->color = BLACK;
        }
        else
            return;
    }
}

最后得到的测试结果也是一样的

在这里插入图片描述

最后的话

红黑树是查找算法中喜欢被用到的一种数据结构，比如像Java中的ConcurrentHashMap，和一些架构中，也是面试官经常问的一个问题，它有着十分优异的性能，虽然平均查找速度比平衡二叉树差了点，但是整体性能包括重构红黑树的性能是打爆平衡二叉树的，而且本次的案例分析仅仅是作者看了一些教程之后自己总结出来的，可能它的插入情况还没考虑全面，测试案例过少，欢迎大佬批评指正！

img

问号小朋友
关注
  • 5
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】手撕红黑树
学了就忘是正常现象
02-26 8831
红黑树和AVL树一样，因其逻辑复杂，面试时现场要求手撕就是纯纯刁难面试者。但某大厂面试官曾要求某些求职者现场手撕红黑树（我赌5毛，让面试官撕，他也撕不出来，而且你家员工上班手搓红黑树啊？），随后求职遭遇被发到网上吐槽，这便有了“手撕红黑树”的梗，也让红黑树成为了知名度最高的数据结构。（话虽如此，对于红黑树的性质、插入思想等概念还是需要掌握的）
C++——红黑树超详细讲解~~~~
陌上人如玉，公子世无双。
11-23 1951
红黑树： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 红黑树的性质： 每个结点不是红色就是黑色。 根节点是黑色的。 如果一个节点是红色的，则它的两个孩子结点是黑色的。 对于每个结点，从该结点到其所有后代叶结点...
保姆级别带你手撕红黑树BRTree
我的学习笔记分享
04-20 1576
一、前言 本文是自己在学习过程中，记录下的一些总结，以便日后复习，同时分享出来，方便与更多人学习交流，共同进步。鄙人水平有限，若有误，请不吝赐教😁😁😁。 二、从头介绍 红黑树树是一种二叉树，比较常用的数据结构，如果对二叉树不是很熟悉或者有遗忘的朋友，可以看看我之前做的笔记。 第一篇介绍二叉树的基础知识：数据结构与算法 树_振予的博客-CSDN博客 第二篇介绍二叉搜索树和二叉平衡树树：数据结构与算法 查找_振予的博客-CSDN博客 三、红黑树介绍 每当我们打开电脑查找一个文档、在教务系统输入我们
C++手撕红黑树
分享学习的知识，记录我的技术成长道路
08-07 641
红黑树在表意上就是一棵每个节点带有颜色的二叉搜索树，并通过对节点颜色的控制，使该二叉搜索树达到尽量平衡的状态。红黑树确保没有一条路径比其他路径长两倍。和AVL树不同的是，AVL树是一棵平衡树，而红黑树可能平衡也可能不平衡(因为是尽量平衡的状态)每一次插入都对根节点置为黑操作，因为第一种情况可能导致根节点不是黑。同时对根节点置黑也并不违反三条规定。...
天天说手撕红黑树？你真的能撕的下来吗？（详细解释+代码注释）
CYK_byte的博客
12-22 1033
/新增结点，默认必须是红色}}//根节点}}注意：每次新增结点必须是红色的，因为如果某一个分支上增加一个黑色结点，根据红黑树的特点，那么其他每一个分支上也必须都增加一个黑色结点，但实际上我需要增加一个结点，而为了满足红黑树特点多增加的这些结点是没有意义的；如果添加一个红色节点，我们只需要通过调整颜色，即可满足要求；
28.红黑树_1.wmv（目前数据结构最好的视频,共42集，需要哪一集的知识自己下，一集3积分）
03-13
26红黑树 27红黑树_0 28红黑树_1 29红黑树_2 30红黑树_3 31红黑树_4 32红黑树_5 33红黑树_6 34堆 35堆排序 36哈希与映射的概述 37B树有什么用 38B树的概念 39图_邻接矩阵 40图_邻接表 41图_DFS 42图_BFS
机器学习实战-手撕决策树
最新发布
05-18
在这个实验中，我们将关注决策树在【鸢尾花数据集】上的应用，这是一个经典的数据集，包含三种鸢尾花的多个特征，用于多类别分类。 决策树的构建过程可以分为以下几个关键步骤： 1. **构建根节点**：所有训练数据...
【数据结构与算法】手撕平衡二叉树.doc
07-10
【数据结构与算法】手撕平衡二叉树 平衡二叉树是一种特殊的二叉查找树，它的设计目标是为了保持树的平衡，确保在各种操作（如查找、插入、删除等）中的时间复杂度尽可能低。平衡二叉树的典型代表是AVL树，它的主要...
DesignModelCode:手撕设计模式！！
05-02
手撕设计模式！！每一种设计模式尽量用代码实现一遍，将在博客中详细讲解，慢慢更新~ 这是:) 设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种： 工厂方法模式 抽象工厂模式 单例模式 建造者模式 ...
vivo iQOO 12系统手撕方案
06-21
vivo iQOO 12系统手撕方案
Java手撕红黑树
wufeifan_learner的博客
01-07 768
前言 我这个人懒得不行，其实早就想学习学习红黑树了，以前只是知道这东西，也知道他是构成HashMap的底层数据结构（jdk1.8以后），但是每次一看红黑树的5条性质就头疼，不想去自习考虑这个数据结构。这个寒假终于下定决心用java手撕一遍红黑树，为了以后的面试做准备。由于这个数据结构有点庞大，我不想从基础开始讲解了，B站好多教学视频，我看了好多，但是现场手撕红黑树的，翻来翻去就那么几个。他们写代码的风格我不是太喜欢，且多是用的idea这个IDE，学生哪有钱买正版，我就直接用eclipse了，反正原理都一样，
手撕HashMap红黑树
我与风来
12-30 850
结合红黑树算法，介绍了底层 HashMap 树型化相关的操作。
深入浅出C++ ——手撕红黑树
weixin_55051736的博客
02-22 594
/节点的值域 Colour _col;//节点的颜色 RBTreeNode < K , V > * _left;//节点的左孩子 RBTreeNode < K , V > * _right;//节点的右孩子 RBTreeNode < K , V > * _parent;//节点的双亲 };
手撕红黑树
qq_33688997的博客
11-18 1914
#include <stdio.h> #include <stdlib.h>typedef struct RBTNode { int key; int black; struct RBTNode *lchild, *rchild; struct RBTNode *father; } RBTNode;RBTNode *NIL;#define lson node->lch
红黑树最全手撕教程（建议马！）
python爬虫人工智能大数据
07-19 977
ACM金牌得主带你手撕红黑树！1套视频 攻克数据结构难题补足短板 + 进阶突破本号读者0元领取要判断一个人的代码水平如何，不是看TA的代码量有多复杂，而是透过代码看TA的数据结构与算法。...
手撕红黑树（Red-Black Tree）
林慢慢的博客
07-06 2755
红黑树 （C++实现）
利用上班摸鱼时间，手撕红黑树（Java代码实现）
weixin_45685353的博客
07-08 590
java代码实现红黑树，包括插入、删除、查询等操作
C++ 手撕红黑树（一）：插入操作
zsiming的博客
07-11 547
红黑树的出现主要是用来解决AVL树旋转次数过多的问题。AVL树在插入节点或者删除节点的过程中（每层递归完回溯时）都需要检查左子树或者右子树之间的高度差是否小于等于1，如果不平衡(大于1)的话需要旋转或者平衡操作来维持平衡，因此在数据量比较大的时候可能旋转了很多次（接近logn次），效率比较差。而红黑树在插入和删除的时候，最多做两次旋转操作。因此旋转次数比较少。然而，值得注意的是，红黑树是一颗BST树但并不是一颗平衡的树。......
list<String>转换成list<student>数据结构
03-28
这里假设List中每个字符串包含的信息是学生的姓名和年龄，以逗号分隔。 可以使用Java 8的Stream API来进行转换，具体步骤如下： 1. 定义一个Student类，包含姓名和年龄属性： ```java public class Student { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值