红黑树的Java实现

最新推荐文章于 2024-05-18 16:42:38 发布
最新推荐文章于 2024-05-18 16:42:38 发布
阅读量566 收藏 10
点赞数 20
分类专栏： 数据结构与算法 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45278293/article/details/137028385
版权

红黑树的Java实现

文章目录

一、概述

  • 红黑树也是一种二叉平衡搜索树，向比与AVL树，是一种弱平衡树。因为AVL树是通过平衡因子，左右树的高度相差不能大于1来保证平衡，而红黑树的左右字数的高度差并不固定，可以大于1，也没有平衡因子的概念。它是通过维护五条性质来保证红黑树是平衡的。
  • 红黑树五条性质：
    1. 节点是 RED 或者 BLACK。
    2. 根节点是 BLACK。
    3. 叶子结点（外部节点，空节点）都是 BLACK。
    4. RED 节点的子节点都是 BLACK。可类比出两条性质
      • RED 节点的 parent 都是 BLACK。
      • 从根节点到叶子结点的所有路径上不能有2个连续的 RED 节点。
    5. 从任一节点到**叶子结点**的所有路径都包含相同数目的 BLACK 节点。
  • 注意性质三：红黑树的叶子结点和其他树的叶子节点不一样。红黑树的叶子结点是假象的节点。且都是 BLACK。
    • 红黑树会让原来那些度为0（例如17、33…）、度为1（例如46、74…）的节点都变成度为2的节点。那么怎么变呢？很简单，给它新增null的子节点即可。红黑树所说的叶子节点是指那些null节点，我们也可以将这些null节点称为外部节点，并且这些null节点（外部节点）是我们为了理解（满足）红黑树的一些性质而假想出来的，我们平时写代码的时候不用将这些节点加进去。给红黑树的每个度为0和度为1的节点加上null的子节点后，这颗红黑树就成为了一颗真二叉树（真二叉树：度要么为0要么为2）。观察上图不难得知：红黑树中度为0的节点都是那些假想出来的null节点，原来的那些不为空的那些节点的度都为2。

在这里插入图片描述

二、添加元素

  • 红黑树的添加只会将元素 添加到叶子节点中，且只有这十二种情况。同时可分三类讨论。

  • 新添加的元素默认为红色，这样可以让红黑树尽快的满足（1，2，3，5都满足，性质4不一定）。
    在这里插入图片描述

    1. 如果新添加节点的父节点为黑色，直接添加，无需做任何处理。
      在这里插入图片描述

    2. 如果添加节点的父节点为红色，且 uncle 为 黑色。（空节点也认为是黑色，如76的右子节点为黑色）则需要旋转来调整平衡，和 BBST 旋转一样的。
      在这里插入图片描述

      • 56 和 60 的情况旋转一次即可。
        在这里插入图片描述

      • 48、74则需要旋转两次。 48 先右旋转再46左旋转。72先左旋转再76右旋转。（旋转的时候注意是将高位的旋转之至低位，低位的旋转至低位，并且是以高位的的为旋转点）
        在这里插入图片描述

    3. 如果添加节点的父节点为红色，且 uncle 为 红色。则需要通过上溢来恢复平衡。注： 这里的上溢是我们类比红黑树为一个4阶B树，通过假想所有的红色节点和父节点进行合并形成 “4解B树的一个节点”，B树的上溢是将关键字拆分合并到父节点的关键字中，是 真实的上溢，而由于红黑树的红色节点和父类节点合并是假象的，所以只需要通过染色来达到上溢的效果即可。

      在这里插入图片描述

  • 都是通过将 grand 节点染成红色，达到让 grand 完成上溢的效果，同时需要将parent 和 uncle 节点染成褐色节点即可。由于上溢的gand 节点可能会导致新的不平衡，没关系，将grand 当成新添加的节点到 grand.parend，递归调用分析grand这次 ‘添加’是哪种情况即可。

  • 下面是添加元素代码，我也标注了各个代码出所代表的是上面哪种情况。

    public void add(V v){
        //创建新节点且为红色
        RBTreeNode<V> newNode = new RBTreeNode<>(v);
        //如果是第一次插入
        if (root == null){
            root = new RBTreeNode<>(v);;
            //根节点必须染为黑色
            root.black();
            return;
        }
        //不是第一次插入：
        addNode(newNode);
    }

