数据结构与算法学习笔记7：红黑树

已于 2022-05-10 13:16:21 修改
阅读量130 收藏 1
点赞数 1
分类专栏： 数据结构与算法学习笔记 文章标签： 学习 b树 数据结构
于 2022-05-10 13:16:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h0327x/article/details/124686049
版权

数据结构与算法学习笔记7：红黑树

红黑树

  • AVL 绝对平衡（高度差）
  • 红黑树 相对平衡（颜色）
  • 红黑树是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的： 可以在 O ( l o g 2 n ) O(log_2n) O(log2​n)时间内做查找，插入和删除，这里的 n n n 是树中元素的数目。

特点

  • 1、每个节点的颜色，要么是黑色的，要么是红色的。
  • 2、根节点必须是黑色的。
  • 3、认为终端节点是黑色的，称之为黑哨兵。
  • 4、树中不允许两个红节点为父子关系。
  • 5、从任意节点向下出发，所能到达的各个终端节点的各条路径上，黑节点的数目必须是完全相同的。
  • 6、由于上述1-5的限制，导致红黑树上不会有一条路径长度超过其它路径的2倍。

红黑树的创建

结构：值value、颜色color、左left、右right、父亲father

查找（节点添加的位置）

参考BST即可

节点添加（新来节点是红色的）

image-20220505224406883

  • 1、 **NULL树，**新的操作节点必须是红，而根节点必须是黑色，因此该节点由红色变为黑色成为根节点。
  • 2、 **非NULL，**新的操作节点如何安置，首先看父亲的颜色
    • 1）父亲为黑色，直接放入就可以了
    • 2）父亲为红色，需要判断叔叔的情况
      • ① 如果叔叔在（在就一定是红色），变色，父亲和叔叔变黑，爷爷变红，然后爷爷作为新的操作节点进行调整
      • ② 如果叔叔不在（不在为NULL就认为是黑色），旋转。
        • ​ 父亲在爷爷左侧
          • ​ 操作节点在父亲的右侧，父亲为新的操作节点，以操作节点为旋转点进行左旋
          • ​ 操作节点在父亲的左侧，将父亲变黑，爷爷变红，然后以爷爷作为旋转点进行右旋，结束。
        • ​ 父亲在爷爷右侧
          • ​ 操作节点在父亲的左侧，父亲为新的操作节点，以操作节点为旋转点进行右旋
          • ​ 操作节点在父亲的右侧，将父亲变黑，爷爷变红，然后以爷爷为旋转点进行左旋，结束。
代码
#include <cstdlib>
#include <stdio.h>
#include <stdlib.h>

enum COLOR{RED,BLACK};  //枚举
//等同于:
//    #define RED    0
//    #define BLACK  1

typedef struct Node{
    int nValue;
    int nColor;
    struct Node *pLeft;
    struct Node *pRight;
    struct Node *pFather;
}RBT;

RBT *pRBT = NULL;

//右旋代码
void RightRotate(RBT *pNode){
    if (pNode == NULL || pNode->pLeft == NULL) return;
    RBT *pMark = pNode->pLeft;
    //三个孩子的关系
    pNode->pLeft = pMark->pRight;
    pMark->pRight = pNode;
    if (pNode->pFather == NULL) {
        pRBT = pMark;
    }else{
        if (pNode == pNode->pFather->pLeft) {
            pNode->pFather->pLeft = pMark;
        }
        else{
            pNode->pFather->pRight = pMark;
        }
    }
    //三个父亲的关系
    if (pNode->pLeft != NULL) {
        pNode->pLeft->pFather = pNode;
    }
    pMark->pFather = pNode->pFather;
    pNode->pFather = pMark;
}

//左旋代码
void LeftRotate(RBT *pNode){
    if (pNode == NULL || pNode->pRight == NULL) return;
    RBT *pMark = pNode->pRight;
    //三个孩子的关系
    pNode->pRight = pMark->pLeft;
    pMark->pLeft = pNode;
    if (pNode->pFather == NULL) {
        pRBT = pMark;
    }else{
        if (pNode == pNode->pFather->pLeft) {
            pNode->pFather->pLeft = pMark;
        }
        else{
            pNode->pFather->pRight = pMark;
        }
    }
    //三个父亲的关系
    if (pNode->pRight != NULL) {
        pNode->pRight->pFather = pNode;
    }
    pMark->pFather = pNode->pFather;
    pNode->pFather = pMark;
}

