数据结构与算法分析：红黑树

已于 2022-10-08 11:03:44 修改
阅读量92 收藏
点赞数
分类专栏： 学习笔记 数据结构与算法总结 文章标签： c++ 开发语言
于 2022-10-03 16:52:50 首次发布
原文链接：https://www.cnblogs.com/skywang12345/p/3624291.html
版权

来自 红黑树(四)之 C++的实现

#include <iostream>
#include <iomanip>
using namespace std;

template<class T>
class RBTree{
    //红黑树,最坏情形O(logN),图示见 https://www.cnblogs.com/skywang12345/p/3245399.html
    //满足下面性质的二分查找树
    //(0.nullptr节点视为黑色)
    //1.节点是红色或黑色
    //2.整棵树的根是黑色
    //3.如果一个节点是红色,子节点必须是黑色
    //4.从一个节点到一个nullptr指针的每一条路径必须包含相同数目的黑色节点

    //红黑树的高度最多是2log(N+1),保证查找是对数操作

    #define rb_parent(r)   ((r)->parent)
    #define rb_color(r) ((r)->color)
    #define rb_is_red(r)   ((r)->color==RED)
    #define rb_is_black(r)  ((r)->color==BLACK)
    #define rb_set_black(r)  do { (r)->color = BLACK; } while (0)
    #define rb_set_red(r)  do { (r)->color = RED; } while (0)
    #define rb_set_parent(r,p)  do { (r)->parent = (p); } while (0)
    #define rb_set_color(r,c)  do { (r)->color = (c); } while (0)


private:
    enum RBTColor{RED,BLACK};
    struct RBTNode{
        RBTColor color;
        T data;
        RBTNode* left;
        RBTNode* right;
        RBTNode* parent;
        RBTNode(T v,RBTColor c,RBTNode* l,RBTNode* r,RBTNode* p):data(v),left(l),right(r),parent(p),color(c){};
    };
    RBTNode* root;
    void inOrderTraversal(RBTNode* node){
        if (!node) return;
        inOrderTraversal(node->left);
        cout << node->data << ' ';
        inOrderTraversal(node->right);
    }

    void print(RBTNode* tree,T v,int direction){
        if (tree){
            if (direction==0) cout << setw(2) << tree->data << "(B) is root" << endl;
            else cout << setw(2) << tree->data <<  (rb_is_red(tree)?"(R)":"(B)") << " is " << setw(2) << v << "'s "  << setw(12) << (direction==1?"right child" : "left child") << endl;
        }
        if (tree->left) print(tree->left,tree->data,-1);
        if (tree->right) print(tree->right,tree->data,  1);
    }

    //插入叶子节点应该是红色,因为如果是黑色就会违背性质4
    //下面如果其父节点是黑色可以直接结束,如果是红色必须调整树使其满足性质3
    //上面链接中的原文分析得很精彩,不懂why可以去看

    //对x进行左旋=>x的右子节点代替x,x成为其左子节点
    //对x进行右旋=>x的左子节点代替x,x成为其右子节点