public void addNode(RBTreeNode<V> newNode) {
        //查找应该插入到哪个叶子节点下面
        RBTreeNode<V> parentNode = findParentNode(root, newNode.value);
        int comp = compare(parentNode.value,newNode.value);
        //插入新节点
        newNode.parent = parentNode;
        if (comp > 0){
            parentNode.left = newNode;
        }else {
            parentNode.right = newNode;
        }
        if (isRed(parentNode)){
            //1.如果父节点为黑色，则直接插入
            return;
        }
        //2.如果父节点是 RED，且 uncle 节点是 BLACK
        RBTreeNode<V> grand = parentNode.parent;
        if (grand != null){
            if (!parentNode.uncle()){
                if (parentNode.isRight()){// right
                    if(comp > 0){ // Left
                        // 右旋
                        rightRotate(parentNode);
                        // 左旋
                        leftRotate(grand);
                    }else { // right
                        // 左旋
                        leftRotate(parentNode);
                    }
                }else { // Left
                    if(comp > 0){// left
                        // 右旋
                        rightRotate(parentNode);
                    }else { // right
                        // 左旋
                        leftRotate(parentNode);
                        // 右旋
                        rightRotate(grand);
                    }
                }
                return;
            }
            //3.如果父节点是 RED，且 uncle 节点是 RED
            //上溢
            upOverFlow(newNode);
        }
    }

