红黑树模板

最新推荐文章于 2024-05-03 18:05:43 发布
最新推荐文章于 2024-05-03 18:05:43 发布
阅读量237 收藏
点赞数
分类专栏： 各类模板算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he_qingjun/article/details/119612340
版权
本文详细探讨了红黑树的数据结构及其关键操作，包括左旋、右旋、插入和删除。特别地，重点讲解了红黑树删除操作的难点，通过实例代码展示了如何处理删除节点后的平衡调整，确保红黑树性质得以维持。同时提供了完整的C++实现，包括查找、插入和删除等函数，帮助读者深入理解红黑树的工作原理。
摘要由CSDN通过智能技术生成

红黑树这一块的知识有点难懂，，难懂的地方就是左旋，右旋，插入调整，和删除调整，对我来说最难懂的还是删除部分，一直只得形不得意，，看着算法导论眼睛疼。。。这里有一位大佬讲的还行-》https://www.cnblogs.com/skywang12345/p/3245399.html

下面是我实现的代码，不够完善，因为我没有重复使用树根，先这样吧，回头复习时把他完善。。下面代码可以运行的哦，注意引用符号，之前有个地方就是因为我加了个引用就一直栈溢出。。。删除操作部分我注释了的那种方法也是可以的，不过我觉得麻烦。。从网上看到了一种简洁的写法就修改了下

代码：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
//红黑树学习，主要难点，左旋，右旋，插入，删除
//红黑树主要是为了保证二叉搜索树的平衡，避免出现一条简单路径的深度高，一条简单路径深度低的情况
//红黑树的效率高，保证在最坏的情况下的时间复杂度的为O(lgn)
//红黑树的五条性质：
//1.每个节点或是红色的，或是黑色的
//2.根节点是黑色的
//3.每个叶节点(NIL)是黑色的
//4.如果一个节点是红色的，则它的两个子结点都是黑色的
//5.对每个结点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色结点
//*************************数据结构定义阶段*************************
typedef enum{RED,BLACK} Color;

typedef struct BST{
    int key;    //关键字
    Color color;//节点颜色
    struct BST *p,*left,*right; //双亲，左孩子，右孩子
    
    BST(){color = BLACK; p = left = right = NULL;}  //无参构造

}BSTNode;

typedef struct BST_Root{    //树根
    BSTNode *root;
    BSTNode *nil;   //红黑树是以一个标记结尾的

    BST_Root(){     //
        
        nil = new BSTNode();
        nil->color = BLACK; 
        nil->p = nil->left = nil->right = NULL;
        root = nil;
    }

}BSTRoot;
BSTRoot BT;  //这里我直接把树根先建好，后面方便使用nil

//*************************数据结构定义阶段*************************

//*************************查找*************************
//和一般的二叉搜索树一样的操作,只是结尾标志不再是NULL，而是统一的nil

BSTNode* tree_search(BSTNode *&T,int k){    //递归查找

    if(T != BT.nil && T->key != k){
        if(k < T->key)
            return tree_search(T->left,k);
        else
            return tree_search(T->right,k);
    }
    return T;
}

BSTNode* interative_tree_search(BSTNode *&T,int k){     //非递归查找
    BSTNode *t = T;

    while(t != BT.nil && t->key != k){
        if(k < t->key)
            t = t->left;
        else
            t = t->right;
    }
    return t;
}

//*************************查找*************************

//************************最大关键字查询,最小关键字查询,前驱和后继查询************************

BSTNode* tree_minmum(BSTNode *&T){  //最小关键字查询
    BSTNode *t = T;

    while(t!=BT.nil && t->left != BT.nil){
        t = t->left;
    }
    return t;
}

BSTNode* tree_maxmum(BSTNode *&T){  //最大关键字查询
    BSTNode *t = T;

    while(t!=BT.nil && t->right != BT.nil){
        t = t->right;
    }
    return t;
}