RBT *GetFather(RBT *pTree,int nNum){
    while (pTree) {
        if (pTree->nValue > nNum) {
            if (pTree->pLeft == NULL) return pTree;
            pTree = pTree->pLeft;   //左侧
        }else if(pTree->nValue < nNum){
            if (pTree->pRight == NULL) return pTree;
            pTree = pTree->pRight;  //右侧
        }else{
            printf("date error!\n");
            exit(1);
        }
    }
    return NULL;
}

RBT *GetUncle(RBT * pFather){
    if (pFather == pFather->pFather->pLeft) {
        return pFather->pFather->pRight;
    }else{
        return pFather->pFather->pLeft;
    }
}

void AddNode(int nNum){
    RBT *pTemp = NULL;
    pTemp = (RBT*)malloc(sizeof(RBT));
    pTemp->nValue = nNum;
    pTemp->nColor = RED;
    pTemp->pFather = NULL;
    pTemp->pLeft = NULL;
    pTemp->pRight = NULL;

    //找到父亲节点
    RBT *pNode = NULL;
    pNode = GetFather(pRBT, nNum);
    pTemp->pFather = pNode;

    //空树情况
    if (pNode == NULL) {
        pRBT = pTemp;
        pRBT->nColor = BLACK;
        return;
    }

    //非空树情况
    //连接
    if (nNum < pNode->nValue) {
        pNode->pLeft = pTemp;
    }else{
        pNode->pRight = pTemp;
    }
    //调整
        //父亲为黑色
    if(pNode->nColor == BLACK){
        return;
    }
    //父亲为红色
    RBT * pGrandFather = NULL;
    RBT * pUncle = NULL;
    while (pNode->nColor == RED) {
        pGrandFather = pNode->pFather;
        pUncle = GetUncle(pNode);
        //叔叔为红色
        if (pUncle != NULL && pUncle->nColor == RED) {
            //不加pUncle != NULL &&情况下如果pUncle为NULL，pUncle->nColor将直接引发程序崩溃
            pNode->nColor = BLACK;
            pUncle->nColor = BLACK;
            pGrandFather->nColor = RED;
            pTemp = pGrandFather;
            pNode = pTemp->pFather;
            //需要判断其是否为根，如果是根的话需要将红色变回黑色，红黑树要求根节点必须是黑色
            if (pNode == NULL) {
                pTemp->nColor = BLACK;
                break;
            }
            continue;
        }
        //叔叔为黑色
        if (pUncle == NULL || pUncle->nColor == BLACK) {
            //不加pUncle != NULL ||情况下如果pUncle为NULL，pUncle->nColor将直接引发程序崩溃
            //父亲是爷爷的左侧
            if (pNode == pGrandFather->pLeft) {
                //当前节点是父亲的右侧
                if (pTemp == pNode->pRight) {
                    pTemp = pNode;
                    LeftRotate(pTemp);  //左旋
                    pNode = pTemp->pFather; //更新父亲
                }
                //当前节点是父亲的左侧
                if (pTemp == pNode->pLeft) {
                    pNode->nColor = BLACK;
                    pGrandFather->nColor = RED;
                    RightRotate(pGrandFather);  //右旋
                    break;
                }
            }
            //父亲是爷爷的右侧
            if (pNode == pGrandFather->pRight) {
                //当前节点是父亲的左侧
                if (pTemp == pNode->pLeft) {
                    pTemp = pNode;
                    RightRotate(pTemp);  //右旋
                    pNode = pTemp->pFather; //更新父亲
                }
                //当前节点是父亲的右侧
                if (pTemp == pNode->pRight) {
                    pNode->nColor = BLACK;
                    pGrandFather->nColor = RED;
                    LeftRotate(pGrandFather);  //左旋
                    break;
                }
            }
        }
    }
}

void CreateRBT(){
    int nNum;
    int nLenth;
    printf("请输入节点个数：\n");
    scanf("%d",&nLenth);
    printf("请输入节点：\n");
    for (int i = 0; i < nLenth; i++) {
        scanf("%d",&nNum);
        AddNode(nNum);
    }
}

