红黑树

最新推荐文章于 2024-08-22 18:25:36 发布
最新推荐文章于 2024-08-22 18:25:36 发布
阅读量934 收藏 12
点赞数 2
分类专栏： 高级数据结构 文章标签： 红黑树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sspudding/article/details/97114156
版权

目录

一、定义

为了解决BST树在最坏情况会退化成链表，有了AVL树，但是AVL树为了维护节点平衡，在插入和删除时做了大量的旋转操作，当数据量过大时，AVL树的旋转操作就拖慢了插入删除的时间。

为了解决这个问题，就有了红黑树。

红黑树的特点：

  • 红黑树是不是一棵平衡树
  • 红黑树节点左右子树高度差不超过2倍（长的不能超过短的2倍）， 牺牲了一些平衡，使得插入删除操作更快
  • 红黑树插入最多旋转两次，删除最多旋转三次

红黑树的五个性质：

  • 每个节点都有颜色，不是黑色就是红色
  • 根节点root必须是黑色
  • 叶子节点都是黑色（指叶子节点的地址域null为黑色，一般null节点默认颜色是黑色）
  • 不能出现连续的红色节点，也就是说红色节点的孩子节点必须是黑色的
  • 从根节点root到达每一个叶子节点的路径上，黑色节点的数量都是相同的

这是一个简单的红黑树：
在这里插入图片描述

/**
 * 红黑树节点颜色定义
 */
enum Color{
    BLACK,RED
}

/**
 * 红黑树节点类型定义
 * @param <T>
 */
class RBNode<T extends Comparable<T>>{
    private T data;
    private RBNode<T> left;
    private RBNode<T> right;
    private RBNode<T> parent;
    private Color color;

    public RBNode(T data, RBNode<T> left, RBNode<T> right, RBNode<T> parent, Color color) {
        this.data = data;
        this.left = left;
        this.right = right;
        this.parent = parent;
        this.color = color;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public RBNode<T> getLeft() {
        return left;
    }

    public void setLeft(RBNode<T> left) {
        this.left = left;
    }

    public RBNode<T> getRight() {
        return right;
    }

    public void setRight(RBNode<T> right) {
        this.right = right;
    }

    public RBNode<T> getParent() {
        return parent;
    }

    public void setParent(RBNode<T> parent) {
        this.parent = parent;
    }

    public Color getColor() {
        return color;
    }

    public void setColor(Color color) {
        this.color = color;
    }
}

/**
 * RB树定义
 * @param <T>
 */
class RBTree<T extends Comparable<T>> {
    private RBNode<T> root;

    public RBTree() {
        this.root = null;
    }

    /**
     * 获取红黑树节点颜色
     * @param node
     * @return
     */
    private Color color(RBNode<T> node){
        return node == null ? Color.BLACK : node.getColor();
    }

    /**
     * 设置节点颜色
     * @param node
     * @param color
     */
    public void setColor(RBNode<T> node, Color color){
        node.setColor(color);
    }

    /**
     * 获取node节点的左孩子节点
     * @param node
     * @return
     */
    public RBNode<T> left(RBNode<T> node){
        return node.getLeft();
    }

    /**
     * 获取当前节点的右孩子节点
     * @param node
     * @return
     */
    public RBNode<T> right(RBNode<T> node){
        return node.getRight();
    }