BSTNode* tree_successor(BSTNode *&T){   //后继查询，后继就是大于T.x的最小关键字节点
    BSTNode *t = T,*y = BT.nil;
    if(T == BT.nil) return T; 

    if(T->right != BT.nil)          //如果右子树不为空直接求右子树的最小节点
        return tree_minmum(T->right);
    
    y = t->p;

    while(y != BT.nil && y->right == t){
        t = y;
        y = y->p;
    }
    return y;
}

BSTNode* tree_predecessor(BSTNode *&T){ //前驱查询，前驱就是小于T.x的最大关键字节点
    BSTNode *t = T,*y = BT.nil;
    if(T == BT.nil) return T;

    if(T->left != BT.nil)          //如果左子树不为空直接求左子树的最大节点
        return tree_maxmum(T->left);
    
    y = t->p;

    while(y != BT.nil && y->left == t){ //这里就是没有左子树的情况，往上找，看看上面还有没有小于t.x的节点
        t = y;
        y = y->p;
    }
    return y;
}

//************************最大关键字查询,最小关键字查询,前驱和后继查询************************

//************************左旋和右旋************************

void left_rotate(BSTNode *&T,BSTNode * x){

    BSTNode *y = x->right;  //x的右孩子取出来
    x->right = y->left; //把y的左孩子给x当右孩子
    
    if(y->left != BT.nil){  //y的左孩子不是nil就让它认x为爸爸
        y->left->p = x;
    }

    y->p = x->p;    //y认x的爸爸为爸爸

    if(x->p == BT.nil)  //如果x原来是根节点，那么更新根节点
        BT.root = y;
    else if(x == x->p->left)    //看x原来是它爸爸的左孩子还是右孩子，因为从现在开始x不是它原来爸爸的儿子了，y才是
        x->p->left = y;
    else
        x->p->right = y;
    y->left = x;
    x->p = y;
    
}

void right_rotate(BSTNode *&T,BSTNode *x){ //右旋，同上面是对称的
    
    BSTNode *y = x->left;

    x->left = y->right;

    if(y->right != BT.nil)
        y->right->p = x;
    
    y->p = x->p;

    if(x->p == BT.nil)
        BT.root = y;
    else if(x == x->p->left)
        x->p->left = y;
    else
        x->p->right = y;
    y->right = x;
    x->p = y;
}

//************************左旋和右旋************************

//************************插入************************

void RB_Insert_Fixup(BSTNode *&T,BSTNode *&z){
    //有三种情况，1.父节点是黑色的；2.z是根；3.父节点是红色的；三种情况只有3需要调整，1，2种不用
    while(z->p->color == RED){
        //看看父节点是祖父结点的左孩子还是右孩子
        if(z->p == z->p->p->left){
            //取得叔叔结点
            BSTNode *y = z->p->p->right;
           
            if(y->color == RED){
                //如果叔叔结点也是红色的，那么叔叔结点和父节点都修改成黑色，祖父结点修改成红色，再把当前结点改成祖父结点
                //这样修改就满足了第四条性质
                z->p->color = BLACK;
                y->color = BLACK;
                z->p->p->color = RED;
                z = z->p->p;
            }else if(z == z->p->right){
                //如果叔叔结点是黑色的，并且当前结点是父节点的右孩子，那么把当前结点修改成父节点，再对当前结点左旋
                z = z->p;
                left_rotate(T,z);
            }else if(z == z->p->left){
                //如果叔叔结点时黑色的，并且当前结点是父节点的左孩子，那么把父节点修改成黑色，祖父结点修改成红色，并对祖父结点右旋
                z->p->color = BLACK;
                z->p->p->color = RED;
                right_rotate(T,z->p->p);
            }
        }else { //下面操作与上面对称
            BSTNode *y = z->p->p->left;

            if(y->color == RED){
                y->color = BLACK;
                z->p->color = BLACK;
                z->p->p->color = RED;
                z = z->p->p;
            }else if(z == z->p->left){
                z = z->p;
                right_rotate(T,z);
            }else if(z == z->p->right){
                z->p->color = BLACK;
                z->p->p->color = RED;
                left_rotate(T,z->p->p);
            }
        }
    }
    BT.root->color = BLACK; //最后把根结点设置成黑色，此时整棵树以满足所有红黑树性质
}

