Java——红黑树

已于 2023-01-31 10:27:11 修改
阅读量1.8k 收藏 3
点赞数
分类专栏： 数据结构 java 文章标签： java 算法 数据结构
于 2022-12-14 11:45:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60867520/article/details/128302018
版权

概念

红黑树也是一种二叉搜索树，但是和avl树不同，它并不是依靠平衡因子来保证树的平衡的，而是通过颜色

红黑树每个节点中会存储颜色，分为红色和黑色，通过红黑树的限制条件，可以保证从根节点出发到叶子节点的每一条路径长度都不会是其他路径长度的两倍，以此达到接近平衡，保证了搜索的效率是log2（N）

性质

红黑树需要满足以下几点性质：

  1. 每个节点不是红色的就是黑色的
  2. 根节点必须是黑色的
  3. 如果一个节点是红色的，那么他的孩子节点必须是黑色的
  4. 每一条路径从根节点到叶子节点中的黑色节点的个数必须相同
  5. 所有的叶子节点（这里指的是空节点）都是黑色的

红黑树节点的定义

红黑树中的节点不仅需要定义左右孩子的指针，父节点的指针，自身存储的值，还要存储这个节点的颜色，这里通过枚举来存储
并且需要满足新创建的节点是红色的，因为如果要是创建的是黑色的，那么在插入的过程中很难保证性质四——每一条路径从根节点到叶子节点中的黑色节点的个数必须相同

节点定义代码

static class RBTreeNode {
        public RBTreeNode left;
        public RBTreeNode right;
        public RBTreeNode parent;
        public int val;
        public COLOR color;

        public RBTreeNode(int val){
            this.val = val;
            //新创建的节点默认是红色
            this.color = COLOR.RED;
        }
    }

COLOR枚举

package rbTree;

public enum COLOR {
    RED,BLACK
}

插入

在插入时和AVL树一样，要先按照平衡二叉树来进行遍历插入

先判断根节点是否为空，为空则直接插入
然后定义一个cur和parent，cur先为root，cur一直向下遍历。
如果val小于cur.val，cur就变成cur.left
大于的话就变成cur.right
如果等于，就说明已经有这个节点了，return false
在cur遍历的过程中，使parent始终为cur的上一个节点，使得当cur变成空时，能够记录上一个节点的位置
然后判断val和parent.val的大小关系，插到对应的位置上

RBTreeNode node = new RBTreeNode(val);
if(root == null){
    root = node;
    node.color = COLOR.BLACK;
    return true;
}
RBTreeNode parent = null;
RBTreeNode cur = root;
while(cur != null){
    if (cur.val < val){
        parent = cur;
        cur = cur.right;
    } else if (cur.val > val){
        parent = cur;
        cur = cur.left;
    } else {
        return false;
    }
}
if(parent.val < val){
    parent.right = node;
} else {
    parent.left = node;
}
node.parent = parent;
cur = node;

然后进行颜色的更改
因为默认插入的颜色是红色，因此如果父节点是黑色的话，那么就不违背任何性质，否则的话需要进行颜色的更改，因此循环的条件是parent不为空，parent的颜色是红色
定义parent的父节点grandfather节点
定义grandfather的另一个孩子节点uncle节点