    void leftRotate(RBTNode* &root, RBTNode* x){
        // 设置x的右孩子为y
        RBTNode *y = x->right;

        // 将 “y的左孩子” 设为 “x的右孩子”；
        // 如果y的左孩子非空，将 “x” 设为 “y的左孩子的父亲”
        x->right = y->left;
        if (y->left) y->left->parent = x;

        // 将 “x的父亲” 设为 “y的父亲”
        y->parent = x->parent;

        if (!x->parent) root = y;   // 如果 “x的父亲” 是空节点，则将y设为根节点
        else{
            if (x->parent->left == x) x->parent->left = y;    // 如果 x是它父节点的左孩子，则将y设为“x的父节点的左孩子”
            else x->parent->right = y;    // 如果 x是它父节点的左孩子，则将y设为“x的父节点的左孩子”
        }

        // 将 “x” 设为 “y的左孩子”
        y->left = x;
        // 将 “x的父节点” 设为 “y”
        x->parent = y;
    }


/*
 * 对红黑树的节点(y)进行右旋转
 *
 * 右旋示意图(对节点y进行左旋)：
 *            py                               py
 *           /                                /
 *          y                                x
 *         /  \      --(右旋)-->            /  \                     #
 *        x   ry                           lx   y
 *       / \                                   / \                   #
 *      lx  rx                                rx  ry
 *
 */
    void rightRotate(RBTNode* &root, RBTNode* y){
        // 设置x是当前节点的左孩子。
        RBTNode *x = y->left;

        // 将 “x的右孩子” 设为 “y的左孩子”；
        // 如果"x的右孩子"不为空的话，将 “y” 设为 “x的右孩子的父亲”
        y->left = x->right;
        if (x->right) x->right->parent = y;

        // 将 “y的父亲” 设为 “x的父亲”
        x->parent = y->parent;

        if (!y->parent) root = x;            // 如果 “y的父亲” 是空节点，则将x设为根节点
        else{
            if (y == y->parent->right) y->parent->right = x;    // 如果 y是它父节点的右孩子，则将x设为“y的父节点的右孩子”
            else y->parent->left = x;    // (y是它父节点的左孩子) 将x设为“x的父节点的左孩子”
        }

        // 将 “y” 设为 “x的右孩子”
        x->right = y;

        // 将 “y的父节点” 设为 “x”
        y->parent = x;
    }


    //插入的叶子结点(当前节点)是红色,父节点也是红色可分为下面三种情况:
    //1.叔叔节点(父亲的兄弟节点)也是红色:父变黑.叔变黑,祖父变红,将祖父设为当前节点
    //2.叔叔节点(父亲的兄弟节点)是黑色,且待插入节点是挂在了右边:将父节点设为当前节点,当前节点左旋(这样插入的节点代替了原来的父节点)
    //3.叔叔节点(父亲的兄弟节点)是黑色,且待插入节点是挂在了左边:父变黑,祖父变红,祖父节点右旋

    void insert(RBTNode* &root,RBTNode* node){
        RBTNode* parent=nullptr;
        RBTNode* cur=root;
        while (cur){
            parent=cur;        //保存路径的上一个顶点,找到要插入的位置的父节点
            if (node->data<cur->data) cur=cur->left;
            else cur=cur->right;
        }
        node->parent=parent;
        if (parent){
            if (node->data<parent->data) parent->left=node;
            else parent->right=node;
        }
        else root=node;

        node->color=RED;
        insertAdjust(root,node);  //调整成红黑树
    }
    void insertAdjust(RBTNode* &root,RBTNode* node){
        RBTNode* parent,*gparent;
        while ((parent=rb_parent(node)) && rb_is_red(parent)){
            //父节点存在且是红色
            gparent=rb_parent(parent);
            if (parent==gparent->left){
                RBTNode* uncle=gparent->right;
                if (uncle && rb_is_red(uncle)){
                    //情况1
                    rb_set_black(parent);
                    rb_set_black(uncle);
                    rb_set_red(gparent);
                    node=gparent;
                }
                else if (parent->right==node){
                    //情况2
                    leftRotate(root,parent);
                    RBTNode* tmp=parent;
                    parent=node;
                    node=tmp;
                }

                //情况3
                rb_set_black(parent);
                rb_set_red(gparent);
                rightRotate(root,gparent);
            }
            else{
                RBTNode* uncle = gparent->left;
                if (uncle && rb_is_red(uncle)){
                    if (uncle && rb_is_red(uncle)){
                        //情况1
                        rb_set_black(uncle);
                        rb_set_black(parent);
                        rb_set_red(gparent);
                        node = gparent;
                        continue;
                    }
                }
                else if (parent->left == node){
                    //情况2
                    RBTNode* tmp;
                    rightRotate(root, parent);
                    tmp = parent;
                    parent = node;
                    node = tmp;
                }
                //情况3
                rb_set_black(parent);
                rb_set_red(gparent);
                leftRotate(root, gparent);
            }
        }
        rb_set_black(root);
    }

    RBTNode* search(RBTNode* x, T v) const{
        if (!x || x->data==v) return x;
        if (v < x->data) return search(x->left, v);
        else return search(x->right, v);
    }