void tree_insert(BSTNode *&T, int k){   //插入操作基本一样，就最后多了两步
    
    BSTNode *t = T,*y = T;

    BSTNode *z = new BSTNode();
    z->key = k;
    z->p = z->left = z->right = BT.nil;
    z->color = RED; //这里要把颜色设置为红色

    while(t!=BT.nil){
        
        y = t;
        if(k < t->key)
            t = t->left;
        else
            t = t->right;
    }

    z->p = y;

    if(y == BT.nil)
        BT.root = z;
    else if(k < y->key)
        y->left = z;
    else
        y->right = z;

    RB_Insert_Fixup(T,z);       //调整颜色，保持红黑性质
}

//************************插入************************


//************************删除************************

void tree_transplant(BSTNode *&T,BSTNode *&u,BSTNode *&v){  

    if(u->p == BT.nil)
        BT.root = v;
    else if(u == u->p->left)
        u->p->left = v;
    else
        u->p->right = v;
    v->p = u->p;
}

void RB_Delete_Fixup(BSTNode *&T,BSTNode *x){

    while(x != T && x->color == BLACK){

        if(x == x->p->left){
            BSTNode *w = x->p->right;

            if(w->color == RED){
                w->color = BLACK;
                x->p->color = RED;
                left_rotate(T,x->p);
                w = x->p->right;        //w是x的兄弟结点，所以这里要修改
            }else if(w->left->color == BLACK && w->right->color == BLACK){

                w->color = RED;
                x = x->p;
            }else if(w->left->color == RED && w->right->color == BLACK){
                w->left->color = BLACK;
                w->color = RED;
                right_rotate(T,w);
                w = x->p->right;
            }
            if(w->right->color == RED){
                w->color = x->p->color;
                x->p->color = BLACK;
                w->right->color = BLACK;
                left_rotate(T,x->p);
                x = T;

            }

        }else{
            BSTNode *w = x->p->left;

            if(w->color == RED){
                w->color = BLACK;
                x->p->color = RED;
                right_rotate(T,x->p);
                w = x->p->left;
            }else if(w->left->color == BLACK && w->right->color == BLACK){
                w->color = RED;
                x = x->p;
            }else if(w->left->color == BLACK && w->right->color == RED){
                w->right->color = BLACK;
                w->color = RED;
                w = x->p->left;
            }
            if(w->right->color == BLACK){
                w->color = x->p->color;
                x->p->color = BLACK;
                w->left->color = BLACK;
                right_rotate(T,x->p);
                x = T;
            }
            
        }
    }
    x->color = BLACK;
}


void tree_delete(BSTNode *&T,int k){  //删除

    BSTNode *z = tree_search(T,k);
    if(z == BT.nil) return;

    BSTNode *y = z,*x = NULL;
    // Color y_color = y->color;

 //如果两个孩子，就找到右子树中最小的结点，将之代替，然后直接删除该结点即可
    if(z->left != BT.nil && z->right != BT.nil){

        y = tree_minmum(z->right);
        z->key = y->key;//这里只对值进行复制，并不复制颜色，以免破坏红黑树的性质
        z = y;
    }
    if(z->left == BT.nil){
        x = z->right;
        tree_transplant(T,z,z->right);        
    }
    else if(z->right == BT.nil){
        x = z->left;
        tree_transplant(T,z,z->left);        
    }
    if(z->color == BLACK)
        RB_Delete_Fixup(T,x);
    delete z;
    // else{

    //     y = tree_minmum(z->right);  //后继
    //     y_color = y->color; 
    //     x = y->right;

    //     if(y->p == z)
    //         x->p = z;
    //     else {  
    //         tree_transplant(T,y,y->right);
    //         y->right = z->right;
    //         y->right->p = y;
    //     }
    //     tree_transplant(T,z,y);
    //     y->left = z->left;
    //     y->left->p = y;
    //     y->color = z->color;
    // }
    // if(y_color == BLACK)
    //     RB_Delete_Fixup(T,x);
}

//************************删除************************

