红黑树

最新推荐文章于 2025-03-01 19:04:21 发布
原创 最新推荐文章于 2025-03-01 19:04:21 发布 · 2.8k 阅读 · 7 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#红黑树
红黑树是一种非严格平衡的二叉搜索树，它的每个节点都有红色或黑色，并遵循特定规则保持平衡。在插入和删除操作中，通过旋转和调整节点颜色保持黑节点平衡。本文介绍了红黑树的基本概念、插入节点的处理策略及其优势。

一.简介

红黑树作为一种二叉搜索树的一种实现，红黑树的左右子树高度差可能大于 1。所以红黑树不是严格意义上的平衡二叉树（AVL），但红黑树是黑色节点完美平衡， 其平均统计性能要强于 AVL 。

红黑树是每个节点都带有颜色属性的二叉查找树，颜色为红色或黑色。
1.节点是红色或黑色。

2.根节点是黑色。

3.每个红色节点的两个子节点都是黑色。（红色节点的子节点必须是黑色节点）

4.从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

故红黑树是黑色平衡的树，左子树与右子树高度差不会超过2倍。红节点的父节点、子节点只能是黑节点

如果插入节点是黑色则所在路径将多出一个黑色节点，故新插入节点是红色节点（插入/删除红色节点不会改变所在路径黑色节点数量），通过旋转和调整节点颜色保证树的平衡

二.实现

红黑树增加/删除节点时需要保证子树黑节点平衡，有如下情况:

1.插入节点为树的根节点时，把根节点颜色修改为黑色

2.插入节点父节点是黑色节点，由于插入节点是红色节点，不会影响该子树黑色节点数量，故不用任何处理

3.插入节点父节点为红色且父节点的兄弟节点也为红色，父节点、父节点的兄弟节点修改为黑色，父节点的父节点修改为红色，再以父节点的父节点为插入节点递归处理

4.父节点为红色且父节点的兄弟节点为null或为黑节点
由于父节点是红色节点，故父节点的父节点为黑色节点

1)LL型
插入数据父节点的兄弟节点只会为null，如果不为null则父节点的兄弟节点子树与父节点将不是平衡的。

修改父节点为黑色节点，祖父节点修改为红色节点
对祖父节点右旋转，让父节点为子树根节点，由于子树黑节点数量没有发生变化，故旋转后黑节点数量和旋转前一样

2)LR型
父节点左旋转将变为LL型，按LL型处理

3)RR型
修改父节点为黑色，祖父节点修改为红色，对祖父节点左旋转，让父节点为子树根节点，旋转后和旋转前黑色节点数量没有改变，故事黑色节点平衡

4)RL型
父节点右旋转变为RR型，按RR型处理

示例说明：

插入数据：4,3,6,5,7,8,9,10,11

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述


package com.vincent;


import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        RBTree<Integer> tree = new RBTree<>();
        for(Integer data : Arrays.asList(4,3,6,5,7,8,9,10,11)){
            tree.add(data);
            System.out.println(tree.getRoot());
        }
        System.out.println();
        List<Integer> list = tree.infixList();
        System.out.println(list);

        tree.delete(list.get(0));

        list = tree.infixList();
        System.out.println(list);

        tree.delete(list.get(list.size()-1));

        list = tree.infixList();
        System.out.println(list);

        tree.delete(list.get(list.size()/2));

        list = tree.infixList();
        System.out.println(list);
    }
}

//红黑树
class RBTree<T extends Comparable<T>>{
    private static final int RED = 0;
    private static final int BLACK = 1;

    static class Node<T extends Comparable<T>> {
        private T item;
        private int color = RED;
        private Node<T> left;
        private Node<T> right;
        private Node<T> parent;

        public Node(T item) {
            this.item = item;
        }

        public T getItem(){
            return item;
        }

