算法导论学习笔记（三）红黑树

于 2016-07-18 20:13:32 发布
阅读量239 收藏
点赞数
分类专栏： 算法导论学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjphqpz/article/details/51945091
版权

算法导论学习笔记（三）红黑树

红黑树是众多平衡二叉树的一种，顾名思义，它由红黑两种节点构成；
它有以下五点性质：
1. 每个节点或是红色的，或是黑色的；
2. 根节点是黑色的；
3. 每个叶节点（NIL）是黑色的；
4. 如果一个节点是红色的，则其两个子节点都是黑色的；
5. 对于每个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点。
当满足以上5个性质的红黑树，就能保证没有一条路径会比其他路径长2倍以上，因而可看作近似平衡。

红黑树是我目前所见过的数据结构中，最为复杂的一种，目前只能初步了解其意图，而不知其真正的原理，故以下代码仍有不足——为经过完整测试，部分代码可能有错。

伪代码

RED-BLACK-INSERT(T, z)
    y = T.nil
    x = T.root
    while x != T.nil
        y = x
        if z.key < x.key
            x = x.left
        else x = x.right
    z.father = y
    if y == T.nil
        T.root = z
    elseif z.key < y.key
        y.left = z
    else y.right = z
    z.right = T.nil
    z.left = T.nil
    z.color = RED
    RED-BLACK-TREE-INSERT-FIXUP(T, z)

RED-BLACK-TREE-INSERT-FIXUP(T, z)
    while z.father.color == RED
        if( z.father == ( (z.father).father).left )
            y = ( (z.father).father).right
            if( y.color == RED)
                (z.father).color = BLACK
                y.color = BLACK
                ( (z.father).father).color = RED
                z = (z.father).father
            else 
                if z == (z.father).right
                    z = z.father
                    LEFT-ROTATE(T,z)
                (z.father).color = BLACK
                ( (z.fater).father).color = RED
                RIGHT-ROTATE(T, (z.father).father)
        else
            y = ( (z.father).father).left
            if( y.color == RED)
                (z.father).color = BLACK
                y.color = BLACK
                ( (z.father).father).color = RED
                z = (z.father).father
            else
                if z == (z.father).left
                    z = z.fahter
                    RIGHT-ROTATE(T, z)
                (z.father).color = BLACK
                ( (z.father).father).color = RED
                LEFT-ROTATE(T, (z.father).fater)

LEFT-ROTATE(T, x)
    y = x.right

    y.father = x.father
    if x.father == T.nil
        T.root = y
    elseif x == (x.father).left
        (y.father).left = y
    else (y.father).right = y

    x.right = y.left
    if x.right != T.nill
        (x.right).father = x

    y.left = x
    x.father = y

RIGHT-ROTATE(T, x)
    y = x.left

    y.father = x.father
    if x.father == T.nil
        T.root = y
    elseif x == (x.father).right
        (x.father).right = y
    else (x.father).left = y

    x.left = y.right
    if x.left != T.nil
        (x.left).father = x

    y.right = x
    x.father = y

RED-BLACK-DELETE( T, z )
    y = z
    y-original-color = y.color
    if z.left == T.nil
        x = z.right
        RED-BLACK-TRANSPLANT( T, z, z.right )
    elseif z.right == T.nil
        x = z.left
        RED-BLACK-TRANSPLANT( T, z, z.left )
    else
        y = getNextTreePoint( z.right )
        y-original-color = y.color
        x = y.right
        if y.p == z
            x.p = y
        else 
            RED-BLACK-TRANSPLANT( T, y, y.right )
            y.right = z.right
            y.right.p = y
        RED-BLACK-TRANSPLANT( T, z, y )
        y.left = z.left
        y.left.p = y
        y.color = z.color
    if y-original-color == BLACK
        RED-BLACK-DELETE-FIXUP( T, x )

RED-BLACK-TRANSPLANT( T, u, v )
    if u.p == T.nil
        T.root = v
    elseif u == u.p.left
        u.p.left = v
    else 
        u.p.right = v
    v.p = u.p