三、删除元素

  • 红黑树删除节点很复杂，分为很多中情况，这里做个总结与归纳。

    1. 如果删除的是 叶子节点且为红色节点，直接删除即可，无需左任何处理。
      在这里插入图片描述
    2. 如果被删除的节点是黑色节点且该黑色节点拥有红色的子节点（无所谓度为1或2），则用红色的字节代替黑色节点，然后直接删除红色节点。注：这里可直接用子节点覆盖需要被删除节点值并删用来覆盖的子节点，也可通过改变指针指向来删除。

    在这里插入图片描述
    3. 如果删除的是节点为黑色且兄弟节点也为黑色。需要分情况讨论：这种情况可以类比B树（4阶B树）和 AVL树。

    • 如果兄弟节点是黑色且有至少一个红色子节点。则进行旋转操作，之后将新的父节颜色继承原先的父节点颜色,并且将旋转后的左右节点染为黑色。比如我们删除 88。
      在这里插入图片描述

    • 如果兄弟节点是黑色且其没有一个红色子节点且父节点是红色。 则将父节点（80）进行下溢，并且将兄弟节点（76）染成红色，父节点（80）染成黑色。
      在这里插入图片描述

    • 如果兄弟节点是黑色且没有一个红色子节点且父节点是黑色。同样进行下溢，但是要将父节点（80）作为新的被删除节点进行递归调用，继续判断如何调整即可。
      在这里插入图片描述

  1. 如果 被删除节点为黑色且兄弟节点为红色，可先将兄弟节点染为黑色（55），再将parent节点染为红色。在进行左旋转，之后就可套用上面说的，被删除节点为褐色且兄弟节点为黑色且父节点为红色的情况。
    在这里插入图片描述

  • 至此删除的所有情况都列举完了，下面就是代码环节了，我也标注了各个代码出所体现上面所列举的情况。

        /**
     * 删除 value = v 的节点
     *
     * @param v
     * @return
     */
    public V remove(V v){
        RBTreeNode<V> node = findNode(v);
        //没有value = v 的节点
        if (node == null) return null;
        V old = node.value;
        //删除node节点
        deleteNode(node);
        return old;
    }

    /**
     * 删除node节点
     *
     * @param node
     */
    public void deleteNode(RBTreeNode<V> node){
        //情况1：如果node节点的度为2
        if (node.left != null && node.right != null){
            //node 的后继节点
            RBTreeNode<V> successor = successor(node);
            node.value = successor.value;
            //装换成删除前驱节点（叶子节点）
            node = successor;
        }
        //被删除的节点的子节点（到这里一定度为1 或 0）
        RBTreeNode<V> replacement = node.isLeft() ? node.left : node.right;
        //情况1：如果度为1
        if (replacement != null){
            //则直接使用子节点替换当前节点即可
            replacement.parent = node.parent;
            if (node.parent == null){
                root = replacement;
            }else if (node.isLeft()){
                node.parent.left = replacement;
            }else {
                node.parent.right = replacement;
            }
            //这个对应情况2，node节点为黑色，且子节点为红色，则使用子节点代替node节点，并染黑即可，染黑在 deleteAfter 里会体现出来
            if (node.color == BLACK){
                deleteAfter(replacement);
            }
        }else {
            //到这里说明node节点没有子节点了
            //当前就一个node节点
            if (node.parent == null){
                root = null;
                return;
            }
            //情况3和4：被删除节点为黑色，调整平衡
            deleteAfter(node);

            //删除node节点,node可能调整了位置，比如3.3情况，会发生上溢，所以还需要判断是否为null
            if (node.parent != null){
                if (node.isLeft()){
                    node.parent.left = null;
                }else {
                    node.parent.right = null;
                }
                node.parent = null;
            }
        }
    }

    /**
     * 删除node节点后调整红黑树至平衡
     *
     * @param node
     */
    public void deleteAfter(RBTreeNode<V> node){
        //情况2 ： 也应前面传replacement 的情况，直接染黑返回
        if (isRed(node)){
            node.black();
            return;
        }
        RBTreeNode<V> parent = node.parent;
        //删除的是根节点
        if (parent == null) return;
        //到这里说明node节点是黑色了，继续讨论
        //获取兄弟节点
        RBTreeNode<V> sibling = node.isLeft() ? parent.right : parent.left;
        if (node.isRight()){
            //情况4：被删除节点为黑色，且兄弟节点为红色
            if (isRed(sibling)){
                sibling.black();
                parent.red();
                rightRotate(parent);
                //旋转之后，兄弟节点变化了，进行更新.之后套用 情况3.2
                sibling = parent.left;
            }
            //到这里 sibling 必为黑色了
            //情况3.2 和 情况 3.3：被删除节点为黑色，且兄弟节点为黑色，且兄弟节点没有一个红色子节点
            if (isBlack(sibling.left) && isBlack(sibling.right)){
                //情况3.1：父节点为黑色 （这里的下溢就是染色，并不是B树真正意义的下溢）
                parent.black();
                sibling.red();
                //情况3.2：父节点为红色
                if (isBlack(parent)){
                    //递归调用
                    deleteAfter(parent);
                }
            }else {
                //情况3.1 : 被删除节点node为黑，兄弟节点为黑，且兄弟节点至少有一个红色子节点，则需要判断旋转方向进行旋转即可
                if (isBlack(sibling.left)){
                    leftRotate(sibling);
                    sibling = parent.left;
                }
                //旋转之后新的父节点要继承原先的父节点
                sibling.color = parent.color;
                sibling.left.black();
                parent.black();
                rightRotate(parent);
            }
        }else {
            //所有旋转反过来
            //情况4：被删除节点为黑色，且兄弟节点为红色
            if (isRed(sibling)){
                sibling.black();
                parent.red();
                leftRotate(parent);
                //旋转之后，兄弟节点变化了，进行更新.之后套用 情况3.2
                sibling = parent.right;
            }

            //到这里 sibling 必为黑色了
            //情况3.2 和 情况 3.3：被删除节点为黑色，且兄弟节点为黑色，且兄弟节点没有一个红色子节点
            if (isBlack(sibling.left) && isBlack(sibling.right)){
                //情况3.1：父节点为黑色 （这里的下溢就是染色，并不是B树真正意义的下溢）
                parent.black();
                sibling.red();
                //情况3.2：父节点为红色
                if (isBlack(parent)){
                    //递归调用
                    deleteAfter(parent);
                }
            }else {
                //情况3.1 : 被删除节点node为黑，兄弟节点为黑，且兄弟节点至少有一个红色子节点，则需要判断旋转方向进行旋转即可
                if (isBlack(sibling.right)){
                    rightRotate(sibling);
                    sibling = parent.right;
                }
                //旋转之后新的父节点要继承原先的父节点
                sibling.color = parent.color;
                sibling.right.black();
                parent.black();
                leftRotate(parent);
            }
        }
    }