void PreorderTraversal(RBT *pTree){
    if (pTree == NULL)  return;
    printf("value = %d\tcolor = %d\n",pTree->nValue,pTree->nColor);
    PreorderTraversal(pTree->pLeft);
    PreorderTraversal(pTree->pRight);
}//前序遍历


int main()
{
    CreateRBT();
    PreorderTraversal(pRBT);
    return 0;
}

删除

先进行被删除节点的搜索，然后进行孩子个数的分析，如果有两个孩子，那么用左的最右or右的最左与该节点进行替换，然后再开始分析替换后真正要删除的那个节点。

分析

Z为真正被删除节点，也是操作节点。

  • Z为根且无子，直接删除，变空树，结束

  • Z为根且有一子，子变为黑色，删Z，子成为新根，结束

    （只有一子时该子必为红色，因为和红黑树性质中的“从任意节点向下出发，所能到达的各个终端节点的各条路径上，黑节点的数目必须是完全相同的”）

  • Z为红色，直接删Z，结束

  • Z非根，Z为黑色且有一个，爷孙相连，子变黑色，删Z，结束

  • Z非根，Z为黑色且无子，删，然后进行如下分析和调整

    • 兄弟为红，将父亲变红，兄弟变黑，以父亲为旋转点进行旋转，以Z继续调整
    • 兄弟为黑
      • 兄弟的两孩子（Z的侄子）全黑（或者NULL）
        • 父亲为红，父亲变黑，兄弟变红，结束
        • **父亲为黑，**兄弟变红，父亲为新Z，以Z继续调整
      • 左侄子红，右侄子黑
        • 兄弟在父亲的右侧，兄弟变红，左侄子变黑色，然后以兄弟为旋转点进行右旋
        • 兄弟在父亲的左侧，把父亲的颜色给兄弟，父亲变黑，左侄子变黑，以父亲为旋转点右旋，结束
      • 右侄子红
        • 兄弟在父亲的右侧，把父亲的颜色给兄弟，父亲变黑，右侄子变黑，以父亲为旋转点左旋，结束
        • 兄弟是父亲的左侧，兄弟变红，右侄子变黑色，然后以兄弟为旋转点进行左旋
代码
#include <cstddef>
#include <cstdlib>
#include <stdio.h>
#include <stdlib.h>

enum COLOR{RED,BLACK}; 

typedef struct Node{
    int nValue;
    int nColor;
    struct Node *pLeft;
    struct Node *pRight;
    struct Node *pFather;
}RBT;

RBT *pRBT = NULL;

//右旋代码
void RightRotate(RBT *pNode){
    if (pNode == NULL || pNode->pLeft == NULL) return;
    RBT *pMark = pNode->pLeft;
    //三个孩子的关系
    pNode->pLeft = pMark->pRight;
    pMark->pRight = pNode;
    if (pNode->pFather == NULL) {
        pRBT = pMark;
    }else{
        if (pNode == pNode->pFather->pLeft) {
            pNode->pFather->pLeft = pMark;
        }
        else{
            pNode->pFather->pRight = pMark;
        }
    }
    //三个父亲的关系
    if (pNode->pLeft != NULL) {
        pNode->pLeft->pFather = pNode;
    }
    pMark->pFather = pNode->pFather;
    pNode->pFather = pMark;
}

//左旋代码
void LeftRotate(RBT *pNode){
    if (pNode == NULL || pNode->pRight == NULL) return;
    RBT *pMark = pNode->pRight;
    //三个孩子的关系
    pNode->pRight = pMark->pLeft;
    pMark->pLeft = pNode;
    if (pNode->pFather == NULL) {
        pRBT = pMark;
    }else{
        if (pNode == pNode->pFather->pLeft) {
            pNode->pFather->pLeft = pMark;
        }
        else{
            pNode->pFather->pRight = pMark;
        }
    }
    //三个父亲的关系
    if (pNode->pRight != NULL) {
        pNode->pRight->pFather = pNode;
    }
    pMark->pFather = pNode->pFather;
    pNode->pFather = pMark;
}