RED-BLACK-DELETE-FIXUP( T, x )
    while x != T.root and x.color == BLACK
        if x == x.p.left
            w = x.p.right
            if w.color == RED
                w.color = BLACK
                x.p.color = RED
                LEFT-ROATE( T, x.p )
                w = x.p.right
            if w.left.color == BLACK and w.right.color == BLACK
                w.color = RED
                x = x.p
            else 
                if w.right.color == BLACK
                    w.left.color = BLACK
                    w.color = RED
                    RIGHT-ROATE( T, w )
                    w = x.p.right
                w.color = x.p.color
                x.p.color = BLACK
                w.right.color = BLACK
                LEFT-ROATE( T, x.p )
                x = T.root
        else
            w = x.p.left
            if w.color == RED
                w.color = BLACK
                x.p.color = RED
                RIGHT-ROATE( T, x.p )
                w = x.p.left
            if w.right.color == BLACK and w.left.color == BLACK
                w.color = RED
                x = x.p
            else
                if w.left.color == BLACK
                    w.right.color = BLACK
                    w.color = RED
                    LEFT-ROATE( T, w)
                    w = x.p.left
                w.color = x.p.color
                x.p.color = BLACK
                w.left.color = BLACK
                RIGHT-ROATE( T, x.p )
                x = T.root
    x.color = BLACK

代码实现

#include <iostream>
#define RED true
#define BLACK false
using namespace std;
struct TreePoint
{
    int key;
    bool color;
    TreePoint* father;
    TreePoint* right;
    TreePoint* left;
    TreePoint(){}
    TreePoint(int key) {
        this->key = key;
        father = NULL;
        right = NULL;
        left = NULL;
    }
};
struct RedBlackTree
{
    TreePoint* root;
    TreePoint* nil;
    RedBlackTree(){
        nil = new TreePoint();
        nil->color = BLACK;
        root = nil;
        root->father = nil;
    }
};
void leftRotate(RedBlackTree &, TreePoint* );
void rightRotate(RedBlackTree &, TreePoint* );
TreePoint* getNextTreePoint(RedBlackTree &, TreePoint*);
void transplantRedBlackTree(RedBlackTree &, TreePoint*  ,TreePoint* );

void fixUpRedBlackTreeInserting(RedBlackTree &, TreePoint*);
void insertRedBlackTree(RedBlackTree &, TreePoint* );

void fixUpRedBlackTreeDeleting(RedBlackTree &, TreePoint*);
void deleteRedBlackTree(RedBlackTree &, TreePoint* );

TreePoint* findPoint(RedBlackTree &,TreePoint* , int );
void show(RedBlackTree &, TreePoint* );


int main()
{
    RedBlackTree redBlackTree;
    int n = 10;
    cin>>n;
    //while(n--) {
    int key;
    for(int i=0;i<n;++i){
        cin>>key;
        insertRedBlackTree(redBlackTree,new TreePoint(key));
    }
    show(redBlackTree,redBlackTree.root);
    cout<<endl;
    key = 7;
    TreePoint* find = findPoint(redBlackTree,redBlackTree.root,key);

    deleteRedBlackTree(redBlackTree,find);
    show(redBlackTree,redBlackTree.root);
    cout<<endl;
}


void insertRedBlackTree(RedBlackTree &T,TreePoint* z){
    TreePoint* y = T.nil;
    TreePoint* x = T.root;
    while( x != T.nil ) {
        y = x;
        if(z->key < x->key) {
            x = x->left;
        }
        else {
            x = x->right;
        }
    }
    z->father = y;
    if (y == T.nil) {
        T.root = z;
    }
    else if(z->key < y->key) {
        y->left = z;
    }
    else {
        y->right = z;
    }
    z->right = T.nil;
    z->left = T.nil;
    z->color = RED;
    fixUpRedBlackTreeInserting(T,z);
}

void fixUpRedBlackTreeInserting(RedBlackTree &T,TreePoint* z) {
    while( (z->father)->color == RED) {
        TreePoint* y;
        if( z->father == ( (z->father)->father)->left) {
            y = ( (z->father)->father)->right;
            if( y->color == RED) {
                (z->father)->color = BLACK;
                y->color = BLACK;
                ( (z->father)->father)->color = RED;
                z = (z->father)->father;
            }
            else {
                if( z == (z->father)->right) {
                    z = z->father;
                    leftRotate(T,z);
                }
                (z->father)->color = BLACK;
                ( (z->father)->father)->color = RED;
                rightRotate(T,(z->father)->father);
            }
        }
        else {
            y = ( (z->father)->father)->left;
            if( y->color == RED) {
                (z->father)->color = BLACK;
                y->color = BLACK;
                ( (z->father)->father)->color = RED;
                z = (z->father)->father;
            }
            else {
                if( z == (z->father)->left) {
                    z = z->father;
                    rightRotate(T,z);
                }
                (z->father)->color = BLACK;
                ( (z->father)->father)->color = RED;
                leftRotate(T,(z->father)->father);
            }
        }
    }
    (T.root)->color = BLACK;
}