void inorder_input(BSTNode *&T){ //中序遍历输出
    if(T!=BT.nil){
        inorder_input(T->left);
        printf("%d ",T->key);
        inorder_input(T->right);
    }
}

int main(){

    int a[9] = {11,2,14,1,7,15,5,8,4};

    for(int i = 0;i<9;i++)
        tree_insert(BT.root,a[i]);

    printf("inorder input primitive sequence: ");
    inorder_input(BT.root);
    putchar('\n');
    printf("after digit 7 be deleted: ");
    tree_delete(BT.root, 7);
    tree_delete(BT.root,14);
    inorder_input(BT.root);
    putchar('\n');
    system("pause");
    return 0;
}
white Era
关注
专栏目录
【模板】红黑树
wakawaka
12-22 494
#define BLACK 1 #define RED 0 class bst { private: struct Node { int value; bool color; Node *leftTree, *rightTree, *parent; Node() { color = RED;
红黑树详解及其模板类实现
Moyu的专栏
01-29 1082
一、历史 1972年，Rudolf Bayer发明了一种数据结构，这是一种特殊的4阶B树。这些树维护从根到叶的所有路径保持相同数量的节点，从而创建完美平衡的树。但是，它们不是二叉搜索树。Bayer在他的论文中将它们称为“对称二叉B树”（symmetric binary B-tree），后来它们作为2-4树（也称2-3-4树）变得流行。 在1978年的一篇论文“平衡树的二色框架”中，Leonid...
红黑树(RB_Tree) 模版
12-07
这是本人写的一个红黑树的模版，只需要改一下接口就可以用了。基本操作查找，删除，修改都是O(logn).
红黑树【模板】【高性能】
ZTJ的博客
02-21 592
#include<bits/stdc++.h> #include<thread> #include<windows.h> using namespace std; #define FIN freopen("D://debug//in.txt","r",stdin); #define FOUT freopen("D://debug//out.txt","w",stdout); #define FDATA freopen("D://debug//data.txt","w",s
红黑树数据结构的实现模板
weixin_44001521的博客
02-19 179
可以参考的学习资料： 30张图带你彻底理解红黑树–这个可以讲解思想来源 红黑树(一)之 原理和算法详细介绍–总结了算法的规则 【数据结构】带你轻松学习红黑树，菜鸟学习红黑树经验分享！ #include"pch.h" #include<iostream> #inclu...
红黑树_ C++模板实现
11-08
详细的红黑树C++模板实现，调试后运行正确。 template class RBTree { private: static node *nil;//哨兵，静态成员，被整个RBTree类所共有 node *root; RBTree(const RBTree&);//禁止复制构造 RBTree operator=(const RBTree&);//禁止赋值 void leftRotate(node*);//左旋 void rightRotate(node*);//右旋 void insertFixup(node*);//插入节点后红黑性质调整 void eraseFixup(node*);//删除节点后红黑性质调整 public: RBTree():root(nil) { root->parent = nil; root->left = nil; root->right = nil; root->color = black; } RBTree(node *rbt):root(rbt){}//复制构造函数，用于创建子红黑树对象 void insert(const T&);//插入 void create();//创建红黑树 void erase(const T&);//删除 node* locate(const T&)const;//查找 node* minMum()const;//最小值 node* maxMum()const;//最大值 node* successor(const T&)const;//找后继 node* predecessor(const T&)const;//前驱 void preTraversal()const;//先根遍历 void inTraversal()const;//中根遍历 void destroy();//销毁红黑树 bool empty()const{return root == nil;}//判空 };
C++实现红黑树模板类
"这是一个C++实现的红黑树模板类，包含插入、删除和查找操作，以及旋转函数。" 红黑树是一种自平衡的二叉查找树（BST），它在进行插入和删除操作后能保持相对较好的平衡性，从而提供高效的查找、插入和删除性能。在...
红黑树-基于C++实现的红黑树数据结构.zip
03-21
例如，在C++标准模板库(STL)中，`std::set`和`std::map`就是基于红黑树实现的。 在C++中实现红黑树时，通常会定义一个名为`RBTree`的类，包含私有成员变量（如根节点指针）和公共成员函数（如`insert`, `delete`, `...
红黑树java实现
11-22
### 红黑树Java实现详解 #### 一、红黑树简介 红黑树（Red-Black Tree）是一种自平衡二叉查找树。在计算机科学中，它被广泛应用于各种场景，比如作为关联数组的底层实现。红黑树通过在每个节点上存储一个额外的位...
模板--红黑树（C++实现）
qq_42418728的博客
01-18 463
一、结点类与红黑树类： （一）结点类基本数据成员： 1.左右子结点指针域 2.父结点指针域，方便回访父结点 3.有序 前驱 /后继指针域，迭代访问元素，提供一种顺序存储的假象 4.结点颜色，利用红黑规则，保持树的平衡。 （二）结点类的基本成员函数： 两个重载的构造函数，构造红色的新结点 （三）红黑树类基本数据成员： 1.头结点：保存一个据点，用来维系根节点与公用空结点 2....
（模板类）红黑树c++实现
10-02
红黑树的c++实现，代码注释详尽，另外在POJ上找了一个关于红黑树的题，A了，可以保证是正确的实现。 分多的小伙伴们送点分给我吧····哥另外的资源下载了500+次，但是CSDN设置每个资源分封底为100，导致现在我还是木有分可以用···十分的郁闷。
某高人实现的红黑树模板类
小豪之家
12-26 2279
某高人实现的红黑树模板类
数据结构-红黑树(Red-Black Tree)的C++实现模板
weixin_34290352的博客
08-21 137
2019独角兽企业重金招聘Python工程师标准>>> ...
c++模板实现红黑树
liuxiaokai_liu的博客
05-07 965
红黑树概念及构建规则请百度 #include&lt;assert.h&gt; enum Colour { RED, BLACK, }; template&lt;class K, class V&gt; struct RBTreeNode { RBTreeNode* _left; RBTreeNode* _right; RBTreeNode* _pare...
红黑树C++模板和仿函数实现
piaoxuelibin的专栏
12-30 713
<br />                                                               红黑树C++模板和仿函数实现1、红黑树暗地里和程序员打交道，比如set、map，这里就包括了很多语言如C++/Java/C#等OOP Language都包含实现它的代码，看了会STL源码中的红黑树，感觉要学的知识太多，很杂乱，六大组件，红黑树实现中要用到了常用的继承、迭代器等技术。<br /> <br /> <br />2、红黑树理论主要有(1)红黑树定义(2)插入算法(
红黑树(三) 之 C++ STL模板实现(完整源码)
Manofletters的博客
02-23 445
使用C++模板实现红黑树
我实现的红黑树C++模版类
Gamebaby Rock Sun的博客
10-10 367
下面是我实现的红黑树C++模版类，利用了windows中的一些特性，关于红黑树的算法我不再赘述，大家自己搜索一下，满网络都是，此处的实现是一个非常好用的模版版本。可以免费用于任何用途，在版本升级或发生变动后，本人将不通知任何使用者，但是如果需要技术支持、升级服务或培训服务的可以与本人联系，QQ 41750362。 //红黑树#include "GRSPublicDef.h"#include "G
二叉搜索树和红黑树概述以及模板实现(1)
文西
01-04 1166
最近研究了一下算法导论里面关于二叉搜索树和红黑树的一章，对于红黑树的内容虽然还没有完全消化吸收，写一篇blog算是对所有内容的一个复习和反思吧。 1. 二叉搜索树 二叉搜索树是一颗二叉树，要求对于任何一个节点，它的左儿子内的数据要小于根节点数据，而右节点的数据要大于根节点内的数据。 例如 在搜索问题中，虽然哈希表在比较好的情况下可以提供O(1)的时间，但是对于数据分布不好，或者数据
【数据结构】如何创建一棵红黑树（附动图讲解）
最新发布
Eristic0618的博客
05-03 2085
本篇文章围绕数据结构中的红黑树展开讲解，包含红黑树的性质、节点的定义、插入操作和验证红黑树等内容，内含自制动图方便理解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值