    /**
     * 获取 当前节点的父节点
     * @param node
     * @return
     */
    public RBNode<T> parent(RBNode<T> node){
        return node.getParent();
    }
}

二、红黑树的旋转

红黑树的左旋和右旋操作同AVL树的左旋右旋原理一样，如果不明白可以参考博客AVL树看详细的图解左旋和右旋操作

左旋操作
private void leftRotate(RBNode<T> node) {
    RBNode<T> child = node.getRight();
    child.setParent(node.getParent());
    if (node.getParent() == null) {
        this.root = child;
    } else {
        if (node.getParent().getLeft() == node) {
            node.getParent().setLeft(child);
        } else {
            node.getParent().setRight(child);
        }
    }

    node.setRight(child.getLeft());
    if (child.getLeft() != null) {
        child.getLeft().setParent(node);
    }

    child.setLeft(node);
    node.setParent(child);
}
右旋操作
private void rightRotate(RBNode<T> node){
    RBNode<T> child = node.getLeft();
    child.setParent(node.getParent());
    if(node.getParent() == null)
        this.root = child;
    else if(node.getParent().getLeft() == node)
        node.getParent().setLeft(child);
    else
        node.getParent().setRight(child);
    node.setParent(child);
    node.setLeft(child.getRight());
    if(child.getRight() != null)
        child.getRight().setParent(node);
    child.setRight(node);
}

红黑树的查找操作和AVL树的查找操作相同，所以参考AVL树的查找代码即可
主要介绍插入和删除

三、红黑树的插入

红黑树插入时，插入节点是应该是红色。因为如果插入节点是黑色，那么插入位置所在的子树黑色节点总是多1。
红黑树的插入主要有以下三种情况：

1.红黑树为空树

当是空树时，直接把插入节点作为根节点，并且它设为黑色。因为红黑树规定根节点root必须是黑色。

2.插入节点的父节点是黑色

由于插入的节点是红色的，当插入节点的父节点是黑色时，不会影响红黑树的平衡，直接插入 即可。
在这里插入图片描述
同AVL树一样，查找合适的地方直接插入
在这里插入图片描述

3.插入节点的父节点是红色

这种情况又分为下面三种情况：

  • 叔叔节点是红色：
    把当前插入节点的父节点和叔叔节点都设置成黑色，把祖父节点设置成红色，然后从祖父节点开始继续向上回溯

在这里插入图片描述

  • 叔叔节点为空或者是黑色，且当前节点、父节点、祖父节点在一条线上：
    先把父节点设置成黑色，祖父节点都设置成红色，相当于把父节点和祖父节点的颜色进行交换，再进行一次旋转操作
    在这里插入图片描述
  • 叔叔节点为空或者是黑色，且当前节点、父节点、祖父节点不在一条线上：
    先进行一次旋转操作，将当前节点、父节点、祖父节点调整到同一侧，变成上述情况，再进行上述操作
    在这里插入图片描述
/**
 * 红黑树插入
 * @param val
 */
public void insert(T val){
    if(root == null){ //空树
        //直接插入到根节点，且置为黑色
        root = new RBNode<>(val, null,null,null,Color.BLACK);
        return;
    }

    RBNode<T> parent = null;
    RBNode<T> cur = root;
    //查找合适的插入位置
    while(cur != null){
        if(cur.getData().compareTo(val) > 0){
            parent = cur;
            cur = cur.getLeft();
        } else if(cur.getData().compareTo(val) < 0){
            parent = cur;
            cur = cur.getRight();
        } else {
            return;
        }
    }
    //待插入的节点
    RBNode<T> node = new RBNode<T>(val, null, null,parent,Color.RED);
    //直接插入
    if(parent.getData().compareTo(node.getData()) > 0){
        parent.setLeft(node);
    } else{
        parent.setRight(node);
    }

    // 如果新插入节点的父节点是红色，则进行红黑树的插入调整
    if(color(parent) == Color.RED){
        fixAfterInsert(node);
    }
}

/**
 * 红黑树的插入调整操作
 * @param node
 */
private void fixAfterInsert(RBNode<T> node) {
    //node节点的父节点是红色，出现连续的红色节点，需要调整颜色
    while(color(parent(node)) == Color.RED){
        //插入节点再祖父节点的左子树上
        if(left(parent(parent(node))) == parent(node)){
            //叔叔节点
            RBNode<T> uncle = right(parent(parent(node)));
            //叔叔节点是红色
            if(color(uncle) == Color.RED){ // 插入情况3.1
                setColor(parent(node), Color.BLACK); //父亲节点置为黑色
                setColor(uncle, Color.BLACK); //叔叔节点置为黑色
                setColor(parent(parent(node)), Color.RED); //祖父节点置为红色
                node = parent(parent(node)); //node指向祖父节点，继续向上回溯调整
            } else {
                //叔叔节点为黑色，且祖父、父亲、插入节点不在一条线上
                if(node == right(parent(node))){ // 插入情况3.3前半段
                    node = parent(node);
                    leftRotate(node); //左旋
                }
                // 插入情况3.3后半段和情况3.2合并
                //祖父、父亲、当前节点在一条直线上，直接做右旋转操作
                setColor(parent(node), Color.BLACK); //将父节点置成黑色，旋转以后就成为根节点了
                setColor(parent(parent(node)), Color.RED);//祖父节点置成红色
                //以祖父节点为根节点做右旋操作
                rightRotate(parent(parent(node)));
                break; //调整完成，跳出循环
            }
        } else {
            // 插入节点在祖父节点的右子树上，和上面的所有情况相反
            RBNode<T> uncle = left(parent(parent(node)));
            if(color(uncle) == Color.RED){ // 插入情况3.1
                setColor(parent(node), Color.BLACK);
                setColor(uncle, Color.BLACK);
                setColor(parent(parent(node)), Color.RED);
                node = parent(parent(node));
            } else {
                if(node == left(parent(node))){ // 插入情况3.3前半段
                    node = parent(node);
                    rightRotate(node);
                }

                setColor(parent(node), Color.BLACK); // 插入情况3.33后半段和情况3.22合并
                setColor(parent(parent(node)), Color.RED);
                leftRotate(parent(parent(node)));
                break;
            }
        }
    }
    // 有可能向上回溯时把根节点置成红色，直接把根节点设置成黑色
    setColor(this.root, Color.BLACK);
}

四、红黑树的删除

红黑树的删除操作和插入操作一样，都需要在不同的情况下进行相应的调整，并且删除操作还稍微要复杂一点

如果删除的是红色节点 ，直接删除就可以，因为黑色节点的数量不会变化

但是如果删除的是黑色节点 ，删除完节点就需要进行调整，因为破坏了红黑树的性质，某一个分支路径上的黑色节点少了一个。
这种情况主要分为四种小的情况：

情况1

兄弟节点是红色

兄弟节点是红色的，所以删除一个黑色节点后无法借调一个黑色节点过来，但是兄弟节点的孩子肯定都是黑色的，所以以该节点的父节点为根节点进行一次旋转操作，把黑色的兄弟节点提上来，就可以借调黑色节点了。
在这里插入图片描述

情况2

兄弟节点是黑色的，而且兄弟节点的两个孩子也都是黑色的
直接把兄弟节点设置成红色，然后从父节点开始继续回溯调整。
在这里插入图片描述

情况3

兄弟是黑色，和父亲，兄弟在同一侧的兄弟的孩子为红色

将兄弟节点颜色置为父亲节点的颜色，再将父亲节点颜色涂成黑色，将兄弟节点的红色孩子涂成黑色，再以父节点为根节点进行旋转
ps：当前节点在为左孩子，左旋，右孩子，右旋
在这里插入图片描述

情况4

兄弟是黑色，和父亲，兄弟不在同一侧的兄弟的孩子为红色
将兄弟节点的颜色和其红色孩子颜色交换，再将兄弟节点作为根节点进行旋转，就变成了情况3。
ps：兄弟为左子树，左旋，右子树，右旋
在这里插入图片描述