四、完整代码

  • 代码也可看看 TreeMap 源码，TreeMap 就是用红黑树实现的。

    package com.example.demo.tree.rbtree;

import java.util.Comparator;

/**
 * 红黑树的简单实现
 */
public class RBTree<V> {

    //红色
    private static final boolean RED = true;
    //黑色
    private static final boolean BLACK = false;

    //根节点
    private RBTreeNode<V> root;

    //比较器
    private Comparator<V> comparator;

    /**
     * 添加元素，红黑树的节点添加，必是往叶子节点上添加新节点
     * 红黑树添加新节点后仍需要满足红黑树的五条性质
     *  1.节点是 RED 或者 BLACK
     *  2.根节点是 BLACK
     *  3.叶子节点（外部节点，空节点）都是 BLACK
     *  4.RED 节点的子节点都是 BLACK
     *      1.RED 节点的 parent 都是 BLACK
     *      2.从根节点到叶子节点的所有路径都包含相同数目的 BLACK 节点
     *  5.从任一的节点到到叶子节点的所有路径都包含相同数目的 BLACK 节点。
     * 我们每次添加节点，都使新添加的节点为 RED，则可直接满足1,2,3,5，只有 4.1不满足，更方便调整，
     * 所以我们都将新添加的元素默认为 RED
     *
     * @param v
     * @return
     */
    public void add(V v){
        //创建新节点且为红色
        RBTreeNode<V> newNode = new RBTreeNode<>(v);
        //如果是第一次插入
        if (root == null){
            root = new RBTreeNode<>(v);;
            //根节点必须染为黑色
            root.black();
            return;
        }
        //不是第一次插入：
        addNode(newNode);
    }

    public void addNode(RBTreeNode<V> newNode) {
        //查找应该插入到哪个叶子节点下面
        RBTreeNode<V> parentNode = findParentNode(root, newNode.value);
        int comp = compare(parentNode.value,newNode.value);
        //插入新节点
        newNode.parent = parentNode;
        if (comp > 0){
            parentNode.left = newNode;
        }else {
            parentNode.right = newNode;
        }
        if (!parentNode.color){
            //1.如果父节点为黑色，则直接插入
            return;
        }
        //2.如果父节点是 RED，且 uncle 节点是 BLACK
        RBTreeNode<V> grand = parentNode.parent;
        if (grand != null){
            if (!parentNode.uncle()){
                if (parentNode.isRight()){// right
                    if(comp > 0){ // Left
                        // 右旋
                        rightRotate(parentNode);
                        // 左旋
                        leftRotate(grand);
                    }else { // right
                        // 左旋
                        leftRotate(parentNode);
                    }
                }else { // Left
                    if(comp > 0){// left
                        // 右旋
                        rightRotate(parentNode);
                    }else { // right
                        // 左旋
                        leftRotate(parentNode);
                        // 右旋
                        rightRotate(grand);
                    }
                }
                return;
            }
            //3.如果父节点是 RED，且 uncle 节点是 RED
            //上溢
            upOverFlow(newNode);
        }
    }


    /**
     * 删除 value = v 的节点
     *
     * @param v
     * @return
     */
    public V remove(V v){
        RBTreeNode<V> node = findNode(v);
        //没有value = v 的节点
        if (node == null) return null;
        V old = node.value;
        //删除node节点
        deleteNode(node);
        return old;
    }

    /**
     * 返回 node 的后继节点
     *
     * @param node
     * @return
     */
    public RBTreeNode<V> successor(RBTreeNode<V> node){
        RBTreeNode<V> child = node.right;
        if (child == null) return null;
        while (child.left != null){
            child = child.left;
        }
        return child;
    }