while(parent != null && parent.color == COLOR.RED){
    //根不能是红色，所以一定有父节点
    RBTreeNode grandFather = parent.parent;
    if(parent == grandFather.left){
        RBTreeNode uncle = grandFather.right;

在这里分为以下几种情况：

情况一

cur，parent为红，grandfather为黑，uncle存在且为红
在这里插入图片描述
此时cur和parent两个都是红色，因此不满足性质——如果一个节点是红色的，那么他的孩子节点必须是黑色的

此时如果把cur改成黑色，那么uncle这边就不满足性质—— 每一条路径从根节点到叶子节点中的黑色节点的个数必须相同

所以需要将parent和uncle都改成黑色节点

但是，这里还需要考虑grandfather的兄弟节点也会出现不满足性质—— 每一条路径从根节点到叶子节点中的黑色节点的个数必须相同，因此我们可以把grandfather改成红色的，这样就满足这个性质了

所以，如果grandparent是根节点，那么就不用改颜色了，如果不是根节点的话，我们就需要让grandparent变成红色的
在这里插入图片描述
然后我们可以把grandparent看成cur，继续向上调整

if(uncle != null && uncle.color == COLOR.RED){
    parent.color = COLOR.BLACK;
    uncle.color = COLOR.BLACK;
    grandFather.color = COLOR.RED;

    //向上迭代
    cur = grandFather;
    parent = cur.parent;

情况二

cur和parent为红色，grandfather为黑色，uncle不存在或为黑色
这种情况就相当于情况一的相反情况，因此写在情况一的else中
情况二出现在下图这样，先是情况一进行调整，迭代后出现情况二
在这里插入图片描述

这时我们需要右单旋grandparent，然后将原来的grandparent变成红色，parent变成黑色
在这里插入图片描述
关于右单旋，这个在上一篇博客avl树中讲过，不会的可以去上一篇博客看

//uncle不存在或者是黑色
//情况二
rotateRight(grandFather);
grandFather.color = COLOR.RED;
parent.color = COLOR.BLACK;

右单旋：

private void rotateRight(RBTreeNode parent) {
    RBTreeNode subL = parent.left;
    RBTreeNode subLR = subL.right;

    parent.left = subLR;
    subL.right = parent;
    if(subLR != null) {
        subLR.parent = parent;
    }

    RBTreeNode pParent = parent.parent;

    parent.parent = subL;

    //检查是否parent为根节点
    if(parent == root){
        //使subL为根节点
        root = subL;
        root.parent = null;
    } else {
        //使得parent的原parent节点的孩子为subL
        if (pParent.left == parent) {
            pParent.left = subL;
        } else {
            pParent.right = subL;
        }
        subL.parent = pParent;
    }
}

情况三

cur和parent为红色，grandfather为黑色，uncle不存在或者为黑色
情况三也是由下方迭代上来时，会出现的一种情况，例如下图
在这里插入图片描述
那么，我们需要将parent进行左单旋，这样问题就回到情况二了
在这里插入图片描述
因此，我们只需要左单旋一下parent，然后让cur和parent交换一下位置，然后再用情况二来处理就可以了

//情况三
if(cur == parent.right){
    rotateLeft(parent);
    RBTreeNode tmp = parent;
    parent = cur;
    cur = tmp;
}//情况三变成情况二

//uncle不存在或者是黑色
//情况二
rotateRight(grandFather);
grandFather.color = COLOR.RED;
parent.color = COLOR.BLACK;

左单旋：

private void rotateLeft(RBTreeNode parent) {
    RBTreeNode subR = parent.right;
    RBTreeNode subRl = subR.left;

    parent.right = subRl;
    subR.left = parent;
    if(subRl != null){
        subRl.parent = parent;
    }

    RBTreeNode pParent = parent.parent;

    parent.parent = subR;

    if(root == parent){
        root = subR;
        root.parent = null;
    } else {
        if (pParent.left == parent){
            pParent.left = subR;
        } else {
            pParent.right = subR;
        }
        subR.parent = pParent;
    }
}

情况四，情况五，情况六

这三种情况就是uncle节点再parent的左侧的情况
情况四和情况一的处理是一样的

当cur是parent的right，就是情况五，那么和情况二处理方法类似，只是变成了左单旋grandparent
在这里插入图片描述

当cur是parent的left，就是情况六，那么和情况三处理方法类似，只是变成了右单旋parent
在这里插入图片描述

//parent == grandfather.right
RBTreeNode uncle = grandFather.left;
if(uncle != null && uncle.color == COLOR.RED){
	//情况四
    parent.color = COLOR.BLACK;
    uncle.color = COLOR.BLACK;
    grandFather.color = COLOR.RED;

    //向上迭代
    cur = grandFather;
    parent = cur.parent;
} else {
    //情况六
    if(cur == parent.left){
        rotateRight(parent);
        RBTreeNode tmp = parent;
        parent = cur;
        cur = tmp;
    }//情况五变成情况四

    //uncle不存在或者是黑色
    //情况五
    rotateLeft(grandFather);
    grandFather.color = COLOR.RED;
    parent.color = COLOR.BLACK;
}

插入的全部代码

public boolean insert(int val){
    RBTreeNode node = new RBTreeNode(val);
    if(root == null){
        root = node;
        node.color = COLOR.BLACK;
        return true;
    }
    RBTreeNode parent = null;
    RBTreeNode cur = root;
    while(cur != null){
        if (cur.val < val){
            parent = cur;
            cur = cur.right;
        } else if (cur.val > val){
            parent = cur;
            cur = cur.left;
        } else {
            return false;
        }
    }
    if(parent.val < val){
        parent.right = node;
    } else {
        parent.left = node;
    }
    node.parent = parent;
    cur = node;

    //调整颜色
    while(parent != null && parent.color == COLOR.RED){
        //根不能是红色，所以一定有父节点
        RBTreeNode grandFather = parent.parent;
        if(parent == grandFather.left){
            RBTreeNode uncle = grandFather.right;
            if(uncle != null && uncle.color == COLOR.RED){
                //情况一
                parent.color = COLOR.BLACK;
                uncle.color = COLOR.BLACK;
                grandFather.color = COLOR.RED;

                //向上迭代
                cur = grandFather;
                parent = cur.parent;
            } else {
                //uncle不存在或者是黑色
                //情况三
                if(cur == parent.right){
                    rotateLeft(parent);
                    RBTreeNode tmp = parent;
                    parent = cur;
                    cur = tmp;
                }//情况三变成情况二

                //情况二
                rotateRight(grandFather);
                grandFather.color = COLOR.RED;
                parent.color = COLOR.BLACK;
            }
        } else {
            //parent == grandfather.right
            RBTreeNode uncle = grandFather.left;
            if(uncle != null && uncle.color == COLOR.RED){
                //情况四
                parent.color = COLOR.BLACK;
                uncle.color = COLOR.BLACK;
                grandFather.color = COLOR.RED;

                //向上迭代
                cur = grandFather;
                parent = cur.parent;
            } else {
                //uncle不存在或者是黑色
                //情况六
                if(cur == parent.left){
                    rotateRight(parent);
                    RBTreeNode tmp = parent;
                    parent = cur;
                    cur = tmp;
                }//情况六变成情况五

                //情况五
                rotateLeft(grandFather);
                grandFather.color = COLOR.RED;
                parent.color = COLOR.BLACK;
            }
        }
    }

    root.color = COLOR.BLACK;
    return true;
}

验证是否为红黑树

中序遍历

红黑树是二叉搜索树，所以应该满足中序遍历结果是一个从小到大的有序序列

public void inorder(RBTreeNode root){
    if (root == null){
        return;
    }
    inorder(root.left);
    System.out.println(root.val);
    inorder(root.right);
}

判断根节点的颜色

如果是空树，我们认为这棵树是红黑树，不是空树的话需要判断这棵树的根节点是否为黑色，如果不是黑色，说明这棵树不是红黑树

if(root == null){
    //空树是红黑树
    return true;
}

if(root.color != COLOR.BLACK){
    System.out.println("根节点不是黑色");
    return false;
}

判断红色节点的孩子节点是否为红色节点

通过另外单写一个方法，可以实现递归查询每一个树的左子树是否满足和右子树是否满足

首先判断传入的节点是否为空，如果是空则返回true

然后判断这个节点是否为红色节点，如果是，则判断他的孩子节点有没有红色的，如果有，说明不满足性质——红色节点的孩子节点不能是红色的，那么就直接返回false

然后去分别判断root的左子树和root的右子树是否满足条件，必须都满足才能返回true，因此是&&的关系

private  boolean checkRedColor(RBTreeNode root){
    if(root == null){
        return true;
    }

    if (root.color == COLOR.RED){
        RBTreeNode parent = root.parent;
        if(parent.color == COLOR.RED){
            System.out.println("红色节点的孩子节点还是红色节点");
            return false;
        }
    }

    return checkRedColor(root.left) && checkRedColor(root.right);
}

判断每条路径的黑色节点总数是否相等

先求出红黑树的某一条路径的黑色节点个数，然后拿这个个数去和其他的路径进行比较

int blackNum = 0;
RBTreeNode cur = root;
while(cur != null){
    if(cur.color == COLOR.BLACK){
        blackNum++;
    }
    cur = cur.left;
}

单写一个判断黑色节点总数的方法，方便我们递归

这里的参数分别有如下的含义：pathBlackNum代表递归到现在时的黑色节点的总个数，而blackNum则是我们计算好了的某一条路径上的黑色节点的总个数

首先判断传入的节点是否为空，如果是空则返回true

然后判断传入的节点是否为黑色的，如果是黑色的，我们就需要让pathBlackNum++，代表这个路径上又多了一个黑色的节点

接着看传入的节点的左右孩子节点是否为空，如果都为空，说明当前传入的节点是叶子节点，那么我们就可以去看当前路径的黑色节点总数pathBlackNum和之前计算的路径中黑色节点个数blackNum是否相等，如果不相等，说明这个路径的黑色节点个数和别的不一致，那么就不是红黑树

然后，分别递归去看左子树的黑色节点个数和右子树的黑色节点个数是否符合要求

private boolean checkBlackNum(RBTreeNode root, int pathBlackNum, int blackNum) {
    if (root == null){
        return true;
    }

    if (root.color == COLOR.BLACK){
        pathBlackNum++;
    }

    if(root.left == null && root.right == null){
        if(pathBlackNum != blackNum){
            System.out.println("某条路径上的黑色节点总数和其他路径的黑色节点总数不一致");
            return false;
        }
    }

    return checkBlackNum(root.left, pathBlackNum, blackNum)
            && checkBlackNum(root.right, pathBlackNum, blackNum);
}

完整检查是否为红黑树代码

public boolean isRBTree() {
    if(root == null){
        //空树是红黑树
        return true;
    }

    if(root.color != COLOR.BLACK){
        System.out.println("根节点不是黑色");
        return false;
    }

    //计算最红黑树的最左面路径的黑色节点个数
    int blackNum = 0;
    RBTreeNode cur = root;
    while(cur != null){
        if(cur.color == COLOR.BLACK){
            blackNum++;
        }
        cur = cur.left;
    }

    //检查是否有红色节点的孩子节点也是红色节点，检查是否某条路径上的黑色节点总数和其他路径的黑色节点总数不一致
    return checkRedColor(root) && checkBlackNum(root,0, blackNum);
}

主函数调用

package rbTree;

public class Test {
    public static void main(String[] args) {
        //int[] array = {16,3,7,11,9,26,18,14,15};
        int[] array = {4,2,6,1,3,5,15,7,16,14};
        RBTree rbTree = new RBTree();
        for (int i = 0; i < array.length; i++) {
            rbTree.insert(array[i]);
        }

        rbTree.inorder(rbTree.root);
        System.out.println(rbTree.isRBTree());
    }
}

在这里插入图片描述
可以看到，我们的红黑树插入代码是正确的，最终的得到的红黑树是满足所有性质的

Xiao8830
关注
专栏目录
面试题——红黑树，B树、B+树
Java
01-06 3163
面试题——红黑树，B树、B+树
红黑树实现java代码
11-01
红黑树实现java代码，供大家参考，具体详解请参见我的博客http://blog.csdn.net/clamclam/article/details/49545477
Java 实现 红黑树（通俗易懂）
最新发布
lllsure的博客
08-07 1343
红黑树的概念和模拟实现
Java之红黑树
qq_41720578的博客
04-28 5235
1、简介 红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。 红黑树是一种特化的AVL树（平衡二叉树），都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。 它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的： 它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目。 红黑树是一种平衡二叉查找树的变体，它的左右子树高差有可能大于 1，所以红黑树不是
红黑树的java实现
qarkly的专栏
06-29 5339
红黑树的原理以及算法见文章：
红黑树理解以及Java实现
热门推荐
qq_41854763的博客
09-13 1万+
我对红黑树的理解 红黑树本身并不复杂，只是在插入删除的时候情况比较多，如果强行记忆的话会显得比较困难，而且容易忘记。所以以前对红黑树一直没有很好的掌握。恰好这次借着复习数据结构的机会，静下心来仔细的学习了一下红黑树，所以用这篇文章把我对红黑树的操作的理解记录下来，在理解的基础上记忆会容易得多，这样以后就不用重复学习啦！ 1. 红黑树的定义 红黑树是一颗二叉查找树，且具有如下...
java最优有序查找——红黑树（RBT）算法
QuinnNorris的博客
05-12 4004
在大量数据中常用的查找数据的做法有四类：顺序查找，二分查找，二叉树查找（BST），红黑树查找（RBT）。 这四类查找方法分别对应着四种基本思想原理： 顺序查找 —— 无序简单查找 二分查找 —— 有序查找，每次折半搜索，插入数据费时 二叉树查找（BST） —— 不平衡二叉树有序查找，插入与搜索综合性能较优 红黑树查找（RBT） —— 平衡二叉树有序查找，插入与搜索
算法学习13——红黑树
qq_22343953的博客
07-27 523
文章目录红黑树红黑树的性质红黑树的插入 红黑树 红黑树是一棵二叉搜索树，拥有二叉搜索树的性质：左子树的所有值小于根节点，右子树的所有值大于根节点。同时还具有近似平衡性质，近似平衡指的是任何节点的左右子树高度不会超过一半。它相对平衡二叉树的优势在于，任何不平衡都可以在三次之内的旋转解决，而平衡二叉树最坏会达到树的高度级别的旋转次数。 红黑树的性质 红黑树节点除了左节点，右节点，关键字的值三个基本二叉树元素之外，还维护了红黑色作为标记。同时null被定义成为叶子节点，具有关键字的节点被定义成为内部节点。 红黑树
GO数据结构——红黑树（一.基础操作）
qq_53057924的博客
09-23 1068
1.简介 R-B Tree，全称是Red-Black Tree，又称为“红黑树”，它一种特殊的二叉查找树。红黑树的每个节点上都有存储位表示节点的颜色，可以是红(Red)或黑(Black)。在开发当中，红黑树的综合效率最高，复杂度也最高。 红黑树的特性: （1）每个节点或者是黑色，或者是红色。（红色代表true，黑色代表false） （2）根节点是黑色。 （3）每个叶子节点（NIL）是黑色。[注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点] （4）如果一个节点是红色的，则它的子节点必须是黑色的
红黑树
ChristinaXinny的博客
09-22 491
写在前面 当在10亿数据进行不到30次比较就能查找到目标时，不禁感叹编程之魅力！人类之伟大呀！ —— 学红黑树有感。 终于，在学习了几天的红黑树相关的知识后，我想把我所学所想和所感分享给大家。红黑树是一种比较难的数据结构，要完全搞懂非常耗时耗力，红黑树怎么自平衡？什么时候需要左旋或右旋？插入和删除破坏了树的平衡后怎么处理？等等一连串的问题在学习前困扰着我。如果你在学习过程中也会存在我的疑问，那么本文对你会有帮助，本文帮助你全面、彻底地理解红黑树！ 本文将通过图文的方式讲解红黑树的知识点，并且不会涉及到任何代
Java-红黑树
weixin_45203607的博客
01-28 600
学习注意事项 必须会二叉搜索树 必须会AVL树 必须知道什么是L , R ,RL , LR 这些旋转概念 以上概念,我博客里都有自行寻找…下面就开始红黑树的讲解了 介绍 红黑树必须满足的5个条件 和AVL树的比较 AVL树是一棵严格的平衡树，它所有的子树都满足二叉平衡树的定义。因此AVL树高被严格控制在(-1 ,1,+1)，因此AVL树的查找比较高效。但AVL树插入、删除结点后旋转的次数比红黑树多。红黑树用非严格的平衡来降低插入删除时旋转的次数。因此，如果你的业务中查找远远多于插入、删除，那选
红黑树详解
qq_44962809的博客
05-10 381
1.定义 红黑树是特殊的二叉查找树，又名R-B树(RED-BLACK-TREE)，由于红黑树是特殊的二叉查找树，即红黑树具有了二叉查找树的特性，而且红黑树还具有以下特性： 1.每个节点要么是黑色要么是红色 2.根节点是黑色 3.每个叶子节点是黑色，并且为空节点(还有另外一种说法就是，每个叶子结点都带有两个空的黑色结点（被称为黑哨兵），如果一个结点n的只有一个左孩子，那么n的右孩子是一个黑哨兵；如果...
Java实现红黑树
HMH_huige的博客
06-06 246
Java实现红黑树
java红黑树
weixin_35755434的博客
12-30 352
Java 红黑树是一种平衡二叉树，它的每个节点都有一个颜色属性，可以是 "红" 或 "黑"。它的每条路径都至少包含相同数量的黑色节点，这使得它的最坏情况下的查询性能比一般二叉搜索树要优秀。红黑树的插入、删除和查找操作的时间复杂度均为 O(logn)，这使得它在需要频繁执行这些操作的场景中非常有用。 Java 红黑树是 Java 的 java.util.TreeMap 类的底层数据结构。它用于存储有...
java的红黑树_java红黑树
weixin_39631445的博客
02-16 72
红黑树性质1、每个结点或是红色的，或是黑色的2、根节点是黑色的3、每个叶结点(NIL)是黑色的4、如果一个节点是红色的，则它的两个儿子都是黑色的。5、对于每个结点，从该结点到其叶子结点构成的所有路径上的黑结点个数相同。和AVL树的比较AVL树是一棵严格的平衡树，它所有的子树都满足二叉平衡树的定义。因此AVL树高被严格控制在XXX，因此AVL树的查找比较高效。但AVL树插入、删除结点后旋转的次数比红...
Java高阶数据结构之红黑树
qq15035899256的博客
09-04 3196
本文是Java高阶数据结构的学习，剖析红黑树底层原理，红黑树的时间复杂度，红黑树的插入以及插入时的平衡调整。之后的学习内容将持续更新！！！
java 红黑树_Java实现红黑树
weixin_29758911的博客
02-12 223
1 packagecom.example.lenovo.linehough;23 public classGRBTree {4 intiCount;5 int[] treeValue;6 GRBTreeNode root;7 boolean BLACK = false;8 boolean RED = true;910 publicGRBTree() {11 ...
java数据结构 红黑树
08-21
- *3* [Java数据结构——红黑树](https://blog.csdn.net/weixin_30699463/article/details/95256212)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值