void deleteRedBlackTree(RedBlackTree &T, TreePoint* z) {
    TreePoint* y = z;
    TreePoint* x;
    bool originalColor_y = y->color;
    if( z->left == T.nil ) {
        x = z->right;
        transplantRedBlackTree(T,z,z->right);
    }
    else if( z->right == T.nil) {
        x = z->left;
        transplantRedBlackTree(T,z,z->left);
    }
    else {
        y = getNextTreePoint(T,z->right);
        originalColor_y = y->color;
        x = y->right;
        if( y->father == z) {
            x->father = y;
        }
        else {
            transplantRedBlackTree(T,y,y->right);
            y->right = z->right;
            (y->right)->father = y;
        }
        transplantRedBlackTree(T,z,y);
        y->left = z->left;
        (y->left)->father = y;
        y->color = z->color;
    }
    if( originalColor_y == BLACK) {
        fixUpRedBlackTreeDeleting(T,x);
    }
}

void fixUpRedBlackTreeDeleting(RedBlackTree &T, TreePoint* x) {
    while( x != T.root && x->color == BLACK) {
        TreePoint* w;
        if( x== (x->father)->left) {
            w = (x->father)->right;
            if( w->color == RED) {
                w->color = BLACK;
                (x->father)->color = RED;
                leftRotate(T,x->father);
                w = (x->father)->right;
            }
            if( (w->left)->color == BLACK && (w->right)->color == BLACK) {
                w->color = RED;
                x = x->father;
            }
            else {
                if( (w->right)->color == BLACK) {
                    (w->left)->color = BLACK;
                    w->color = RED;
                    rightRotate(T,w);
                    w = (x->father)->right;
                }
                w->color = (x->father)->color;
                (x->father)->color = BLACK;
                (w->right)->color = BLACK;
                leftRotate(T,x->father);
                x = T.root;
            }
        }
        else {
            w = (x->father)->left;
            if( w->color == RED) {
                w->color = BLACK;
                (x->father)->color = RED;
                rightRotate(T,x->father);
                w = (x->father)->left;
            }
            if( (w->right)->color == BLACK && (w->left)->color == BLACK) {
                w->color = RED;
                x = x->father;
            }
            else {
                if( (w->left)->color == BLACK) {
                    (w->right)->color = BLACK;
                    w->color = RED;
                    leftRotate(T,w);
                    w = (x->father)->left;
                }
                w->color = (x->father)->color;
                (x->father)->color = BLACK;
                (w->left)->color = BLACK;
                rightRotate(T,x->father);
                x = T.root;
            }
        }
    }
    x->color = BLACK;
}

void leftRotate(RedBlackTree &T,TreePoint* x) {
    TreePoint* y;
    y = x->right;
    y->father = x->father;
    if( x->father == T.nil) {
        T.root = y;
    }
    else if( x == (x->father)->left) {
        (y->father)->left = y;
    }
    else {
        (y->father)->right = y;
    }
    x->right = y->left;
    if( x->right != T.nil ) {
        (x->right)->father = x;
    }
    y->left = x;
    x->father = y;
    }
    void rightRotate(RedBlackTree &T,TreePoint* x) {
    TreePoint* y;
    y = x->left;
    y->father = x->father;
    if( x->father == T.nil) {
        T.root = y;
    }
    else if( x == (x->father)->right) {
        (y->father)->right = y;
    }
    else {
        (y->father)->left = y;
    }
    x->left = y->right;
    if( x->left != T.nil ) {
        (x->left)->father = x;
    }
    y->right = x;
    x->father = y;
}

void transplantRedBlackTree(RedBlackTree &T, TreePoint* u,TreePoint* v) {
    if( u->father == T.nil ) {
        T.root = v;
    }
    else if( u == (u->father)->left ) {
        (u->father)->left = v;
    }
    else {
        (u->father)->right = v;
    }
    v->father = u->father;
}

TreePoint* getNextTreePoint(RedBlackTree &T, TreePoint* x) {
    while(x->left != T.nil){
        x = x->left;
    }
    return x;
}