    /**
     * 删除node节点
     *
     * @param node
     */
    public void deleteNode(RBTreeNode<V> node){
        //情况1：如果node节点的度为2
        if (node.left != null && node.right != null){
            RBTreeNode<V> successor = successor(node);
            node.value = successor.value;
            //装换成删除前驱节点（叶子节点）
            node = successor;
        }
        //被删除的节点的子节点（到这里一定度为1 或 0）
        RBTreeNode<V> replacement = node.isLeft() ? node.left : node.right;
        //情况1：如果度为1
        if (replacement != null){
            //则直接使用子节点替换当前节点即可
            replacement.parent = node.parent;
            if (node.parent == null){
                root = replacement;
            }else if (node.isLeft()){
                node.parent.left = replacement;
            }else {
                node.parent.right = replacement;
            }
            //这个对应情况2，node节点为黑色，且子节点为红色，则使用子节点代替node节点，并染黑即可，染黑在 deleteAfter 里会体现出来
            if (node.color == BLACK){
                deleteAfter(replacement);
            }
        }else {
            //到这里说明node节点没有子节点了
            //当前就一个node节点
            if (node.parent == null){
                root = null;
                return;
            }
            //情况3和4：被删除节点为黑色，调整平衡
            deleteAfter(node);

            //删除node节点,node可能调整了位置，比如3.3情况，会发生上溢，所以还需要判断是否为null
            if (node.parent != null){
                if (node.isLeft()){
                    node.parent.left = null;
                }else {
                    node.parent.right = null;
                }
                node.parent = null;
            }
        }
    }

    /**
     * 删除node节点后调整红黑树至平衡
     *
     * @param node
     */
    public void deleteAfter(RBTreeNode<V> node){
        //情况2 ： 也应前面传replacement 的情况，直接染黑返回
        if (isRed(node)){
            node.black();
            return;
        }
        RBTreeNode<V> parent = node.parent;
        //删除的是根节点
        if (parent == null) return;
        //到这里说明node节点是黑色了，继续讨论
        //获取兄弟节点
        RBTreeNode<V> sibling = node.isLeft() ? parent.right : parent.left;
        if (node.isRight()){
            //情况4：被删除节点为黑色，且兄弟节点为红色
            if (isRed(sibling)){
                sibling.black();
                parent.red();
                rightRotate(parent);
                //旋转之后，兄弟节点变化了，进行更新.之后套用 情况3.2
                sibling = parent.left;
            }
            //到这里 sibling 必为黑色了
            //情况3.2 和 情况 3.3：被删除节点为黑色，且兄弟节点为黑色，且兄弟节点没有一个红色子节点
            if (isBlack(sibling.left) && isBlack(sibling.right)){
                //情况3.1：父节点为黑色 （这里的下溢就是染色，并不是B树真正意义的下溢）
                parent.black();
                sibling.red();
                //情况3.2：父节点为红色
                if (isBlack(parent)){
                    //递归调用
                    deleteAfter(parent);
                }
            }else {
                //情况3.1 : 被删除节点node为黑，兄弟节点为黑，且兄弟节点至少有一个红色子节点，则需要判断旋转方向进行旋转即可
                if (isBlack(sibling.left)){
                    leftRotate(sibling);
                    sibling = parent.left;
                }
                //旋转之后新的父节点要继承原先的父节点
                sibling.color = parent.color;
                sibling.left.black();
                parent.black();
                rightRotate(parent);
            }
        }else {
            //所有旋转反过来
            //情况4：被删除节点为黑色，且兄弟节点为红色
            if (isRed(sibling)){
                sibling.black();
                parent.red();
                leftRotate(parent);
                //旋转之后，兄弟节点变化了，进行更新.之后套用 情况3.2
                sibling = parent.right;
            }

            //到这里 sibling 必为黑色了
            //情况3.2 和 情况 3.3：被删除节点为黑色，且兄弟节点为黑色，且兄弟节点没有一个红色子节点
            if (isBlack(sibling.left) && isBlack(sibling.right)){
                //情况3.1：父节点为黑色 （这里的下溢就是染色，并不是B树真正意义的下溢）
                parent.black();
                sibling.red();
                //情况3.2：父节点为红色
                if (isBlack(parent)){
                    //递归调用
                    deleteAfter(parent);
                }
            }else {
                //情况3.1 : 被删除节点node为黑，兄弟节点为黑，且兄弟节点至少有一个红色子节点，则需要判断旋转方向进行旋转即可
                if (isBlack(sibling.right)){
                    rightRotate(sibling);
                    sibling = parent.right;
                }
                //旋转之后新的父节点要继承原先的父节点
                sibling.color = parent.color;
                sibling.right.black();
                parent.black();
                leftRotate(parent);
            }
        }
    }