    //删除节点(与二叉搜索树操作一样)之后调整成红黑树
    void remove(RBTNode* &root, RBTNode *node){
        RBTNode *child, *parent;
        RBTColor color;

        if ((node->left) && (node->right)){
            RBTNode *replace = node;

            replace = replace->right;
            while (replace->left) replace = replace->left; //右子树的最小节点代替

            if (rb_parent(node)){
                if (rb_parent(node)->left == node) rb_parent(node)->left = replace;
                else rb_parent(node)->right = replace;
            }
            else root = replace;

            child = replace->right;
            parent = rb_parent(replace);

            color = rb_color(replace);


            if (parent == node) parent = replace;
            else{
                if (child) rb_set_parent(child, parent);
                parent->left = child;
                replace->right = node->right;
                rb_set_parent(node->right, replace);
            }

            replace->parent = node->parent;
            replace->color = node->color;
            replace->left = node->left;
            node->left->parent = replace;

            if (color == BLACK) removeAdjust(root, child, parent);

            delete node;
            return ;
        }

        if (node->left) child = node->left;
        else child = node->right;

        parent = node->parent;
        color = node->color;

        if (child) child->parent = parent;

        if (parent){
            if (parent->left == node) parent->left = child;
            else parent->right = child;
        }
        else root = child;
        if (color == BLACK) removeAdjust(root, child, parent);
        delete node;
    }

    void removeAdjust(RBTNode* &root, RBTNode *node, RBTNode *parent){
        RBTNode *other;

        while ((!node || rb_is_black(node)) && node != root){
            if (parent->left == node){
                other = parent->right;
                if (rb_is_red(other)){
                    // Case 1: x的兄弟w是红色的
                    rb_set_black(other);
                    rb_set_red(parent);
                    leftRotate(root, parent);
                    other = parent->right;
                }
                if ((!other->left || rb_is_black(other->left)) && (!other->right || rb_is_black(other->right))){
                    // Case 2: x的兄弟w是黑色，且w的俩个孩子也都是黑色的
                    rb_set_red(other);
                    node = parent;
                    parent = rb_parent(node);
                }
                else{
                    if (!other->right || rb_is_black(other->right)){
                        // Case 3: x的兄弟w是黑色的，并且w的左孩子是红色，右孩子为黑色。
                        rb_set_black(other->left);
                        rb_set_red(other);
                        rightRotate(root, other);
                        other = parent->right;
                    }
                    // Case 4: x的兄弟w是黑色的；并且w的右孩子是红色的，左孩子任意颜色。
                    rb_set_color(other, rb_color(parent));
                    rb_set_black(parent);
                    rb_set_black(other->right);
                    leftRotate(root, parent);
                    node = root;
                    break;
                }
            }
            else{
                other = parent->left;
                if (rb_is_red(other)){
                    // Case 1: x的兄弟w是红色的
                    rb_set_black(other);
                    rb_set_red(parent);
                    rightRotate(root, parent);
                    other = parent->left;
                }
                if ((!other->left || rb_is_black(other->left)) && (!other->right || rb_is_black(other->right))){
                    // Case 2: x的兄弟w是黑色，且w的俩个孩子也都是黑色的
                    rb_set_red(other);
                    node = parent;
                    parent = rb_parent(node);
                }
                else{
                    if (!other->left || rb_is_black(other->left)){
                        // Case 3: x的兄弟w是黑色的，并且w的左孩子是红色，右孩子为黑色。
                        rb_set_black(other->right);
                        rb_set_red(other);
                        leftRotate(root, other);
                        other = parent->left;
                    }
                    // Case 4: x的兄弟w是黑色的；并且w的右孩子是红色的，左孩子任意颜色。
                    rb_set_color(other, rb_color(parent));
                    rb_set_black(parent);
                    rb_set_black(other->left);
                    rightRotate(root, parent);
                    node = root;
                    break;
                }
            }
        }
        if (node) rb_set_black(node);
    }