RBT *GetFather(RBT *pTree,int nNum){
    while (pTree) {
        if (pTree->nValue > nNum) {
            if (pTree->pLeft == NULL) return pTree;
            pTree = pTree->pLeft;   //左侧
        }else if(pTree->nValue < nNum){
            if (pTree->pRight == NULL) return pTree;
            pTree = pTree->pRight;  //右侧
        }else{
            printf("date error!\n");
            exit(1);
        }
    }
    return NULL;
}

RBT *GetUncle(RBT *pFather){
	if(pFather == pFather->pFather->pLeft){
		return pFather->pFather->pRight;
	}else{
		return pFather->pFather->pLeft;
	}
}

RBT *GetBrother(RBT * pNode){
    if (pNode == pNode->pFather->pLeft) {
        return pNode->pFather->pRight;
    }else{
        return pNode->pFather->pLeft;
    }
}

void AddNode(int nNum){
    RBT *pTemp = NULL;
    pTemp = (RBT*)malloc(sizeof(RBT));
    pTemp->nValue = nNum;
    pTemp->nColor = RED;
    pTemp->pFather = NULL;
    pTemp->pLeft = NULL;
    pTemp->pRight = NULL;

    //找到父亲节点
    RBT *pNode = NULL;
    pNode = GetFather(pRBT, nNum);
    pTemp->pFather = pNode;

    //空树情况
    if (pNode == NULL) {
        pRBT = pTemp;
        pRBT->nColor = BLACK;
        return;
    }

    //非空树情况
    //连接
    if (nNum < pNode->nValue) {
        pNode->pLeft = pTemp;
    }else{
        pNode->pRight = pTemp;
    }
    //调整
        //父亲为黑色
    if(pNode->nColor == BLACK){
        return;
    }
    //父亲为红色
    RBT * pGrandFather = NULL;
    RBT * pUncle = NULL;
    while (pNode->nColor == RED) {
        pGrandFather = pNode->pFather;
        pUncle = GetUncle(pNode);
        //叔叔为红色
        if (pUncle != NULL && pUncle->nColor == RED) {
            //不加pUncle != NULL &&情况下如果pUncle为NULL，pUncle->nColor将直接引发程序崩溃
            pNode->nColor = BLACK;
            pUncle->nColor = BLACK;
            pGrandFather->nColor = RED;
            pTemp = pGrandFather;
            pNode = pTemp->pFather;
            //需要判断其是否为根，如果是根的话需要将红色变回黑色，红黑树要求根节点必须是黑色
            if (pNode == NULL) {
                pTemp->nColor = BLACK;
                break;
            }
            continue;
        }
        //叔叔为黑色
        if (pUncle == NULL || pUncle->nColor == BLACK) {
            //不加pUncle != NULL ||情况下如果pUncle为NULL，pUncle->nColor将直接引发程序崩溃
            //父亲是爷爷的左侧
            if (pNode == pGrandFather->pLeft) {
                //当前节点是父亲的右侧
                if (pTemp == pNode->pRight) {
                    pTemp = pNode;
                    LeftRotate(pTemp);  //左旋
                    pNode = pTemp->pFather; //更新父亲
                }
                //当前节点是父亲的左侧
                if (pTemp == pNode->pLeft) {
                    pNode->nColor = BLACK;
                    pGrandFather->nColor = RED;
                    RightRotate(pGrandFather);  //右旋
                    break;
                }
            }
            //父亲是爷爷的右侧
            if (pNode == pGrandFather->pRight) {
                //当前节点是父亲的左侧
                if (pTemp == pNode->pLeft) {
                    pTemp = pNode;
                    RightRotate(pTemp);  //右旋
                    pNode = pTemp->pFather; //更新父亲
                }
                //当前节点是父亲的右侧
                if (pTemp == pNode->pRight) {
                    pNode->nColor = BLACK;
                    pGrandFather->nColor = RED;
                    LeftRotate(pGrandFather);  //左旋
                    break;
                }
            }
        }
    }
}

RBT *FindNode(RBT * pTree,int nNum){
    while (pTree) {
        if(pTree->nValue == nNum){
            return pTree;
        }else if(pTree->nValue > nNum){
            pTree = pTree->pLeft;
        }else {
            pTree = pTree->pRight;
        }
    }
    return NULL;
}

