我的第一篇博客——红黑树的基本操作

最新推荐文章于 2024-08-19 23:33:53 发布
最新推荐文章于 2024-08-19 23:33:53 发布
阅读量303 收藏
点赞数
分类专栏： 数据结构 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34228690/article/details/51088577
版权

RBTree是相对平衡的二叉查找树(bst)，与AVL平衡二叉树相比，其”平衡“程度没有那么严格，因而在维护红黑树结构时需要较小的代价，总体性能较好（但是在有特殊查找要求时，考虑使用AVL_tree也是一个不错的选择。）下面我将写写RBTree的性质与基本操作：

首先来简单定义RBTree的节点，方便叙述

class RBTreeNode{
    int key;
    int color; //颜色值   1:BLACK 2:RED
    RBTreeNode p;  //父节点
    RBTreeNode left;  //左孩子
    RBTreeNode right; //右孩子
}

然后来了解RBTree的性质(专业定义请看算法导论红黑树章节)

1. root.color == BLACK  //根节点颜色为黑
2. node.color == BLACK OR RED   //每个节点的颜色为黑色或红色
3. if n.color == RED  //一个节点为红色，则两个孩子（非空的话）颜色为黑色
      n.left.color == BLACK  
      n.right.color == BLACK
4. node--->leaf 的路径上黑色节点数目相同 //任一节点到其叶子节点的路径上黑色节点的数目相同

由RBTree的性质，其颜色约束可以把RBTree的高度限制在log2^n以内,达到到降低时间复杂度的目的。

好了，现在就来看看基本的insert/delete/search 操作，因为RBTree是基于bst的，其search操作与bst的search一样，insert/delete也是在bst的insert/delete操作的基础上改进。由于intsert/delete时可能破坏RBTree的结构，所以需要维持其结构，一般通过改变相关节点的颜色或旋转来维护。

认识旋转操作：leftRotate(X)/rightRotate(Y)
这里写图片描述

分析insert操作（插入的节点颜色为红色，用n表示）
1. n == root //空树时插入，只破坏性质1
n.color = BLACK; return;
2. n != root //非空树时插入
a. if n.p == BLACK return; //性质1-4均没有被破坏
b. if n.p == RED //直接破坏了性质3,需要维护，在维护过程中只需关注n以及n的父亲·爷爷·叔叔，其中P:父亲 G:爷爷 U:叔叔，情况如下
这里写图片描述
由于前两种情况(LL/LR)与后两情况(RR/RL)镜面对称，讨论前两情况即可，代码实现时left与right互换即可。于是我们来看看前两情况的各种着色可能及应对策略

  1. P.color=BLACK; U.color=BLACK; G.color=RED; N=G;进入下一次迭代
    这里写图片描述
  2. rightRotate(G); P.color=BLACK; G.color=RED;进入下一次迭代
    这里写图片描述

  3. leftRotate(P); N<->P; rightRotate(G); P.color=BLACK; G.color=RED;进入下一次迭代

    这里写图片描述
    注意迭代终止条件为：上述1或2.a //while(n!=root && n.p.color==BLACK)