    /**
     * 红黑树的删除
     */
    public void remove(T data){
        if(this.root == null)  //空树
            return;

        RBNode<T> cur = this.root;
        //搜索要删除的节点
        while(cur != null){
            if(cur.getData().compareTo(data) > 0){
                cur = cur.getLeft();
            } else if(cur.getData().compareTo(data) < 0){
                cur = cur.getRight();
            } else {
                break;
            }
        }

        if(cur == null){
            return;
        }
        //待删除的节点有两格孩子 转换成有一个孩子的节点，或者叶子节点的删除
        if(cur.getLeft() != null && cur.getRight() != null){
            //用前驱节点代替
            RBNode<T> old = cur;
            cur = cur.getLeft();
            while(cur.getRight() != null){
                cur = cur.getRight();
            }
            old.setData(cur.getData());
        }

        // 删除cur指向的节点
        RBNode<T> child = cur.getLeft();
        if(child == null){
            child = cur.getRight();
        }

        if(child != null){
            child.setParent(cur.getParent());
            if(cur.getParent() == null){
                this.root = child;
            } else {
                if(cur.getParent().getLeft() == cur){
                    cur.getParent().setLeft(child);
                } else {
                    cur.getParent().setRight(child);
                }
            }
            //如果删除的是黑色节点，需要进行调整
            if(color(cur) == Color.BLACK){
                fixAfterRemove(child);
            }
        } else {
            if(cur.getParent() == null){
                this.root = null;
            } else {
                if(color(cur) == Color.BLACK){
                    fixAfterRemove(cur);
                }

                if(cur.getParent().getLeft() == cur){
                    cur.getParent().setLeft(null);
                } else {
                    cur.getParent().setRight(null);
                }
            }
        }
    }