TreePoint* findPoint(RedBlackTree &T, TreePoint* p, int key) {
    if(p == T.nil){
        return NULL;
    }
    else if(p->key == key){
        return p;
    }
    else if(p->key > key ) {
        return findPoint(T,p->left,key);
    }
    else {
        return findPoint(T,p->right,key);
    }
}

void show(RedBlackTree &T,TreePoint* p) {
    cout<<p->key<<" ";
    if( p->left != T.nil ) {
        show(T,p->left);
    }
    //cout<<p->key<<" ";
    if( p->right != T.nil ) {
        show(T,p->right);
    }
    //cout<<p->key<<" ";
}

/*
9
11 2 14 1 15 7 5 8 4
*/
隐藏在画中的落叶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法导论授课教案学习笔记
01-31
这份"算法导论授课教案学习笔记"是针对该书的深入学习资源，包括了教学教案、课后作业及解答，对于正在学习算法的学生来说，无疑是一份极其宝贵的参考资料。 教程部分可能涵盖以下知识点： 1. **算法基础**：介绍...
红黑树的理解与学习+伪代码
weixin_30511107的博客
02-17 487
在看HashMap源码的时候，涉及到红黑树，这个数据结构早已听闻大名，而且在学校的教材中没有讲这个数据结构，所以花了点时间去学习和理解这个数据结构。（比我想象中的复杂的多……） Red-Black Tree的简介 首先这是个二叉查找树，它属于但又不严格属于平衡二叉树（AVL），因为它没有像平衡二叉树一样，严格规定平衡因子的绝对值要小于等于1，而是靠他的颜色规定来达到高性能。 ...
红黑树的插入操作--伪代码详细分析
Norton的专栏
03-28 2937
学习的时候，最好把性质copy到记事本中，当别人提到性质1,2,3,4,不用翻来翻去。下面的是我学习《算法导论》的笔记。 性质1. 节点是红色或黑色。 性质2. 根是黑色。 性质3. 所有叶子都是黑色（叶子是NIL节点）。 性质4. 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点) 性质5. 从任一节点到其每个叶子的所有简单路径都包含相同数
MIT算法导论公开课的课程笔记（个人总结）
08-30
这份压缩包中的“MIT算法导论公开课之课程笔记”无疑是学习者宝贵的参考资料，它涵盖了课程的精华内容，可以帮助我们更好地理解和掌握算法的核心概念。 算法在计算机科学中扮演着至关重要的角色，它们是解决问题和...
MIT算法导论公开课之课程笔记 平衡搜索树.rar
07-06
在MIT的算法导论课程中，学生将深入学习这些数据结构的原理、操作以及性能分析。通过理解平衡搜索树的工作机制，可以设计出更高效的数据存储和检索解决方案，这对于软件工程师、数据库管理员以及其他涉及数据处理的...
算法导论试题及答案
06-10
5. **数据结构**：数组、链表、栈、队列、哈希表、树（二叉树、平衡树如AVL和红黑树）、图等，以及它们在算法实现中的角色。 6. **递归与分治**：递归函数的设计、分治策略的应用，如归并排序、快速排序、Strassen...
算法导论英文笔记和答案（较全）
11-17
文档《算法导论英文笔记和答案（较全）》是由Thomas H. Cormen、Clara Lee和Erica ...以上内容是针对《算法导论英文笔记和答案（较全）》文档内容的详细知识点梳理，对于学习和掌握算法理论和实践具有重要的指导意义。
【独家首发】基于蜣螂优化算法DBO-GMDH的风电数据回归预测研究Matlab实现.rar
最新发布
08-14
【独家首发】基于蜣螂优化算法DBO-GMDH的风电数据回归预测研究Matlab实现.rar
深度探索：神经网络在图像识别中的革命性应用
08-14
神经网络是一种受人脑结构启发的数学模型，它由大量的节点（或称为“神经元”）相互连接构成。这些节点通常组织成层，包括输入层、隐藏层和输出层。每个神经元可以接收来自前一层的输入，通过某种激活函数处理这些输入，然后将结果传递给下一层的神经元。 神经网络能够通过学习大量的数据来识别模式和特征，这使得它们在图像识别、语音识别、自然语言处理等领域有着广泛的应用。它们也可以用于预测、分类和回归等任务。 训练神经网络通常涉及到一个称为“反向传播”的过程，通过这个过程，网络可以调整其内部参数（权重和偏置），以便更好地完成特定的任务。这个过程通常需要大量的计算资源，并且伴随着梯度下降或其他优化算法来最小化损失函数，从而提高模型的性能。 随着深度学习技术的发展，神经网络变得更加复杂和强大，出现了各种类型的网络结构，比如卷积神经网络（CNNs）用于图像处理，循环神经网络（RNNs）用于序列数据，以及长短期记忆网络（LSTMs）等。
基础会计教学课件第十一章财务会计报告.pptx
08-14
基础会计教学课件第十一章财务会计报告.pptx
基于Android网络聊天软件APP设计与实现.docx
08-14
基于Android网络聊天软件APP设计与实现.docx
基于Android音乐播放器设计与实现2.docx
08-14
基于Android音乐播放器设计与实现2.docx
深度学习基础：理解神经网络及其应用.md
08-14
深度学习基础中的神经网络原理及其广泛应用。文章首先介绍了神经网络的基本构造、激活函数、反向传播等核心概念，详细讲解了卷积神经网络（CNN）、循环神经网络（RNN）等常见神经网络模型的特点及应用场景。接着，文章展示了神经网络在语音识别、图像识别、自动驾驶、医疗影像分析、金融分析、推荐系统等领域的成功案例。此外，还讨论了深度学习的发展趋势，如更深层次的网络、自监督学习、模型压缩、多模态学习及其在实际应用中的挑战与局限性。文章特别提到神经网络对数据的高度依赖、训练中的计算成本、模型的可解释性问题以及泛化能力不足等技术难点。总体上，本文为读者提供了一个从基础到应用、从原理到前沿发展的全景视角，强调了深度学习在推动人工智能技术发展的重要性。
员工关系中的法律问题.pptx
08-14
员工关系中的法律问题.pptx
高效记录与整理编程学习笔记工具
08-14
Obsidian 是一个以 Markdown 为基础的笔记软件，支持双向链接和知识图谱，非常适合建立个人知识网络。Obsidian 的社区中有很多中文用户，而且可以下载中文插件实现中文界面。
螺旋矩阵算法.txt 基于一维数组与vector完成二级索引优化
08-14
00 01 02 03 04 05 06 07 08 09 00 01 02 03 04 05 06 07 08 09 35 00 00 00 00 00 00 00 00 10 35 36 37 38 39 40 41 42 43 10 34 00 00 00 00 00 00 00 00 11 34 63 64 65 66 67 68 69 44 11 33 00 00 00 00 00 00 00 00 12 33 62 83 84 85 86 87 70 45 12 32 00 00 00 00 00 00 00 00 13 32 61 82 95 96 97 88 71 46 13 31 00 00 00 00 00 00 00 00 14 ...... 31 60 81 94 99 9
openvswitch
08-14
openvswitch
ssm_126_mysql_实习支教中小学学校信息管理系统_.zip
08-14
本系统的后台语言使用的是JSP，JSP是一种动态编程语言，可以对数据进行增删改查等操作。在JSP、ASP、PHP等动态语言出现之前，很多网站就只能用静态的HTML语言宣传自己的网站，但这种网站不具备数据的存储操作功能，因为无法连接数据库，本系统使用的JSP语言可以与HTML语言有效的结合起来，不仅可以将各类素材展现在页面上，还可以将数据保存在数据库中。 选择JSP技术开发主要因为其有以下几个优点： （1）首先就是因为JSP的结构清晰、易于理解，而且JSP是面向对象的编程语言，可以使用封装、继承和多态等技术，可以使用类和对象的思想解决很多问题，可以极大的提高编码效率。 （2）选择JSP的第二个原因就是它在浏览器中的响应速度较快，可以提高本系统运行的速度。 （3）选择JSP作为本系统开发技术的第三个原因就是它具备较为稳定的连接数据库的方法，可以使数据稳定地进行存储和更新。
通用的C++数据结构代码实现，使用模板 代码完整，注释齐全，可直接运行，可使用doxygen生成网页和PDF文档
08-14
通用于各类数据结构与算法(C++语言)教材，适用于自学、课程设计/毕业设计和考研复习等。完整的代码实现，可直接运行调试，使用模板，方便灵活。代码注释完整，可生成网页版/PDF文档，效果丰富
红黑树：算法导论第三章关键数据结构
总结来说，算法导论第三章的PPT内容深入讲解了数据结构中的动态集合以及其中的红黑树，强调了它们在执行高效集合操作中的关键作用，并提供了多种实现方式供读者理解和实践。理解并掌握这部分内容对于深入学习算法和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值