分析delete操作（删除节点为min，链接到n.p的节点为con）
1.删除点颜色为红色，return；
2.不为黑色则，把链接接上去的节点看成既具有自己的colo属性，也有一额外的“黑色”用来提高黑色节点数目，现在只要想办法把这个“黑色”转为某节点的color属性即可：
1. if con.color ==RED
con.color = BLACK; return;
2.关注con 及其父亲·叔叔·侄儿，情况如下：(灰色表示颜色不确定）
这里写图片描述
下面给出部分函数java代码实现：

class RBTreeNode{
    final static int BLACK = 1,RED = 0;
    int key;
    int color; //颜色值   1:BLACK 0:RED
    RBTreeNode p;  //父节点
    RBTreeNode left;  //左孩子
    RBTreeNode right; //右孩子
    RBTreeNode(int key,int color,RBTreeNode p,RBTreeNode left,RBTreeNode right){
        this.key = key;
        this.color = color;
        this.p = p;
        this.left = left;
        this.right = right;
    }
}

public class RBTree {
    private RBTreeNode root;
    RBTree(){ root = null;}
    void leftRotate(RBTreeNode x){//左旋转
        RBTreeNode y = x.right;
        if(x == root)
            root = y;
        else {
            if(x.p.left ==x) 
                x.p.left = y;
            else  
                x.p.right = y;
        }
        y.p = x.p;
        x.right = y.left;
        y.left = x;
        x.p = y;
        if(x.right != null)
            x.right.p = x;   
    }
    void rightRotate(RBTreeNode x){//右旋转
        RBTreeNode y = x.left;
        if(x == root)
            root = y;
        else {
            if(x.p.left ==x) 
                x.p.left = y;
            else  
                x.p.right = y;
        }
        y.p = x.p;
        x.left= y.right;
        y.right = x;
        x.p = y;
        if(x.left !=null)
            x.left.p = x;
    }
    void fixUpInsert(RBTreeNode n){   //插入后维持性质
        while(root != n && n.p.color == RBTreeNode.RED){
            if(n.p.p.left == n.p){  //LL LR
                if( n.p.right !=null &&
                    n.p.right.color == RBTreeNode.RED){
                    //情况2.1
                    n.p.color = RBTreeNode.BLACK;
                    n.p.color = RBTreeNode.BLACK;
                    n.p.p.color = RBTreeNode.RED;
                    n = n.p.p;
                 }
                 else {
                     if(n.p.right == n){
                         leftRotate(n.p);
                         n = n.left;
                     }
                     rightRotate(n.p.p);
                     n.p.color = RBTreeNode.BLACK;
                     n.p.right.color = RBTreeNode.RED;  
                 }
            }
            else{   //RR RL
                if( n.p.left !=null &&
                        n.p.left.color == RBTreeNode.RED){
                        n.p.color = RBTreeNode.BLACK;
                        n.p.color = RBTreeNode.BLACK;
                        n.p.p.color = RBTreeNode.RED;
                        n = n.p.p;
                     }
                     else {
                         if(n.p.left == n){
                             rightRotate(n.p);
                             n = n.right;
                         }
                         leftRotate(n.p.p);
                         n.p.color = RBTreeNode.BLACK;
                         n.p.left.color = RBTreeNode.RED;   
                     }
            }
        }
        root.color = RBTreeNode.BLACK;
    }
    void fixUpDelete(RBTreeNode n){ //删除后维持性质       
        //自己根据delete分析码出来吧
    }
    void insert(int key){  //插入操作
        if(root == null){  //空树时插入
            root = new RBTreeNode(key,RBTreeNode.BLACK,null,null,null);
        }
        else{  //非空树时插入
            RBTreeNode temRoot = root;
            RBTreeNode temRootPa =null;
            boolean markL = false;
            while(temRoot !=null){  //找到即将插入的位置
                markL = false;
                if(temRoot.key > key){
                    temRootPa = temRoot;
                    temRoot = temRoot.left;
                    markL = true; 
                }
                else {
                    temRootPa = temRoot;
                    temRoot = temRoot.right;
                }
            }
            if(markL){
                temRootPa.left = new RBTreeNode(key,RBTreeNode.RED,temRootPa,null,null);
                fixUpInsert(temRootPa.left);  //插入后维持性质
            }
            else {
                temRootPa.right = new RBTreeNode(key,RBTreeNode.RED,temRootPa,null,null);
                fixUpInsert(temRootPa.right);  //插入后维持性质
            }
        }
    }
    RBTreeNode getMin(RBTreeNode tem){
        while(tem.left != null)
            tem = tem.left;
        return tem;
    }
    void delete(int key){
            RBTreeNode temRoot = root;
            while(temRoot !=null){  //寻找要删除的节点
                if(temRoot.key > key)
                    temRoot = temRoot.left;
                else if(temRoot.key < key)
                    temRoot = temRoot.right;
                else break;
            }
            if(temRoot == null) return; //没有找到要删除的节点
            if(temRoot.left !=null && temRoot.right !=null){  //待删除节点有两个孩子
                RBTreeNode min = getMin(temRoot.right); //找到右子树中最小元素节点
                temRoot.key = min.key; //把待删除点转移到右子树中最小元素节点
                if(min.p.right == min) min.p.right = min.right;  //删除min节点
                else min.p.left = min.right;    
                fixUpDelete(min.right);  //删除后维持性质
            }
            else {
                RBTreeNode con = (temRoot.left != null ? temRoot.left : temRoot.right);
                //确定连接上去的节点
                if(temRoot ==root) //待删点为root
                    root = con;
                else{


                    if(temRoot.p.left == temRoot)
                    temRoot.p.left =con;
                    else temRoot.p.right = con;    
                }
                fixUpDelete(con);   //删除后维持性质
            }       
    }
}

h

莫小乐
关注
专栏目录
C++——红黑树
dongxue727504的博客
12-07 3004
C++之红黑树板块讲解
数据结构——二叉树——红黑树和哈夫曼树
xiaoyu1381的博客
08-16 561
数据结构——二叉树——红黑树和哈夫曼树
红黑树的各种操作
pleasetojava
11-01 141
红黑树各种操作 // 红黑树各种操作.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include&lt;iostream&gt; using namespace std; enum MyColor{red,black}; typedef int DType;...
红黑树详解
bianjilang1的专栏
10-05 820
介绍另一种平衡二叉树：红黑树（Red Black Tree），红黑树由Rudolf Bayer于1972年发明，当时被称为平衡二叉B树（symmetric binary B-trees），1978年被Leonidas J. Guibas 和Robert Sedgewick改成一个比较摩登的名字：红黑树。 红黑树和之前所讲的AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，
详细红黑树操作通俗易懂讲解（插入与删除+图片通俗讲解）
最新发布
weixin_62513677的博客
08-19 678
详细通俗易懂的红黑树操作讲解，快来看看吧
红黑树操作
weixin_33752045的博客
10-08 63
红黑树规则 每一个节点不是红色就是黑色的 根总是黑色的 如果节点是红色的,则它的子节点必须是黑色的(节点是黑色，子节点也可以为红色/黑色) 从根到叶节点或空子节点的每条路径，必须包含相同数目的黑色节点 试验1：插入两个红色节点 图1 试验2：旋转 1.向右旋转 图2 开始时如图1 选中50，向右旋转 父节点移到其右子节点位置 ...
红黑树基本操作
dudu3332的博客
03-02 750
很早之前就想写一篇关于红黑树的文章，但是由于担心自己理解的不透彻，就一直不敢下笔。于是在重新看了很多篇文章和资料之后，决定彻彻底底的把红黑树搞清楚。也希望让你在面试中游刃有余。OK，废话不多说，开始今天的文章。 整篇文章的思路是这样的，红黑树其实就是一种数据结构，设计它的目的就是为了高效地进行增删改查，所以我们文章的顺序也会按照这个思路来进行。我们先从二叉查找树逐渐引入到红黑树，然后再详细的讲解...
红黑树 操作
D-Boy的专栏
11-23 500
插入节点： #include #include using namespace std; static int _rb_black_node = 0; static int _rb_red_node = 1; template struct RBNode { RBNode():left(NULL),right(NULL),parent(NULL),
Java——红黑树
tyxtyx123的博客
06-12 1576
红黑树 1. 定义 首先来理解红黑树可以用来解决什么问题：普通的二叉搜索树在作为数据存储工具的时候，具有可以快速找到一个给定关键字的数据项，并且可以快速地插入和删除数据项等优点。其中，二叉搜索树只有当插入的数据是随机数据，插入可快速进行。但当插入的数值是有序的时候，二叉树就会变成非平衡的二叉树，那么它的快速查找、插入、删除指定数据项的能力就消失了。红黑树就可以解决非平衡树的问题，他可以被理解为是一种增加了某些特点的二叉搜索树。 维基百科中对红黑树的定义为：红黑树（英语：Red–black tree）是一种自
亲自动手绘图——红黑树，我不信还手撕不清楚
诗与远方的博客
06-27 220
前言 红黑树是自平衡的二叉查找树，在许多地方都有实际应用比如JAVA的HashMap，在链表长度大于8就会转化为红黑树；在linux经典的epoll中也使用了红黑树来保存文件描述符的插入删除操作。如果频繁地对数据进行插入删除，还要保证效率，使用红黑树是比较好的选择。 红黑树在实际表现上，还是一颗二叉树。在许多性质上和二叉树一样，所以要从二叉树查找开始讲起。 二叉查找树 二叉查找树是最简单的实现，规定左子节点一定小于右子节点。 插入情况只需要对当前节点比大小，不断的递归直到遇到空节点插入。 查询和插入相同，不
平衡树系列(1)——红黑树及其插入
独小雪的博客
11-22 338
平衡二叉树系列(1)——红黑树及其插入 1970 年，31 岁的 Hopcroft 教授研究出了一种新的数据结构，叫 2-3 树。后来的 B 树就是以它为基础的。1972年，Bayer 在 B 树的基础上又发明了“对称二叉 B 树”。六年后，施乐帕洛奥图研究中心（这个地方也是 GUI、Smalltalk 和鼠标的诞生地。）的 Guibas 和 Sedgewick 发了一篇论文，叫“平衡树的双色框架”。众所周知，框架是用来套的。把这个框架套给 Bayer 口中所说的“对称二叉 B 树” ，也就是下文将要提到的
红黑树 基本操作
qq_23835497的博客
05-17 451
红黑树首先是一棵二叉查找树，它每个结点都被标上了颜色（红色或黑色），红黑树满足以下5个性质： 1、 每个结点的颜色只能是红色或黑色。 2、 根结点是黑色的。 3、 每个叶子结点都带有两个空的黑色结点（被称为黑哨兵），如果一个结点n的只有一个左孩子，那么n的右孩子是一个黑哨兵；如果结点n只有一个右孩子，那么n的左孩子是一个黑哨兵。 4、 如果一个结点是红的，则它的两个儿子都是
红黑树及其操作
shengzhu1的博客
07-14 325
介绍另一种平衡二叉树：红黑树（Red Black Tree），红黑树由Rudolf Bayer于1972年发明，当时被称为平衡二叉B树（symmetric binary B-trees），1978年被Leonidas J. Guibas 和Robert Sedgewick改成一个比较摩登的名字：红黑树。 红黑树和之前所讲的AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从
红黑树的操作揭秘手册
stven_king的专栏
03-18 914
前言 二叉树知识点回忆以及整理这篇文章中我们说过“二叉树是一个简单的二分查找，但其性能取决于二叉树的层数”。 - 最好的情况是O(logn),存在于完全二叉树情况下，其访问性能近似于折半查找； - 最差的情况是O(n),比如插入的元素所有节点都没有左子树（右子树），这种情况需要将二叉树的全部节点遍历一次。 红黑树本质上是一种二叉查找树，在节点类中添加类一个用来标识颜色的字段，同时具有一...
红黑树的基本操作
w007d的专栏
07-26 284
红黑树的基本操作
《算法导论》第三版英文版——C++必备经典
书中特别强调了二叉搜索树、AVL树、红黑树和哈希表等高级数据结构，并讨论了它们的性质和操作。 此外，书中还涉及图算法，如最短路径问题（Dijkstra算法、Floyd-Warshall算法）、最小生成树（Prim算法、Kruskal算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值