        /**
         * 添加节点到当前节点树
         * @param node      添加的节点
         */
        public void add(Node<T> node){
            if(node.item.compareTo(this.item) <= 0){
                if(this.left == null){
                    this.left = node;
                    node.parent = this;
                }
                else{
                    this.left.add(node);
                }
            }
            else{
                if(this.right == null){
                    this.right = node;
                    node.parent = this;
                }
                else{
                    this.right.add(node);
                }
            }
        }


        /**
         * 通过item查找所在树的结点
         * @param item
         * @return
         */
        public Node<T> searchNode(T item){
            int cmp = item.compareTo(this.item);
            if(cmp == 0){
                return this;
            }
            Node<T> node = null;
            if(cmp < 0 && this.left != null && (node=this.left.searchNode(item)) != null){
                return node;
            }
            else if(cmp > 0 && this.right != null && (node=this.right.searchNode(item)) != null){
                return node;
            }
            return null;
        }

        /**
         * 删除节点,如果删除的节点为根节点将有NullPointerException
         */
        public void del(){
            Node<T> parent = this.parent;
            if(this.left==null && this.right==null){//删除节点为叶子节点
                if(parent.left == this){
                    parent.left = null;
                }
                else{
                    parent.right = null;
                }
            }
            else if(this.left == null){//删除节点只有右子树
                if(parent.left == this){
                    parent.left = this.right;
                }
                else{
                    parent.right = this.right;
                }
            }
            else if(this.right == null){//删除节点只有左子树
                if(parent.left == this){
                    parent.left = this.left;
                }
                else{
                    parent.right = this.left;
                }
            }
            else{//删除节点有左右节点,从删除节点左子树中寻找最大值
                Node<T> maxNode = this.left;
                while(maxNode.right != null){
                    maxNode = maxNode.right;
                }
                if(maxNode == this.left){//删除节点左子树的最大值就是删除节点的左节点
                    this.item = maxNode.item;
                    this.left = maxNode.left;
                }
                else{
                    maxNode.parent.right = null;
                    this.item = maxNode.item;
                }
            }
        }

        /**
         * 节点的中序遍历
         * @param dst   遍历节点的存放容器
         */
        public void infixList(List<T> dst){
            if(this.left != null){
                this.left.infixList(dst);
            }
            dst.add(this.item);
            if(this.right != null){
                this.right.infixList(dst);
            }
        }

        /**
         * 该节点树的最大高度
         * @return
         */
        public int height(){
            return Math.max(left==null?0:left.height(),right==null?0:right.height())+1;
        }

        /**
         * 对当前节点左旋转操作
         * @return  返回左旋转操作后子树根节点(即当前节点的右节点)
         */
        public Node<T> leftRotate(){
            if(this.right==null){
                return null;
            }
            Node<T> right = this.right;
            this.right = right.left;
            if(right.left != null) {
                right.left.parent = this;
            }

            right.left = this;
            right.parent = this.parent;
            if(this.parent != null) {
                if (this.parent.left == this) {
                    this.parent.left = right;
                } else {
                    this.parent.right = right;
                }
            }
            this.parent = right;
            return right;
        }

        /**
         * 对当前节点右旋转操作
         * @return  返回右旋转操作后子树根节点(即当前节点的左节点)
         */
        public Node<T> rightRotate(){
            if(this.left==null){
                return null;
            }
            Node<T> left = this.left;
            this.left = left.right;
            if(left.right != null) {
                left.right.parent = this;
            }

            left.right = this;
            left.parent = this.parent;
            if(this.parent != null) {
                if (this.parent.left == this) {
                    this.parent.left = left;
                } else {
                    this.parent.right = left;
                }
            }
            this.parent = left;
            return left;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "item=" + item +
                    '}';
        }
    }

    private Node<T> root;

    Node<T> getRoot(){
        return root;
    }

    public void add(T item){
        Node<T> node = new Node<>(item);
        if(this.root == null){
            this.root = node;
        }
        else{
            Node<T> old = this.root.searchNode(item);
            if(old != null){
                old.item = item;
            }
            else{
                this.root.add(node);
            }
        }
        rebalance(node);
    }