    /**
     * 删除时对红黑树的调整
     * @param node
     */
    private void fixAfterRemove(RBNode<T> node) {
        //回溯过程中遇到根节点或者红色节结束循环
        while(node != this.root && color(node) == Color.BLACK){
            if(node == left(parent(node))){
                RBNode<T> brother = right(parent(node));
                //兄弟节点是红色，无法借一个黑色节点，需要左旋，把黑色节点的子节点往上提
                if(color(brother) == Color.RED){
                    setColor(brother, Color.BLACK);
                    setColor(parent(node), Color.RED);
                    leftRotate(parent(node));
                    brother = right(parent(node));
                }
                // 兄弟节点是黑色，而且兄弟节点的两个孩子也是黑色节点，把兄弟节点改成红色，继续回溯父节点
                if(color(left(brother)) == Color.BLACK
                        && color(right(brother)) == Color.BLACK){
                    setColor(brother, Color.RED);
                    node = parent(node);
                } else {
                    // 兄弟节点是黑色，但是右孩子没有红色节点（借给左子树后，右子树设法给自己添加一个黑色节点保证黑色节点数量不变）
                    if(color(right(brother)) != Color.RED){
                        setColor(brother, Color.RED);
                        setColor(left(brother), Color.BLACK);
                        rightRotate(brother);
                        brother = right(parent(node));
                    }

                    // 兄弟节点是黑色，而且右孩子是红色，直接左旋，并把右孩子直接调成黑色
                    setColor(brother, color(parent(node)));
                    setColor(parent(node), Color.BLACK);
                    setColor(right(brother), Color.BLACK);
                    leftRotate(parent(node));
                    break;
                }
            } else {
                // 兄弟节点是红色，无法借一个黑色节点，需要右旋转，把兄弟节点的子节点黑色节点往上提
                RBNode<T> brother = left(parent(node));
                if(color(brother) == Color.RED){
                    setColor(brother, Color.BLACK);
                    setColor(parent(node), Color.RED);
                    rightRotate(parent(node));
                    brother = left(parent(node));
                }

                //兄弟节点是黑色，而且兄弟节点的两个孩子也是黑色节点
                if(color(left(brother)) == Color.BLACK
                        && color(right(brother)) == Color.BLACK){
                    setColor(brother, Color.RED);
                    node = parent(node);
                } else {
                    // 兄弟节点是黑色，但是左孩子没有红色节点
                    if(color(left(brother)) != Color.RED){
                        setColor(brother, Color.RED);
                        setColor(right(brother), Color.BLACK);
                        leftRotate(brother);
                        brother = left(parent(node));
                    }

                    // 兄弟节点是黑色，而且左孩子是红色，直接左旋，并把右孩子直接调成黑色
                    setColor(brother, color(parent(node)));
                    setColor(parent(node), Color.BLACK);
                    setColor(left(brother), Color.BLACK);
                    rightRotate(parent(node));
                    break;
                }
            }
        }
        /**
         * 删除黑色节点后，其孩子节点是红色，直接调成黑色，结束上面循环，保持黑色节点数量不变；
         * 删除黑色节点后，其孩子节点是黑色，但是向上回溯的时候，遇到红色节点，直接改成黑色节点，结束上面循环，保持黑色节点数量不变
         */
        // 在当前这一路遇见红色节点，直接补一个黑色节点
        setColor(node, Color.BLACK);
    }
sspudding
关注
专栏目录
红黑树详解
09-02
红黑树详解（带目录源码） 本文适合那些有对二叉树有一定的基础，并且熟悉C语言的读者。本文最主要的参考资料是《Introduction to Algorithms 3rd Edition》。
C/C++数据结构之深入理解红黑树原理和实现过程
Lion_Long的博客
09-12 602
红黑树具有一下性质： （1）每个结点不是红的就是黑的； （2）根结点是黑的； （3）每个叶子结点是黑的； （4）如果一个结点是红的，则它的两个儿子是黑的； （5）对每个节点，从该结点到其子孙结点的所有路径上，都包含相同数目的黑结点；即黑高。这决定红黑树的平衡。
红黑树入门篇
rootDream的博客
02-22 590
红黑树 前言： JDK1.7时，HashMap组成：数组+链表。到1.8后，推出了红黑树。 当链表长度超过阈值8，则会将链表转化为红黑树，当小于6时，就会将红黑树转化为链表。 由于二叉查找树的性能极低，所以红黑树自然而然就占据主要地位。 时间复杂度也就是树的深度。 链表(也称暴力O(n))->二叉树->二叉查找树(O(logn)~O(n))->特殊的二叉查找树(红黑树O(...
红黑树（Red-Black Tree）
最新发布
xy2006860的专栏
08-22 525
红黑树（Red-Black Tree）是一种自平衡的二叉查找树（Binary Search Tree, BST），它通过在每个节点上附加一个存储位表示颜色（红色或黑色）来确保树的平衡。红黑树能够在 O(log n) 时间内执行插入、删除和查找操作，这里的 n 是树中节点的数量。
HashMap中红黑树退化成链表的条件（源码分析）
热门推荐
qq_45369827的博客
03-17 1万+
条件 扩容 resize( ) 时，红黑树拆分成的 树的结点数小于等于临界值6个，则退化成链表。 移除元素 remove( ) 时，在removeTreeNode( ) 方法会检查红黑树是否满足退化条件，与结点数无关。 扩容 resize( ) 的源码分析 扩容时如果是红黑树结构会执行红黑树的 split( ) 方法 split 方法中会初始化生成 loHead 和 hiHead 两个红黑树的头结点（之后会用 low 和 high 表示） lc 和 hc 分别为 low 和 high 的元素个数，初
hashMap 红黑树
weixin_45556228的博客
05-14 1509
红黑树的形成(以下两个条件同时满足): 1.(容量)数组长度大于64 && 2.链表元素大于8 红黑树退化成链表:(有两种情况下会退化为链表的形式) 1.数组扩容且链表中的元素小于等于6,退化为链表 || 2.删除(remove)树节点, 当 ①root ; ②root.left; ③root.right; ④root.left.left 有一个为null时候,退化为链表 ConcurrentHashMap 1.7: 1.初始化时候开辟空间 2.Segment+数组+链表 3.
红黑树代码
03-30
红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树...
红黑树527378231
06-06
红黑树527378231
红黑树527378236
06-06
红黑树527378236
红黑树java操作代码 红黑树是java里面遍历性能最好数据结构
10-17
红黑树（Red-Black Tree）是一种自平衡二叉查找树，它在计算机科学中扮演着重要的角色，尤其是在实现高效的数据结构和算法时。在Java中，虽然标准库并未直接提供红黑树的类，但我们可以自定义实现，如提供的`Red...
红黑树demo python代码
07-12
红黑树是一种自平衡二叉查找树，由Rudolf Bayer在1972年提出。它的设计目标是在保持二叉查找树基本性质的同时，通过引入颜色属性来保证树的平衡，从而达到高效的插入、删除和查找操作。在这个“红黑树demo python...
红黑树源码
10-12
红黑树（Red-Black Tree）是一种自平衡的二叉查找树，由计算机科学家Rudolf Bayer在1972年提出。它在保持二叉查找树特性的同时，通过引入颜色属性来确保树的平衡，从而提高了数据操作的效率。在C++中，红黑树常用于...
红黑树Java实现
06-25
红黑树（Red-Black Tree）是一种自平衡二叉查找树，它在计算机科学中扮演着重要的角色，尤其是在数据结构和算法领域。红黑树的名字来源于它的节点颜色属性：红色或黑色。这种颜色属性用于确保树的平衡，使得在树中的...
解析红黑树（ppt文档）.ppt
03-01
解析红黑树（ppt文档） 红黑树是一种自平衡二叉查找树，它的每个节点都包含一个键值和对应的值。红黑树的主要特点是它可以自动维持平衡，从而保证查找、插入、删除操作的时间复杂度为 O(log n)。 红黑树的五个性质...
HashMap原理
.鞭指云端.的技术博客
09-13 3136
HashMap原理
红黑树详解（C/C++实现）
blll0的博客
03-12 855
本文对红黑树进行详细的介绍，分析了红黑树的删除插入操作以及详细的代码实现，最后介绍了红黑树与AVL树的区别
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值