void DeleteNode(int nNum){
    //找到当前被删除节点
    RBT *pTemp = NULL;
    pTemp = FindNode(pRBT, nNum);
    if(pTemp == NULL) return;   //没有要删除的节点 直接结束即可
    
    RBT *pMark = NULL;  //标记
    //孩子情况的分析
    if (pTemp->pLeft != NULL && pTemp->pRight != NULL) {
        pMark = pTemp;
        pTemp = pTemp->pLeft;
        while (pTemp->pRight != NULL) {
            pTemp = pTemp->pRight;
        }   //找到左的最右，然后进行值的覆盖替换
        pMark->nValue = pTemp->nValue;
    }

    //颜色情况的讨论
    RBT *pNode = pTemp->pFather;
    //1. 根
    if (pNode == NULL) {
        //  1.1 无子的情况
        if (pTemp->pLeft == NULL && pTemp->pRight == NULL) {
            free(pTemp);
            pTemp = NULL;
            pRBT = NULL;
            return;
        }
        //  1.2 有一子(红)的情况
        else {
            pRBT = pTemp->pLeft ? pTemp->pLeft : pTemp->pRight;
            pRBT->nColor = BLACK;
            pRBT->pFather = NULL;
            free(pTemp);
            pTemp = NULL;
            return;
        }
    }
    //2. 非根
        //2.1 节点为红色
        if (pTemp->nColor == RED) {
             //判断这个红节点在父亲左侧还是右侧
            if (pTemp == pNode->pLeft) {
                pNode->pLeft = NULL;
            }else{
                pNode->pRight = NULL;
            }
            free(pTemp);
            pTemp = NULL;
            return;
        }
        //2.2 节点为黑色且有一个红子
        if (pTemp->nColor == BLACK && (pTemp->pLeft != NULL || pTemp->pRight != NULL)) {
            if (pTemp == pNode->pLeft) {    //判断这个红子在父亲左侧还是右侧，此处为左
                pNode->pLeft = pTemp->pLeft ? pTemp->pLeft : pTemp->pRight;    //爷孙相连，父亲的左侧换人换成删除节点的孩子
                pNode->pLeft->nColor = BLACK;
                pNode->pLeft->pFather = pNode;
            }else if (pTemp == pNode->pRight) {
                pNode->pRight = pTemp->pLeft ? pTemp->pLeft : pTemp->pRight;
                pNode->pRight->nColor = BLACK;
                pNode->pRight->pFather = pNode;
            }
            free(pTemp);
            pTemp = NULL;
            return;
        }
        //2.3 节点为黑色且无子
        else {
            RBT *pBrother = GetBrother(pTemp);    //兄弟节点
            //删除节点，注意获取兄弟节点和删除节点的顺序不可以乱，先删除节点就无法获取到其兄弟了
            if (pTemp == pNode->pLeft) {
                pNode->pLeft = NULL;
            }else {
                pNode->pRight = NULL;
            }
            free(pTemp);
            pTemp = NULL;
            //调整
            while (1) {
                //2.3.1 兄弟是红色
                if (pBrother->nColor == RED) {
                    pNode->nColor = RED;
                    pBrother->nColor = BLACK;
                    //判断方向进行旋转
                    if (pBrother == pNode->pRight) {
                        LeftRotate(pNode);
                        pBrother = pNode->pRight;   //旋转完兄弟会换人，要更新一下兄弟
                    }else {
                        RightRotate(pNode);
                        pBrother = pNode->pLeft;
                    }
                }
                //2.3.2 兄弟是黑色
                else if (pBrother->nColor == BLACK) {
                    //2.3.2.1 侄子全黑
                    if ( (pBrother->pLeft == NULL && pBrother->pRight == NULL) ||
                        ( (pBrother->pLeft != NULL && pBrother->pLeft->nColor == BLACK) && 
                            (pBrother->pRight != NULL && pBrother->pRight->nColor == BLACK) ) ) {
                        //2.3.2.1.1 父亲红
                        if (pNode->nColor == RED) {
                            pNode->nColor = BLACK;
                            pBrother->nColor = RED;
                            break;
                        }
                        //2.3.2.1.2 父亲黑
                        else if (pNode->nColor == BLACK) {
                            pBrother->nColor = RED;
                            pTemp = pNode;  //父亲作为新的操作节点
                            pNode = pTemp->pFather; //父亲这个变量也需要随之发生变化
                            //判断是否为根，为根则直接结束了
                            if (pNode == NULL) {
                                break;
                            }
                            pBrother = GetBrother(pTemp);   //因为temp改变了 更新一下Brother
                        }
                    }
                    //2.3.2.2 左侄子红，右侄子黑
                    else if ( (pBrother->pLeft != NULL && pBrother->pLeft->nColor ==RED) &&
                                (pBrother->pRight == NULL || pBrother->pRight->nColor == BLACK) ) {
                        //2.3.2.2.1 兄弟在父亲右侧
                        if (pBrother == pNode->pRight) {
                            pBrother->nColor = RED;
                            pBrother->pLeft->nColor = BLACK;
                            RightRotate(pBrother);
                            pBrother = pNode->pRight;   //旋转后兄弟换人了 记得更新
                        }
                        //2.3.2.2.2 兄弟在父亲左侧
                        else {
                            pBrother->nColor = pNode->nColor;   //把父亲颜色给兄弟
                            pNode->nColor = BLACK;
                            pBrother->pLeft->nColor = BLACK;
                            RightRotate(pNode);
                            break;
                        }
                    }
                    //2.3.2.3 右侄子红，左侄子随便
                    else {
                        //2.3.2.3.1 兄弟在父亲左侧
                        if (pBrother == pNode->pLeft) {
                            pBrother->nColor = RED;
                            pBrother->pRight->nColor = BLACK;
                            LeftRotate(pBrother);
                            pBrother = pNode->pLeft;
                        }
                        //2.3.2.3.2 兄弟在父亲右侧
                        else {
                            pBrother->nColor = pNode->nColor;   //把父亲颜色给兄弟
                            pNode->nColor = BLACK;
                            pBrother->pRight->nColor = BLACK;
                            LeftRotate(pNode);
                            break;
                        }
                    }
                }
            }
        }
}