    public:
        RBTree():root(nullptr){};
        void inOrderTraversal(){inOrderTraversal(root);}
        void insert(T v){
            RBTNode* z=new RBTNode(v,BLACK,nullptr,nullptr,nullptr);
            insert(root,z);
        }
        void remove(T v){
            RBTNode* node;
            if ((node = search(root, v))) remove(root, node);
        }
        void print(){
            if (root) print(root,root->data,0);
        }


};

int main()
{
    int a[]= {10, 40, 30, 60, 90, 70, 20, 50, 80};
    int check_insert=1;    // "插入"动作的检测开关(0，关闭；1，打开)
    int check_remove=1;    // "删除"动作的检测开关(0，关闭；1，打开)
    int i;
    int ilen = (sizeof(a)) / (sizeof(a[0])) ;
    RBTree<int>* tree=new RBTree<int>();

    cout << "== 原始数据: ";
    for(i=0; i<ilen; i++)
        cout << a[i] <<" ";
    cout << endl;

    for(i=0; i<ilen; i++)
    {
        tree->insert(a[i]);
        // 设置check_insert=1,测试"添加函数"
        if(check_insert)
        {
            cout << "== 添加节点: " << a[i] << endl;
            cout << "== 树的详细信息: " << endl;
            tree->print();
            cout << endl;
        }

    }

    cout << "\n== 中序遍历: ";
    tree->inOrderTraversal();


    cout << "== 树的详细信息: " << endl;
    tree->print();

    // 设置check_remove=1,测试"删除函数"
    if(check_remove)
    {
        for(i=0; i<ilen; i++)
        {
            tree->remove(a[i]);

            cout << "== 删除节点: " << a[i] << endl;
            cout << "== 树的详细信息: " << endl;
            tree->print();
            cout << endl;
        }
    }
    return 0;
}
_森罗万象
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构：红黑树原理分析和C语言实现分步详解
black_kyatu的博客
02-10 967
数据结构之红黑树详解红黑树简介什么是红黑树为什么要用B树B树的性质B+树C语言实现数据结构定义创建B树初始化一个空节点根据给定的数据集合进行建树节点插入判断节点是否是满节点进行递归插入子树的分裂 红黑树简介 什么是红黑树 红黑树是一种特殊的二叉查找树通过巧妙的设计，使得其 为什么要用B树 B树查找数据速度快，和红黑树等平衡二叉查找树相当，同时由于B树的每个节点可以包含多个数据关键字，相当于对数的...
c语言红黑树,数据结构与算法 ：红黑树 C语言实现
weixin_34520503的博客
05-19 340
花了好几天的业余时间，看文章，总算是用C实现了一遍红黑树，主要还是自己C语言水平不够高，调试断点浪费了不少时间，闲话少说·····································LSP的分割线·····································最近整理代码，在掘金整理了最新的红黑树实现代码，比这里更整洁，这里就不重新发了，详见同名掘金博客1. 红黑树结构体//...
数据结构与算法（C语言版）__红黑树02
Software's Blog
12-30 411
今天继续丰富红黑树，我们继续上一个博客今天写红黑树的insert功能 在头文件中添加Except.h和RedBlackTree.h在源文件中添加TestRedBlackTree.cpp//Except.h //返回异常 #ifndef EXCEPT_H #define EXCEPT_H#include<string>using namespace std;class DSException{ pu
数据结构与算法：红黑树的原理分析
riskys的博客
05-20 1186
原文链接：http://www.cnblogs.com/yangecnu/p/Introduce-Red-Black-Tree.html 前面一篇文章介绍了2-3查找树，可以看到，2-3查找树能保证在插入元素之后能保持树的平衡状态，最坏情况下即所有的子节点都是2-node，树的高度为lgN，从而保证了最坏情况下的时间复杂度。但是2-3树实现起来比较复杂，本文介绍一种简单实现2-3树的数据
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
本资源"数据结构与算法分析--C语言描述"是针对数据结构初学者的一个优秀教材，旨在帮助读者快速掌握这一领域。 首先，数据结构是组织和存储数据的方式，它决定了数据的访问效率和处理速度。常见的数据结构包括数组...
《数据结构与算法分析：C语言描述》 三份参考源代码
03-03
《数据结构与算法分析：C语言描述》是计算机科学领域一本经典的教材，由Mark Allen Weiss撰写，主要关注如何使用C语言来实现和分析各种数据结构和算法。这本书深入浅出地讲解了数据结构如数组、链表、栈、队列、树、...
C++笔记5•内存管理•
qq_64446190的博客
08-12 1039
内存管理
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
qq_19319481的博客
08-09 369
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
C语言一维数组(含数组二分查找)
hdxbufcbjuhg的博客
08-09 1240
在⼀个升序的数组中查找指定的数字n，很容易想到的⽅法就是遍历数组，但是这种⽅法效率⽐较低。比如我们之前写的猜数字游戏，会生成一个随机数来让玩家猜，范围是1~100，那玩家会从1开始一个一个猜吗，不会吧，那样就太慢了，我们一般会从整体的一半开始猜，比如猜50，告诉你大了还是小了，这样只需要一步就可以排除庞大数字中的一半，比如假设猜1 ~ 10000，猜5000后就可以知道猜大了还是小了，直接排除了5000个数字，效率很快，这就是⼆分查找，也叫折半查找。
【C++】类的默认成员函数，构造函数、析构函数、拷贝构造函数、运算符重载
2402_82757055的博客
08-10 929
这篇我们继续学习C++类和对象部分，大概会说一下类的一些默认成员函数，构造函数、析构函数、拷贝构造函数、赋值运算符重载这些知识。
C语言断言进阶篇：全面总结与实战技巧
极客代码
08-10 487
断言是一种用于验证程序中某个条件是否为真的语句。如果条件为假，程序会触发一个错误，通常会导致程序终止。断言主要用于开发和测试阶段，以帮助开发者发现和修正错误。在某些情况下，默认的assert宏可能无法满足我们的需求。if (!abort();= NULL);在这个自定义断言宏中，我们输出了更多的错误信息，包括失败的断言表达式、函数名、文件名和行号，方便我们定位错误。本文系统且全面地总结了C语言中的断言机制，包括断言的定义、作用、实现以及在实战中的运用。
【C语言】字符串操作函数详解
EleganceJiaBao的博客
08-14 512
这些头文件提供了字符串操作所需的函数声明。以下是常用字符串操作函数的详细讲解，包括每个函数的参数、返回值说明以及示例代码。每个函数的使用说明还包括了适当的表格以帮助理解其功能和用法。
C++_基本语法笔记_模板
最新发布
qq_45629864的博客
08-14 297
思想是Java里的泛型（不确定用什么类型的数据）这里template这一句，意思是声明T是泛型，后面写用到泛型T的函数。建议都用应用场景：不同数据类型的交换函数。
C++的内存分区
m0_63764282的博客
08-14 340
在C++中，程序的内存主要被分为几个不同的区域（或称为“分区”），这些区域用于存储不同类型的数据。
C语言常用关键字
Fearlessness的博客
08-14 441
C语言中常用的关键字
C++ 知识点（长期更新）
weixin_51332735的博客
08-09 2174
必知必会
矩阵转置（c语言）
scy2429828663的博客
08-09 806
int m = 0;int a = 0;//输入 n m//将数据存储在arr上//输入 aj < n;j++)i < m;i++)//转置i < m;i++)j < n;
C++ Poco框架判断请求方式是GET还是POST
jiexijihe945的博客
08-09 274
作为服务器开发者GET和POST等Method还是要区分的，不同的请求方法要走不同的逻辑。这篇文章很简短但是基于另一篇文章，如果你已经了解Poco了就不用看了。手把手教你使用Poco框架开发服务器应用1、看似简单的一个小函数却是决定成败的关键。
C++版数据结构与算法分析：习题解析
"数据结构与算法分析C++（第3版）课后习题答案" 这篇摘要提供的是关于《数据结构与算法分析C++（第3版）》一书的课后习题解答资源。这本书是学习数据结构和算法的重要教材，C++语言的第三版意味着它可能包含了最新...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值