    /**
     * 调整树的平衡性，会依次回溯到父节点
     * @param node      当前插入的节点
     */
    private void rebalance(Node<T> node){
        Node<T> parent = node.parent;
        if(parent == null){//树的根节点
            node.color = BLACK;
            return;
        }
        else if(parent.color == RED) {//红节点一定有父节点
            Node<T> pparent = parent.parent;
            //父节点的兄弟节点
            Node<T> psibling = pparent.left == parent ? pparent.right : pparent.left;
            if (psibling != null && psibling.color == RED) {
                parent.color = psibling.color = BLACK;
                pparent.color = RED;

                rebalance(pparent);
            }
            else if (psibling == null || psibling.color == BLACK) {
                Node<T> subRoot = null;
                if (pparent.left == parent && parent.left == node) {//LL型
                    parent.color = BLACK;
                    pparent.color = RED;
                    subRoot = pparent.rightRotate();

                } else if (pparent.left == parent && parent.right == node) {//LR型
                    parent.leftRotate();
                    node.color = BLACK;
                    pparent.color = RED;
                    subRoot = pparent.rightRotate();
                } else if (pparent.right == parent && parent.left == node) {//RL型
                    parent.rightRotate();
                    node.color = BLACK;
                    pparent.color = RED;
                    subRoot = pparent.leftRotate();
                } else {//RR型
                    parent.color = BLACK;
                    pparent.color = RED;
                    subRoot = pparent.leftRotate();
                }

                //设置树的根节点
                if (subRoot.parent == null) {
                    this.root = subRoot;
                }
            }
        }
    }

    public void delete(T item){
        Node<T> delNode = null;
        if(root.item.compareTo(item)==0){//删除根节点
            delNode = root;

            if(root.left==null && root.right==null){
                this.root = null;
            }
            else if(root.left==null){
                this.root = root.right;
            }
            else if(root.right==null){
                this.root = root.left;
            }
            else{//根节点有左右节点,扫描右子树最小节点
                Node<T> node = this.root.right;
                while(node.left!=null){
                    node = node.left;
                }
                if(node == this.root.right){
                    this.root.item = node.item;
                    this.root.right = node.right;
                }
                else {
                    node.parent.left = null;
                    this.root.item = node.item;
                }
            }
        }
        else {
            Node<T> node = this.root.searchNode(item);
            delNode = node;
            if (node != null) {
                node.del();
            }
        }
        if(delNode != null){
            this.rebalance(delNode);
        }
    }

    public List<T> infixList(){
        List<T> rst = new ArrayList<>();
        this.root.infixList(rst);
        return rst;
    }

    public int height(){
        return this.root.height();
    }

}

三.总结

红黑树的平衡处理相对AVL较为宽松，数据插入/删除时效率相对较高