void CreateRBT(){
    int nNum;
    int nLenth;
    printf("请输入节点个数：\n");
    scanf("%d",&nLenth);
    printf("请输入节点：\n");
    for (int i = 0; i < nLenth; i++) {
        scanf("%d",&nNum);
        AddNode(nNum);
    }
}

void PreorderTraversal(RBT *pTree){
    if (pTree == NULL)  return;
    printf("value = %d\tcolor = %d\n",pTree->nValue,pTree->nColor);
    PreorderTraversal(pTree->pLeft);
    PreorderTraversal(pTree->pRight);
}//前序遍历

int main()
{
    CreateRBT();
    PreorderTraversal(pRBT);
    printf("------------------------\n");
    DeleteNode(1);
    PreorderTraversal(pRBT);
    printf("------------------------\n");
    DeleteNode(8);
    PreorderTraversal(pRBT);
    printf("------------------------\n");
    DeleteNode(11);
    PreorderTraversal(pRBT);
    printf("------------------------\n");
    DeleteNode(14);
    PreorderTraversal(pRBT);
    printf("------------------------\n");
    DeleteNode(2);
    PreorderTraversal(pRBT);
    printf("------------------------\n");
    DeleteNode(5);
    PreorderTraversal(pRBT);
    printf("------------------------\n");
    DeleteNode(7);
    PreorderTraversal(pRBT);
    printf("------------------------\n");
    DeleteNode(15);
    PreorderTraversal(pRBT);
    printf("------------------------\n");
    return 0;
}

应用

  • map：key、value
  • set：value，不允许数值重复插入（insert_unique）
  • multiset：value，允许数值重复插入（insert_equal）
红黑树优势
  • 搜索很快，中序遍历能够得到有序数据
红黑树在Linux底层应用：

  • ① 进程管理

    • PCB 本质上就是一个结构体 task_struct

    • 图中显示的标白部分就是负责进程调度的，实际上底层就是：

      进程放到红黑树中管理，红黑树的每个节点都是一个进程，key可以理解成当前进程运行时间。

      例如：设置定时器9点，然后在红黑树中进行搜索到9点，该结点左侧部分（包括兄弟的孩子等）就是需要运行的部分

  • ② 内存管理

    • 每次申请的空间（主要就是起始地址＋结束地址or偏移量）作为红黑树中的结点，可以快速找到对应内容的位置