    /**
     * 左旋 将node 和 子节点进行旋转，达到 node节点位置降低，而子节点位置上升的效果
     *
     * @param node
     */
    public void leftRotate(RBTreeNode<V> node) {
        //父节点
        RBTreeNode<V> parent = node.parent;
        //grand 节点
        RBTreeNode<V> grand = parent.parent;
        //左节点
        RBTreeNode<V> left = node.left;
        //1. 将 grand 节点 的 子节点指向 node 节点
        if (grand == null){
          root = node;
          node.black();
        } else if (parent.isLeft()){
            grand.left = node;
        }else {
            grand.right = node;
        }
        //2. 将 node 的父节点 指向 grand 节点
        node.parent = grand;
        //3. 将 node 节点的左节点指向 parent 节点
        node.left = parent;
        //4. 将 parent 节点的 parent 指向 node 节点
        parent.parent = node;
        //5. 将 parent 节点的 right 指向 node 的left
        parent.right = left;
        //6. 将 node 节点的left 节点的parent 指向 parent 节点
        if (left != null){
            left.parent = parent;
        }
        //7. node 节点染成黑色
        node.black();
        //8. parent 节点染成红色
        if (parent != root){
            parent.red();
        }

    }

    /**
     * 右旋，将node 和 子节点进行旋转，达到 node节点位置降低，而子节点位置上升的效果
     *
     * @param node
     */
    public void rightRotate(RBTreeNode<V> node){
        //父节点
        RBTreeNode<V> parent = node.parent;
        //grand 节点
        RBTreeNode<V> grand = parent.parent;
        //右节点
        RBTreeNode<V> right = node.right;
        //1. 将 grand 节点 的 左子节点指向 node 节点
        if (grand == null) {
            root = node;
            root.black();
        }else if (parent.isLeft()){
            grand.left = node;
        }else {
            grand.right = node;
        }
        //2. 将 node 的父节点 指向 grand 节点
        node.parent = grand;
        //3. 将 node 节点的右节点指向 parent 节点
        node.right = parent;
        //4. 将 parent 节点的 parent 指向 node 节点
        parent.parent = node;
        //5. 将 parent 节点的 left 指向 node 的right
        parent.left = right;
        //6. 将 node 节点的 right 节点的parent 指向 parent 节点
        if (right != null){
            right.parent = parent;
        }
        //7. node 节点染成黑色
        node.black();
        //8. parent 节点染成红色
        if (parent != root){
            parent.red();
        }
    }

    /**
     * 上溢，通过染色达到上溢的效果
     *
     * @param node
     */
    public void upOverFlow(RBTreeNode<V> node){
        if (!node.parent.color || !node.uncle()) return;
        //父节点
        RBTreeNode<V> parent = node.parent;
        //grand 节点
        RBTreeNode<V> grand = parent.parent;
        //uncle 节点
        RBTreeNode<V> uncle = parent.brother();
        //1.将 grand 上溢 染成红色
        grand.red();
        //2.将parent 染成黑色
        parent.black();
        //3.将 parent 的brother 染成黑色
        uncle.black();
        //4. 以 grand 位新插入的节点，继续向上调整
        addNode(grand);
    }

    public RBTreeNode<V> findParentNode(RBTreeNode<V> node,V v){
        if (node.leaf()) return node;
        if (compare(v,node.value) < 0){
            return findParentNode(node.left,v);
        }else {
            return findParentNode(node.right,v);
        }
    }


    /**
     * 判断节点node 是否为黑色，空节点也为黑色
     *
     * @param node
     * @return
     */
    public boolean isBlack(RBTreeNode<V> node){
        return node == null || node.color == BLACK;
    }

    /**
     * 判断节点 node 是否为红色，空节点为黑色
     * @param node
     * @return
     */
    public boolean isRed(RBTreeNode<V> node){
        return node != null && node.color == RED;
    }