【数据结构】红黑树
weixin_43148189的博客
12-19 634
概述 AVL树 是一种自平衡二叉查找树，它要求每个结点的左右子树的高度之差的绝对值（平衡因子）不超过1，所以它是一种非常严格的平衡二叉树； 红黑树（Red Black Tree） 也是一种自平衡二叉查找树，它是许多“平衡”搜索树中的一种，它可以保证在最坏情况下基本动态集合操作的时间复杂度为O(lgn)；红黑树在它的每个结点上增加了一个存储位来表示结点的颜色，可以是RED或BLACK；红黑树确保没有...
红黑树原理
Flippeds的博客
12-01 458
一.简介 红黑树作为一种二叉搜索树的一种实现，红黑树的左右子树高度差可能大于 1。所以红黑树不是严格意义上的平衡二叉树（AVL），但红黑树是黑色节点完美平衡， 其平均统计性能要强于 AVL 。 红黑树是每个节点都带有颜色属性的二叉查找树，颜色为红色或黑色。 1.节点是红色或黑色。 2.根节点是黑色。 3.每个红色节点的两个子节点都是黑色。（红色节点的子节点必须是黑色节点） 4.从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。 故红黑树是黑色平衡的树，左子树与右子树高度差不会超过2倍。红节点的父节点
数据结构-RBTree(红黑树)
Fly_Fly_Zhang的博客
07-14 1216
概述： 红黑树是不是一颗平衡树: 不是，其高度差可以达到n 红黑树结点左右子树高度差： 长的不能超过短的二倍。因为需要保证所有路径上黑色节点数量相等，因此若一条节点路径全部是黑色，另一条路径红黑相间也只能插入2n个。 红黑树的增删效率？ 高于AVL树，红黑树插入最多调整两次，删除调整三次。AVL树最多调整次数达到层数次。 红黑树特点： 每个节点都有颜色，非黑即红。 所有叶子节点都是黑色的，叶...
数据结构复习——红黑树
qq_40462579的博客
04-24 1082
红黑树是一种近似平衡的二叉搜索树，它能够保证任何一个节点的左右子树的高度差小于两倍（高的树的高度最大是矮的树的高度两倍）。 红黑树是满足以下条件的二叉搜索树： 每个节点要么是红色，要么是黑色； 根节点是黑色的； 每个叶节点（空节点）是黑色的； 不能有相邻的两个红色节点； 从任意一节点到其每个叶子的所有路径都包含相同数目的黑色节点； 红黑树示意图1： 红黑树示意图2： 关键性质：从根节点到叶...
红黑树简介
zrh_CSDN的博客
06-25 584
伸展树实现简单、无需修改节点结构、分摊复杂度低，但可惜最坏情况下的单次操作需要时间，难以适用于对可靠性和稳定性要求极高的场合。AVL树尽管可以保证最坏情况下的单次操作速度，但需要在节点中嵌入平衡因子等标识，删除操作之后的重平衡可能需做多达次旋转，从而频繁地导致全树整体拓扑结构的大幅度变化。红黑是即是针对后一不足的改进。通过为节点指定颜色，并巧妙地动态调整，红黑树可保证：在每次插入或删除操作之后的重...
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
热门推荐
小七的博客
01-18 28万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
Go最新【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树(1)，2024年最新赶紧学起来
2401_84925044的博客
05-17 920
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新如果你需要这些资料，可以戳这里获取上面这颗红黑树，我们来将所有的红色节点上移到和他们的父节点同一高度上，就会形成如下结构这个结构很明显，就是一棵四阶B树（一个节点最多放三个数据），如果画成如下的样子大家应该就能看的更清晰了。由上面的等价变换我们就可以得
2024年Go最全【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树，2024最新大厂Golang面经
2401_84911119的博客
05-14 907
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新如果你需要这些资料，可以戳这里获取我们可以利用四阶B树与红黑树等价的性质，以红黑树转换成B树之后的节点情况来进行一个分类红黑树的基本操作和其他树形结构一样，一般都包括查找、插入、删除等操作。前面说到，红黑树是一种自平衡的二叉查找树，既然是二叉查找树的一
面试问你红黑树，你都懂了吗
tyrroo的博客
08-27 581
红黑树（Red Black Tree）是一种自平衡的二叉搜索树（Self-balancing Binary Search Tree）。以前也叫做平衡二叉 B 树（Symmetric Binary B-tree）。 预备知识 树的知识框架结构如下图所示： image 平衡二叉搜索树 平衡二叉搜索树（Balanced Binary Search Tree），英文简称 BBST。经典常见的平衡二叉搜索树是 AVL 树和红黑树。 ①二叉搜索树 二叉搜索树（Binary Search T..
平衡二叉树和红黑树最差情况性能分析
大菜鸟的博客
04-22 1万+
平衡二叉树和红黑树最差情况分析 1.经典平衡二叉树 平衡二叉树（又称AVL树）是带有平衡条件的二叉查找树，使用最多的定理为：一棵平衡二叉树是其每个节点的左子树和右子树的高度最多差为1的二叉查找树。因为他是二叉树的一种具体应用，所以他同样具有二叉树的性质。例如，一棵满二叉树在第k层最多可拥有个节点（性质1）。一棵树的高度为其从根节点到最底层节点经过的路径数（例如只含一个节点的树的高度为0）...
红黑树简单介绍
m0_57015193的博客
09-12 493
红黑树是二插平衡树的再优化，二插平衡树强制要求左右子树高度差不能超过1，并且它的左右子树也得是二插平衡树。这就导致每次添加、删除元素时需要大量的操作保持树的平衡，红黑树在其基础上优化，它不强制要求高度差必须小于1，但也尽可能保证树相对平衡，查询效率也高 首先红黑树需要满足以下几条规则： 1. 节点非黑即红 2. 根节点必须黑色 3. 每个叶节点（不是叶子节点，页节点值 NIL 或空节点）必须是黑色 4. 每个红色节点的两个子节点必须是黑色 5. 从任一节点到每个叶节点所经过的黑色节点数目相同 也就是说
数据结构与算法之红黑树
蘑菇蘑菇不会开花的专栏
07-25 418
在上一篇我们说到2-3树在某些情况插入后的平衡操作可能会使得效率降低，在2-3查找树基础上改进的红黑树不仅具有较高的效率。那么红黑树是如何操作的呢？ 定义 红黑树是一种近似平衡的二叉查找树，它能够确保任何一个节点的左右子树的高度差不会超过二者中较低那个的一陪。具体来说，红黑树是满足如下条件的二叉查找树（binary search tree）： 每个节点要么是黑色要么是红色 根节点是黑色 每个叶子节点是黑色，并且为空节点(还有另外一种说法就是，每个叶子结点都带有两个空的黑色结点（被称为黑哨兵），如果一个结点
红黑树和AVL树的区别以及红黑树的调整规则
是木子啦~
03-30 741
AVL树和红黑树 AVL树高度平衡，每进行一次增删操作就要判断一下是否平衡，红黑树可以好几次增删操作再判断是否平衡 频繁增删用红黑树，频繁查找用二叉平衡树 *红黑树条件： 1.根是黑色 2.（红属性）红色节点的孩子必须是黑的的（两个红色的不可以连在一起，但是两个黑色的可以连在一起） 3.（黑属性）每一个节点，到它的叶子节点都包括相同的黑节点（红黑树的叶子节点是空指针） 4.根据上面三个规则可以推出，红黑树的高度最大是2*log(n+1) (以2为底，注意是2倍的) 保证平衡是看黑色高度 红黑树的插入
一文带你彻底搞懂红黑树【史上最好理解的红黑树讲解】
最新发布
jiayoucode的博客
03-01 580
看到这篇文章的小伙伴，耐下心来，红黑树这个命题，你会彻底的搞明白他的原理是什么。
30张图带你彻底理解红黑树
qq_43842093的博客
04-05 1055
当在10亿数据进行不到30次比较就能查找到目标时，不禁感叹编程之魅力！人类之伟大呀！—— 学红黑树有感。终于，在学习了几天的红黑树相关的知识后，我想把我所学所想和所感分享给大家。红黑树是一种比较难的数据结构，要完全搞懂非常耗时耗力，红黑树怎么自平衡？什么时候需要左旋或右旋？插入和删除破坏了树的平衡后怎么处理？等等一连串的问题在学习前困扰着我。如果你在学习过程中也会存在我的疑问，那么本文对你会有帮助，本文帮助你全面、彻底地理解红黑树！
傻瓜都能看懂，30张图彻底理解红黑树！
独爱米粒
01-23 891
傻瓜都能看懂，30张图彻底理解红黑树！ 当在 10 亿数据中只需要进行十几次比较就能查找到目标时，不禁感叹编程之魅力!人类之伟大呀!                                                                                                             ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值