Linux中的epoll模型
  • 通过红黑树能快速判断消息关联到哪个线程的能力（非轮询监听），所以高并发IO可以考虑epoll模型，
  • 当然，哈希表搜索速度也很快，但其很严重的缺陷是占用空间，数组一开始就需要定长，不可以动态变化，所以红黑树更实用。除此外，还可以用于索引的还有B+树。
97Marcus
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
《恋上数据结构与算法》笔记（十三）：红黑树
Guizy
12-08 528
目录 具体代码在 : RBTree, 欢迎star 一、红黑树（Red Black Tree） 1、初识红黑树 2、红黑树的等价变化 3、红黑树 vs 2-3-4树 4、红黑树节点关系 二、红黑树的实现 1、构造方法 2、添加 2.1 parent为BLACK 2.2 parent为RED（Double Red） 2.2.1 添加-修复性质4-LL\RR 2.2.2 添加-修复性质4-LR\RL 2.2.3 添加-修复性质4-上溢-LL 2.2.4 添加-修复性质4-上溢-RR 2.2.
数据结构与算法学习笔记（十），左偏红黑树
06-01
笔记而已，不要太较真，有错误请立即指出。 类： 节点类 红黑树类 函数： 左旋，右旋，反转颜色，添加，查找。
红黑树详解（C/C++实现）
blll0的博客
03-12 788
本文对红黑树进行详细的介绍，分析了红黑树的删除插入操作以及详细的代码实现，最后介绍了红黑树与AVL树的区别
数据结构与算法学习笔记5：二叉树
h0327x的博客
05-03 770
数据结构与算法学习笔记6树二叉树**二叉树的特性：****满二叉树 vs 完全二叉树**完全二叉树的特性：二叉搜索树 / 排序二叉树 （Binary Search Tree）二叉树的创建（粗暴版）遍历深度**前序遍历：****中序遍历：****后序遍历：**广度层序遍历：二叉树的创建（前序递归版）如何创建完全二叉树 树 树：一对多 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TNn0JnUX-1651567717166)(https://cdn.jsdelivr.n
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
热门推荐
小七的博客
01-18 16万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
数据结构与算法学习笔记
tanqing24520的博客
09-12 2558
1. 数据结构与算法 1.1 知识脑图 1.2 什么是 数据结构 与 算法 数据结构 就是一组数据的存储结构 算法 就是操作一组数据的方法 数据结构是为算法服务的，算法要作用在特定的数据结构之上 1.3 为什么需要数据结构和算法 在计算机科学和互联网迅猛发展下，需要计算的数据量越来越庞大。但是计算机的计算能力是有限的，这么大量的数据计算，需要越来越多的计算机，需要越来越长的计算时间，注重效率的我们需要尽可能的提高计算效率 选用合适的数据结构和算法，特别是在处理体量非常庞大的数据的时候，可以极
我的算法：我的数据结构和算法学习笔记
02-08
我的算法我的算法学习笔记数据结构叠放队列链表BinarySearchTree 组地图eep 段树特里联合查找AVL树红黑树哈希表图形演算法分类气泡分选选择排序插入排序贝壳分类快速分类合并排序堆排序计数排序桶分类基数排序搜索二...
leetcode迷宫问题-Algorithm:算法学习笔记
06-30
算法学习笔记 记录内容包括《算法4》学习编写的 demo，和 leetcode 习题笔记。 基础目标： 基础数据结构相关：链表、栈和队列的实现 排序算法相关：时间复杂度为 O(n²) 的系列排序算法如 选择、插入和优化的希尔等...
0854考研初试(自命题) 数据结构强化笔记 Akira37.pdf
04-21
0854考研初试科目《程序设计与数据结构》学习笔记。 根据各大数据结构教材与参考书编写，结合个人刷题体验总结了大量实用结论，适用于绝大部分院校自命题DS初试全程复习，也可作为408统考参考之用（不含红黑树等部分...
leetcode卡-algorithm_notes:算法学习笔记
07-06
数据结构 线性表 顺序表 链表 单链表 双(向)链表 循环链表 单(向)循环链表 双(向)循环链表 堆栈 顺序栈 链栈 队列 顺序队列 顺序循环队列 链队 数组 一维数组 多维数组 矩阵的压缩存储 广义表 树 存储实现 二叉树 ...
限流的学习
weixin_43675252的博客
05-01 317
限流算法：滑动窗口算法滑动日志算法漏桶算法令牌桶算法。
Build a Large Language Model (From Scratch) 从头开始构建大型语言模型(第二章)学习笔记
Czi.的博客
04-29 1124
LLM需要将文本数据转换为数值向量，称为嵌入，因为它们无法处理原始文本。嵌入将离散数据（如单词或图像）转换为连续向量空间，使它们与神经网络操作兼容。第一步，将原始文本分解为tokens，这些tokens可以是单词或字符。然后，tokens被转换为整数表示形式，称为token IDs。可以添加特殊tokens（例如和）来增强模型的理解并处理各种上下文，例如未知单词或标记(marking)不相关文本之间的边界。
力扣数据库题库学习（4.28日）--1587. 银行账户概要 II
Jesse_Kyrie的博客
04-28 258
对于力扣题1587. 银行账户概要 II的解答，提供解题思路与解题方法，知识点为:1. GROUP BY 2. SUM 3. LEFT JOIN 4. HAVING
场景文本检测&识别学习 day08（无监督的Loss Function、代理任务、特征金字塔）
最新发布
丿罗小黑的博客
05-03 245
无监督的Loss Function（无监督的目标函数） 根据有无标签，可以将模型的学习方法分为：无监督、有监督两种。而自监督是无监督的一种 无监督的目标函数可以分为以下几种： 生成式网络的做法，衡量模型的输出和固定的目标之间的差距，主要考虑输入数据是怎么分布的，即 “给定Y，如何生成X”。如auto-encoder：输入一张干扰过的图，通过编码器-解码器，然后得出一张还原后的图，通过对比原图和生成的还原后的图之间的差异 判别式网络的做法，衡量模型的输出和固定的目标之间的差异，主要考虑输入和输出的映射关系
[C++基础学习-04]----C++数组详解
一伦明悦的博客
05-02 342
一维数组和二维数组是在编程中常用的数据结构，它们具有不同的特点和适用场景。1、一维数组一维数组是一种线性结构，它由一系列按顺序存储的元素组成；通常用于存储一组相同类型的数据，例如整数、浮点数、字符等；访问速度比较快，通过数组下标即可快速定位和访问特定元素；适用于存储列表、向量、序列等线性数据。2、二维数组二维数组是一种表格状的结构，它由一维数组组成的数组，用于存储表格数据或矩阵数据；通常用于存储二维结构的数据，例如游戏地图、图像数据、二维表格等；
xss漏洞学习
Z11762的博客
04-29 627
跨站脚本（Cross-Site Scripting），本应该缩写为CSS，但是该缩写已被层叠样式脚本Cascading Style Sheets所用，所以改简称为XSS。也称跨站脚本或跨站脚本攻击。原理：跨站脚本攻击XSS通过将恶意得Script代码注入到Web页面中，当用户浏览该页之时，嵌入其中Web里面的Script代码会被执行，从而达到恶意攻击用户的目的。特点：本质上是一种针对网站应用程序攻击的技术，同属于代码注入。
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
weixin_66413741的博客
04-30 1072
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。
【书生·浦语大模型实战营第二期】XTuner微调LLM：1.8B、多模态、Agent——学习笔记4
m0_61819793的博客
05-01 958
书生·浦语实战营第二期 学习笔记4 使用XTuner工具微调InternLM-1.8B，LLaVA微调方案
netty的继续学习一(相关概念)
u013127325的博客
05-01 834
netty组件信息的简单介绍
数据结构与算法c++笔记
08-31
很高兴回答你关于数据结构与算法的问题！以下是一些关于C语言中数据结构和算法...这只是数据结构与算法的一小部分内容，还有很多其他知识点和算法可以学习。希望这些笔记对你有所帮助！如果你有任何问题，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

97Marcus

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

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

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

打赏作者

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

抵扣说明：

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

余额充值