    /**
     * 查找值我 v 的节点
     *
     * @param v
     * @return
     */
    public RBTreeNode<V> findNode(V v){
        RBTreeNode<V> node = root;
        while (node != null){
            int comp = compare(node.value,v);
            if (comp < 0){
                node = node.right;
            }else if (comp > 0){
                node = node.left;
            }else {
                return node;
            }
        }
        return null;
    }

    private int compare(V a, V b){
        if (comparator == null){
            return ((Comparable<V>)a).compareTo(b);
        }
        return comparator.compare(a,b);
    }

    /**
     * 红黑树的节点
     *
     * @param <V> 节点存储的值类型
     */
    private static class RBTreeNode<V>{
        //节点存储的值
        private V value;
        //节点颜色
        private boolean color;
        //左子节点
        private RBTreeNode<V> left;
        //右子节点
        private RBTreeNode<V> right;
        //父节点
        private RBTreeNode<V> parent;
        public RBTreeNode(V v){
            this.value = v;
            //新建的节点默认是红色
            this.color = RED;
        }

        public RBTreeNode(V v, boolean color){
            this.value = v;
            this.color = color;
        }

        public boolean colorOf(){
            return color;
        }

        /**
         * 返回节点的颜色
         *
         * @return
         */
        public boolean color(){
            return color;
        }

        /**
         * 将节点染成红色
         *
         * @return
         */
        public void red(){
            this.color = RED;
        }

        /**
         * 将节点染成黑色
         */
        public void black(){
            this.color = BLACK;
        }

        /**
         * 判断是否为叶子节点
         */
        public boolean leaf(){
            return left == null && right == null;
        }

        /**
         * 当前节点是否为左节点
         *
         * @return
         */
        public boolean isLeft(){
            return parent != null && this == parent.left;
        }

        /**
         * 当前节点是否为右节点
         *
         * @return
         */
        public boolean isRight(){
            return parent != null && this == parent.right;
        }

        public RBTreeNode<V> brother(){
            return this == parent.left ? parent.right: parent.left;
        }
        /**
         * 返回叔父节点的颜色，如果我空，则是黑色
         *
         * @return
         */
        public boolean uncle(){
            if (isLeft()){
                return parent.right == null ? BLACK: parent.right.color;
            }else {
                return parent.left == null ? BLACK: parent.left.color;
            }
        }

        @Override
        public String toString() {
            String str = "";
            if (color == RED){
                str = "R_";
            }
            return str;
        }
    }
}

总结

  • 红黑树 于 AVL 树对比
    在这里插入图片描述

  • 理论看再多不如自己动手实现一遍，才能体会到很多没注意到的细节。

参考资料：
小破站的小码哥红黑树讲解

mobº
关注
  • 20
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树java实现
偏离的定弦
05-01 4224
红黑树（英语：Red–black tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。它是在1972年由鲁道夫·贝尔发明的，他称之为”对称二叉B树”，它现代的名字是在Leo J. Guibas和Robert Sedgewick于1978年写的一篇论文中获得的。它是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的：它可以在O(log n)时
红黑树以及JAVA实现
JHIII的博客
08-26 1432
红黑树是一种特殊的B树是B树种2-3-4树的一种特殊实现，红黑树保证了每个节点只会有两个子节点，通过对每个节点进行染色，然后通过不同颜色的节点组合来分别代表2-3-4的2节点、3节点、4节点树的情况。在学习红黑树之前，我们需要先去了解2-3-4树。红黑树，本质上其实就是将一个B树（我们这里讨论2-3-4树）转化为一个二叉树。那么如何去转化的同时又能继承B树绝对平衡性呢？答案就是通过染色和旋转，到这里打住，让我们先来看红黑树的定义所有的节点不是黑色就是红色根节点是黑色的所有叶子节点是黑色的。...
红黑树-Java实现
weixin_37607613的博客
04-05 8994
一、定义 红黑树是特殊的平衡二叉树，具有以下特性： 1、根节点的颜色是黑色 2、节点颜色要么是黑色、要么是红色 3、如果一个节点的颜色是红色，则它的子节点必须是黑色，即不能有2个连续的红色节点 4、每个叶子节点都是黑色(这里的叶子节点是为空的叶子节点) 5、从一个节点到该节点的叶子节点的所有路径上都包含相同数量的黑色节点 通过上面的定义，可以看到红黑树本质上还是一颗二叉查找树，所以，对红黑树的插入删除操作都可以分为两阶段来完成，首先，将红黑树看成一颗普通的二叉查找树完成插入删除操....
java实现红黑树
weixin_42609225的博客
12-30 205
红黑树是一种平衡二叉搜索树，它的每个节点都有一个颜色属性，可以是红色或黑色。为了保证红黑树的平衡，它有以下五条性质： 每个节点要么是红色，要么是黑色。 根节点是黑色。 叶子节点(最后一层的节点)是黑色。 如果一个节点是红色，则它的两个儿子都是黑色。 对于每个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点。 下面是一个 Java 实现红黑树的例子： ```java pub...
红黑树Java实现
Burg
11-06 2393
作者：美团点评技术团队 链接：https://zhuanlan.zhihu.com/p/24367771 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 红黑树是平衡二叉查找树的一种。为了深入理解红黑树，我们需要从二叉查找树开始讲起。 BST 二叉查找树（Binary Search Tree，简称BST）是一棵二叉树，它的左子节点的值比父节点的值要小，右节点的值...
java红黑树代码实现
weixin_35749796的博客
02-15 169
红黑树是一种自平衡二叉查找树，它在保持二叉查找树基本性质的同时，通过对节点进行染色，保持了树的平衡，从而保证了最坏情况下的时间复杂度为 O(log n)。 下面是一个简单的 Java 实现： ```java public class RedBlackTree<K extends Comparable, V> { private static final boolean RED ...
Java之红黑树
qq_41720578的博客
04-28 4859
1、简介 红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。 红黑树是一种特化的AVL树（平衡二叉树），都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。 它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的： 它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目。 红黑树是一种平衡二叉查找树的变体，它的左右子树高差有可能大于 1，所以红黑树不是
红黑树（Java实现）
weixin_45567738的博客
05-09 1560
RBTree 根节点是黑色 每个叶子节点都是黑色的空结点（NIL结点）（为了简单期间，一般会省略该节点） 如果一个节点是红色的，则它的子节点必须是黑色的（父子不能同为红） 从任一结点到其每个叶子的所有路径都包含相同数目的黑色结点（平衡的关键） 新插入节点默认为红色，插入后需要校验红黑树是否符合规则，不符合则需要进行平衡 节点 package com.richard.brtree; public class BRTreeNode { private int key; private
图解红黑树与Java实现
qq_43240702的博客
02-20 1075
50章图帮你彻底理解红黑树的前世今生与平衡背后的原理
对红黑树的认识总结
热门推荐
张彦峰的博客
05-12 170万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
红黑树实现（java代码）
10-07
红黑树创建，插入，删除操作代码。包括创建，插入操作，删除操作，代码有详细的注释，java代码实现。
java 红黑树实现.rar
04-27
java 实现红黑树的增删改查
通过Java实现红黑树及其可视化
12-09
通过Java实现红黑树及其可视化 对于节点的定义，包含节点的数值、节点的颜色、节点的父节点、节点的左右叶子结点 通过Java实现红黑树，包括红黑树的插入操作、删除操作、维护红黑树性质的操作以及常用的方法函数...
jar包增量更新分析
junlaiyan的专栏
05-16 254
借助jdeps分析出jar包的增量文件
SpringBoot接入Knife4j接口文档
最新发布
博主是个二次元死肥宅~
05-18 673
Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui。
java实现拼图小游戏
monkey108的博客
05-16 617
本文主要提供用java实现的拼图小游戏源代码。
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 903
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
java 实现红黑树
03-01
下面是Java实现红黑树的一般步骤： 1. 定义节点类：首先定义一个表示红黑树节点的类，包含键值、颜色、左子节点、右子节点和父节点等属性。 2. 定义红黑树类：创建一个红黑树类，包含根节点和一些基本操作方法，如...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值