八大数据结构——红黑树（七）

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

八大数据结构——红黑树（七）

目录


树是数据结构中非常重要的一项，有关树的数据结构有许多种，本文重点研究的是红黑树。

关于红黑树，是二叉树范畴里的高级数据结构，内容十分的多，网上各种文章参差不齐，经过我的血泪史，读者可以通过以下文章，完整的了解红黑树，并且最后附上Java实现代码。

二叉搜索树

红黑树是建立在二叉搜索树基础上的，如果您还不了解，请看 八大数据结构——二叉搜索树（七）。

2-4树

在学习红黑树之前，您需要搞懂：红黑树中最重要的，红与黑两种颜色代表什么？为什么要用标上红与黑这两种颜色？
通过了解2-4树（您不一定要完全掌握2-4树），来理解红黑树。请看 通过2-3-4树理解红黑树 。

红黑树的定义和插入

通过该篇文章，您可以初步了解红黑树的定义和插入操作。请看 彻底理解红黑树（二）之 插入 。

红黑树的删除

红黑树的删除是其重点与难点，涉及的情况非常多，如果您一时无法明白，可以结合下面的实现代码理解。请看 彻底理解红黑树（三）之 删除 。

红黑树演示网站

有一个网站，非常不错，可以动态演示很多常用的数据结构，您可以通过该网站直观地了解红黑树的插入和删除操作。请看 红黑树演示网站 。
如果您还想了解其他的数据结构动画，可以点击它们的目录 演示网站目录 。

红黑树与AVL树

学习过AVL树的都知道，AVL树的平衡程度更高于红黑树，为什么许多的实际数据结构应用，还是使用了红黑树呢？

  1. 著名的linux进程调度Completely Fair Scheduler,用红黑树管理进程控制块
  2. epoll在内核中的实现，用红黑树管理事件块
  3. nginx中，用红黑树管理timer等
  4. Java的TreeMap实现

请看 红黑树与AVL树，各自的优缺点总结 。

面试中关于红黑树

面试常问：什么是红黑树？ 。

代码实现

洋洋洒洒地学完那么多，来看看Java代码实现吧。您可以对照前面的文章来看代码，就会好理解很多，代码中给出了一些重要注释，也方便您的理解。

//红黑树
public class RedBlackTree<T extends Comparable> {
    private RBNode<T> root;
    private int size;

    public RedBlackTree() {
        root = null;
        size = 0;
    }

    public RedBlackTree(T val) {
        root = new RBNode<>();
        root.color = Color.black;
        root.val = val;
        size = 1;
    }

    public boolean empty() {
        return size == 0;
    }

    public int size() {
        return size;
    }

    //    插入节点
    public boolean insert(T val) {
        //        如果val为null直接返回
        if (val == null) {
            return false;
        }
        //        如果root为null，那新建一个节点，并让保存为root
        if (root == null) {
            root = new RBNode<>();
            root.val = val;
            root.color = Color.black;
            size++;
            return true;
        }
        //        root不为null，那就通过循环找到正确的插入位置
        RBNode<T> node = root;
        while (true) {
            //            如果val与已有值相等，则不允许插入
            if (node.val.compareTo(val) == 0) {
                return false;
            }
            //            val值小于当前节点，则插入到左子树
            if (node.val.compareTo(val) > 0) {
                //                如果左子节点为空，则插入到此处
                if (node.leftNode == null) {
                    RBNode<T> leftNode = new RBNode<>();
                    leftNode.val = val;
                    leftNode.color = Color.red;
                    node.leftNode = leftNode;
                    adjustInsert(leftNode);
                    size++;
                    return true;
                } else {
                    //                    不为空继续往下找
                    node = node.leftNode;
                }
                //                val值大于当前节点，则插入到右子数
            } else {
                //                如果右子节点为空，则插入到此处
                if (node.rightNode == null) {
                    RBNode<T> rightNode = new RBNode<>();
                    rightNode.val = val;
                    rightNode.color = Color.red;
                    node.rightNode = rightNode;
                    adjustInsert(rightNode);
                    size++;
                    return true;
                } else {
                    //                    不为空继续往下找
                    node = node.rightNode;
                }
            }
        }
    }

    //    删除节点
    public boolean remove(T val) {
        RBNode<T> node = find(val);
        if (node == null) {
            return false;
        }
        //        要删除的节点有三种情况，度为2，度为1和度为0的。
        //        平衡的情况也分三种：1.1删除的节点度为0，且为红色，无需调整。
        //                          1.2删除的节点度为0，且为黑色，需调整。
        //                          2
        //                          .删除的节点度为1，将子节点涂为黑色即可。（只有一个子节点时，删除节点比为是黑色，其子节点为红色）
        //                          3
        //                          .删除的节点度为2，实际上删除节点知识替换了值，真正被删除的是其左子树中最大节点，而这个最大节点度为0，或1，所以又转向上面的情况。
        if (node.leftNode != null && node.rightNode != null) {
            //            度为2的节点，删除步骤为
            //            1.找到要删除节点的左子数中最大节点。
            //            2.替换待删除节点的值为这个最大节点值
            //            3.将这个最大节点删除
            RBNode<T> maxNode = node.leftNode;
            while (maxNode.rightNode != null) {
                maxNode = maxNode.rightNode;
            }
            remove(maxNode.val);
            node.val = maxNode.val;
        } else {
            //            度为1和度为2的节点一起处理，分两种情况。
            //            1.要删除的节点为根节点。
            //            2.要删除的节点为非根节点。
            RBNode<T> parent = parent(node);
            RBNode<T> brother = brother(node);
            RBNode<T> child =
                    node.leftNode == null ? node.rightNode : node.leftNode;
            //            根节点无父节点，直接将根节点指向子节点即可。
            if (parent == null) {
                root = child;
            } else {
                //                非根节点，找到它是父节点的左子节点，还是右子节点，然后通过修改父节点指针即可。
                adjustParent(node, child);
            }
            if (child == null) {
                //                删除节点度为0，且为黑色，需要调整。
                if (node.color.compareTo(Color.black) == 0) {
                    adjustDelete(parent, brother);
                }
            } else {
                //                删除节点度为1，只需将子节点涂黑。
                child.color = Color.black;
            }
        }
        size--;
        return true;
    }

    //    插入后调整红黑树。
    private void adjustInsert(RBNode<T> node) {
        //        处理情景4.1的情况，如果祖先节点是根节点，将根节点又设置回黑色。
        if (node == root) {
            node.color = Color.black;
            return;
        }
        RBNode<T> parent = parent(node);
        if (parent.color.compareTo(Color.black) == 0) {
            //            情景3：父节点为黑色
            return;
        } else {
            //            父节点如果为红色，那么必然存在祖先节点，因为根节点是黑色，而且两个红色节点不能相连。
            //            情景4：插入结点的父结点为红结点
            RBNode<T> grandparent = parent(parent);
            RBNode<T> uncle = uncle(node);
            if (uncle != null && uncle.color.compareTo(Color.red) == 0) {
                //                情景4.1：叔叔结点存在并且为红结点
                parent.color = Color.black;
                uncle.color = Color.black;
                grandparent.color = Color.red;
                adjustInsert(grandparent);
            } else {
                if (grandparent.leftNode == parent) {
                    //                    情景4
                    //                    .2：叔叔结点不存在或为黑结点，并且插入结点的父亲结点是祖父结点的左子结点
                    if (parent.leftNode == node) {
                        //                        情景4.2.1：插入结点是其父结点的左子结点
                        RTurn(grandparent);
                        grandparent.color = Color.red;
                        parent.color = Color.black;
                    } else {
                        //                        情景4.2.2：插入结点是其父结点的右子结点
                        LTurn(parent);
                        RTurn(grandparent);
                        node.color = Color.black;
                        grandparent.color = Color.red;
                    }
                } else {
                    //                    情景4
                    //                    .3：叔叔结点不存在或为黑结点，并且插入结点的父亲结点是祖父结点的右子结点
                    if (parent.leftNode == node) {
                        //                        情景4.3.1：插入结点是其父结点的左子结点
                        RTurn(parent);
                        LTurn(grandparent);
                        node.color = Color.black;
                        grandparent.color = Color.red;
                    } else {
                        //                        情景4.3.2：插入结点是其父结点的右子结点
                        LTurn(grandparent);
                        grandparent.color = Color.red;
                        parent.color = Color.black;
                    }
                }
            }
        }
    }

    //    删除后调整红黑树，brother无需进行null判断，因为当删除节点是度为0的黑色时，其左子树黑色点已经达到2（null算黑色），
    //    而兄弟节点如果为null，那么右子树黑色节点只有1，这是不可能的，在删除前，树一定是平衡的。
    //    而兄弟节点的子节点，只要是red，必然不为null，而只有是red的情况，我们才调用到，所以也不会出现空指针。
    //    像下面的兄弟节点的子节点为黑时，是不会有对这个黑色子节点的操作的，有些旋转后是它另外一个红色子节点上位了，
    //    而原来的兄弟节点下去当子节点了，依然不会涉及黑色子节点的操作。
    private void adjustDelete(RBNode<T> parent, RBNode<T> brother) {
        //        1.n为根节点，无需平衡操作
        if (parent == null) {
            return;
        }
        if (brother.color.compareTo(Color.black) == 0) {
            //            2.兄弟节点为黑色
            if (!(brother.leftNode != null &&
                    brother.leftNode.color.compareTo(Color.red) == 0) &&
                    !(brother.rightNode != null &&
                            brother.rightNode.color.compareTo(Color.red) ==
                                    0)) {
                //                2.1兄弟子节点全黑
                if (parent.color.compareTo(Color.red) == 0) {
                    //                    2.1.1父红
                    exchangeColor(parent, brother);
                } else {
                    //                    2.1.2父黑
                    brother.color = Color.red;
                    adjustDelete(parent(parent), brother(parent));
                }
            } else {
                //                2.2.1兄在左
                if (parent.leftNode == brother) {
                    //                    兄左子红
                    if (brother.leftNode != null &&
                            brother.leftNode.color.compareTo(Color.red) == 0) {
                        RTurn(parent);
                        exchangeColor(parent, brother);
                        brother.leftNode.color = Color.black;
                    } else {
                        //                        兄左子黑
                        RBNode<T> rightNode = brother.rightNode;
                        LTurn(brother);
                        exchangeColor(brother, rightNode);
                        adjustDelete(parent, rightNode);
                    }
                } else {
                    //                    2.2.2兄在右
                    if (brother.rightNode != null &&
                            brother.rightNode.color.compareTo(Color.red) == 0) {
                        //                        兄右子红
                        LTurn(parent);
                        exchangeColor(parent, brother);
                        brother.rightNode.color = Color.black;
                    } else {
                        //                        兄右子黑
                        RBNode<T> leftNode = brother.leftNode;
                        RTurn(brother);
                        exchangeColor(brother, leftNode);
                        adjustDelete(parent, leftNode);
                    }
                }
            }
        } else {
            //            3.兄弟节点为红色
            if (parent.leftNode == brother) {
                //                兄在左
                RBNode<T> rightNode = brother.rightNode;
                RTurn(parent);
                exchangeColor(parent, brother);
                adjustDelete(parent, rightNode);
            } else {
                //                兄在右
                RBNode<T> leftNode = brother.leftNode;
                LTurn(parent);
                exchangeColor(parent, brother);
                adjustDelete(parent, leftNode);
            }
        }
    }

    //    修改父节点的左右子节点指针。
    private void adjustParent(RBNode<T> node, RBNode<T> child) {
        RBNode<T> parent = parent(node);
        if (parent.leftNode != null && parent.leftNode == node) {
            parent.leftNode = child;
        } else {
            parent.rightNode = child;
        }
    }

    //    交换颜色
    private void exchangeColor(RBNode<T> node1, RBNode<T> node2) {
        Color color = node1.color;
        node1.color = node2.color;
        node2.color = color;
    }

    //    查找节点
    private RBNode<T> find(T val) {
        if (root == null || val == null) {
            return null;
        }
        RBNode<T> node = root;
        while (node != null) {
            if (node.val.compareTo(val) == 0) {
                return node;
            } else if (node.val.compareTo(val) > 0) {
                node = node.leftNode;
            } else {
                node = node.rightNode;
            }
        }
        return null;
    }

    //    左旋
    private void LTurn(RBNode<T> node) {
        RBNode<T> parent = parent(node);
        RBNode<T> rightNode = node.rightNode;
        if (parent == null) {
            root = rightNode;
        } else {
            adjustParent(node, rightNode);
        }
        node.rightNode = rightNode.leftNode;
        rightNode.leftNode = node;
    }

    //    右旋
    private void RTurn(RBNode<T> node) {
        RBNode<T> parent = parent(node);
        RBNode<T> leftNode = node.leftNode;
        if (parent == null) {
            root = leftNode;
        } else {
            adjustParent(node, leftNode);
        }
        node.leftNode = leftNode.rightNode;
        leftNode.rightNode = node;
    }

    //    查找父节点。
    private RBNode<T> parent(RBNode<T> current) {
        if (root == null || current == null) {
            return null;
        }
        RBNode<T> node = root;
        while (node != null) {
            if (node.leftNode == current || node.rightNode == current) {
                return node;
            } else if (node.val.compareTo(current.val) > 0) {
                node = node.leftNode;
            } else {
                node = node.rightNode;
            }
        }
        return null;
    }

    //    查找叔叔节点
    private RBNode<T> uncle(RBNode<T> node) {
        RBNode<T> parent = parent(node);
        return brother(parent);
    }

    //    查找兄弟节点
    private RBNode<T> brother(RBNode<T> node) {
        RBNode<T> parent = parent(node);
        if(parent==null){
            return null;
        }
        if (parent.leftNode != null && parent.leftNode == node) {
            return parent.rightNode;
        } else {
            return parent.leftNode;
        }
    }

    private void LDR(RBNode<T> node) {
        if (node == null) {
            return;
        }
        LDR(node.leftNode);
        System.out.println(node.val+","+node.color);
        LDR(node.rightNode);
    }

    public void LDR() {
        LDR(root);
    }
}

//红黑树节点。
class RBNode<T extends Comparable> {
    Color color;
    T val;
    RBNode<T> leftNode;
    RBNode<T> rightNode;
}

//枚举类，定义红黑两种颜色。
enum Color {
    red, black
}
BaldIsImpossible
关注
专栏目录
底层实现数据结构：红黑树
ChanYipFan的博客
04-18 1156
学习某个知识（比如红黑树），一上来就扔给你5个定义（就算算法导论那样），告诉你这就是红黑树，然后又从这5个定义推出更多定义。其实这会让学习者很难理解到底什么是红黑树的，这样最大的问题就在于没有介绍清楚这个红黑树是从哪来的，我们为什么要把节点定义成红色或黑色。 2-3树插入元素： 一个原则: 添加节点将永远不会添加到一个空的位置(和二叉搜索树不同)、只会和最后找到的叶子节点做融合：...
《数据结构——C++实现》（第二版）课本源代码
10-30
2. **高级数据结构实现**：例如二叉树（包括二叉搜索树、AVL树、红黑树等）、堆（最大堆和最小堆）、哈希表等。这些数据结构在实际应用中非常常见，如数据库索引、优先队列等。 3. **图数据结构**：包括邻接矩阵和...
数据结构 红黑树性质总结
不远远方
03-18 645
转自： https://www.cnblogs.com/bethunebtj/articles/4853480.html 1.stl中的set底层用的什么数据结构？ 2.红黑树的数据结构怎么定义的？ 3.红黑树有哪些性质？ 4.红黑树的各种操作的时间复杂度是多少？ 5.红黑树相比于BST和AVL树有什么优点？ 6.红黑树相对于哈希表，在选择使用
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
热门推荐
小七的博客
01-18 21万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
【C++进阶学习】第八弹——红黑树的原理与实现——探讨树形结构存储的最优解
最新发布
2301_80220607的博客
07-22 2578
【C++进阶】+【高阶数据结构】——红黑树的原理与实现——超详解，适合小白学习了解！！！
数据结构-红黑树
流华追梦的专栏
06-14 126
大家应该都学过平衡二叉树(AVLTree)，了解到AVL树的性质，其实平衡二叉树最大的作用就是查找，AVL树的查找、插入和删除在平均和最坏情况下都是O(logN)。AVL树的效率就是高在这个地方。如果在AVL树中插入或删除结点后，使得高度之差大于1。此时，AVL树的平衡状态就被破坏，它就不再是一棵二叉树；为了让它重新维持在一个平衡状态，就需要对其进行旋转处理，那么创建一颗平衡二叉树的成本其实不小。
王道数据结构笔记03-红黑树/RBT
testleaf.cn
08-31 3232
为什么要发明红黑树？ 红黑树大概会怎么考？ 红黑树的定义 【实例】一颗红黑树： 【练习】是否符合红黑树要求？ 【一种可能的出题思路】 补充概念：结点的“黑高” 红黑树的性质 红黑树的查找 红黑树的插入 红黑树的删除 红黑树插入演示 与“黑高”相关的推论 左根右，根叶黑，不红红，黑路同 黑叔：旋转+染色 红叔：染色+变新 LL型：右单旋，父换爷+染色 RR型：左单旋，父换爷+染色 LR型：左、右双旋，儿换爷+染色 RL型：右、左双旋，儿换爷+染色............
【数据结构】红黑树（RBTree）详解——C++实现
Sauron7i的博客
10-15 793
每一个节点都是有颜色的，不是黑色就是红色。根节点root必须是黑色的。所有叶子节点都是黑色的，叶子节点是NULL节点，不存储实际的数据。每个红色节点必须有两个黑色的子节点，或者说是从每个叶子节点到根节点的所有路径上不能有连续的红色节点。从任一节点到其每个叶子上的所有简单路径都包含相同数目的黑色节点。因为每个节点不是红色就是黑色，所以需要定义一个颜色相关的枚举量。还需要操作其父节点，所以定义一个parent指针。private :// 节点颜色 enum Color {
C++ 第八节&数据结构 第七节 ——二叉搜索树 AVL树 红黑树（底层原理图+模拟实现）
jxwd的博客
03-02 2769
我们将着重来探讨 二叉树 中特殊的两种树——搜索二叉树 和 平衡二叉树。而平衡二叉树我们可以有AVL树，红黑树等。 我们今天就重点来说说这三种结构。 1、二叉搜索树 我们之所以将其放在这里来讲，最主要的原因就是之前我们所有模拟实现都是用C去实现的，而这些东西用C语言很难实现，所以，我们将其放在C++当中。 1-1、概念 二叉搜索树又称二叉排序树，它要么是一个空树，要么是满足以下性质的一个二叉树。 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树
数据结构——八大排序
m0_49687898的博客
05-23 770
一、直接插入排序 二、希尔排序 三、选择排序 四、堆排序 五、冒泡排序 六、快速排序递归版本 1.hoare法 2.挖坑法 3.前后指针法 快排优化版本 1.三位数取中 2.小区间优化 非递归版本 快排总结 七、归并排序 递归版本 非递归版本 八、计数排序 九、八大排序总结
数据结构 ——java语言描述 源代码
11-29
朱站立先生的《数据结构 ——java语言描述》源代码涵盖了以上诸多内容，通过阅读和实践这些源代码，开发者可以深入理解各种数据结构的内部工作机制，并提升编程技巧。同时，清华大学出版社的出版也确保了资料的专业...
《数据结构算法实现》随书代码
06-05
《数据结构算法实现》是一本经典的教材，由严蔚敏教授编写，主要涵盖了计算机科学中的核心主题——数据结构和算法的实现。这本书的配套代码提供了对书中理论的实践支持，帮助读者深入理解各种数据结构的工作原理及其...
数据结构——殷人昆版习题答案
10-12
堆是一种特殊的树形数据结构，满足最大堆或最小堆的性质。堆常用于实现优先队列，也是快速排序和堆排序的基础。 七、排序与查找 1. 排序：冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等是常见的排序...
八大数据结构——哈夫曼树（七）
BaldIsImpossible的博客
03-09 3018
八大数据结构——哈夫曼树（七） 目录八大数据结构——哈夫曼树（七）基础定义哈夫曼树的构造哈夫曼树编码哈夫曼树解码代码实现完整代码 树是数据结构中非常重要的一项，有关树的数据结构有许多种，本文重点研究的是哈夫曼树（最优二叉树）。 基础定义 路径： 对于一棵子树中的任意两个不同的结点，如果从一个结点出发，按层次自上而下沿着一个个树枝能到达另一结点，称它们之间存在着一条路径。可用路径所经过的结点序列表示路径，路径的长度等于路径上的结点个数减1。 权重： 无论是节点还是路径都可以带有一个权重，通常可以是一个数值。这
树的前序，中序，后序遍历。
BaldIsImpossible的博客
03-06 867
目录定义与解释递归代码实现非递归代码实现 定义与解释 前序遍历： 前序遍历（VLR）， [1] 是二叉树遍历的一种，也叫做先根遍历、先序遍历、前序周游，可记做根左右。前序遍历首先访问根结点然后遍历左子树，最后遍历右子树。 中序遍历： 中序遍历（LDR）是二叉树遍历的一种，也叫做中根遍历、中序周游。在二叉树中，中序遍历首先遍历左子树，然后访问根结点，最后遍历右子树。 后序遍历： 后序遍历（LRD）是二叉树遍历的一种，也叫做后根遍历、后序周游，可记做左右根。后序遍历有递归算法和非递归算法两种。在二叉
八大数据结构——哈希表（五）
BaldIsImpossible的博客
02-27 719
import java.util.Enumeration; import java.util.NoSuchElementException; //哈希表，基于“开放链地址法”的冲突解决方法 public class HashTable<K, V> { // 定义存储容器,表长如果改变，原来的哈希算法也要调整，情况复杂，这里不予考虑，所以表长初始化就不给改变。 private HashNode<K, V>[] array; // 记录已存储元素个数
八大数据结构——数组（一）
BaldIsImpossible的博客
02-23 617
八大数据结构——数组（一） 数据结构定义（百度解释）： 数据结构(data structure)是带有结构特性的数据元素的集合，它研究的是数据的逻辑结构和数据的物理结构以及它们之间的相互关系，并对这种结构定义相适应的运算，设计出相应的算法，并确保经过这些运算以后所得到的新结构仍保持原来的结构类型。 常用的主要有八大类型：1.数组（Array）2.栈（Stack）3.链表（Linked List）4.图（Graph）5.散列表（哈希表）（Hash）6.队列（Queue）7.树（Tree）8.堆（Heap）。
八大数据结构——链表（三）
BaldIsImpossible的博客
02-23 421
//实现一个只有单向的链表 public class LinkedList<Type> { private Node<Type> firstNode;//头节点 private Node<Type> lastNode;//尾节点 private int size; public LinkedList(){ clear(); } public LinkedList(Type val) { c
八大数据结构——栈（二）
BaldIsImpossible的博客
03-03 388
八大数据结构——栈（二） 目录八大数据结构——栈（二）java代码实现完整代码 常用的主要有八大类型：1.数组（Array）2.栈（Stack）3.链表（Linked List）4.图（Graph）5.散列表（哈希表）（Hash）6.队列（Queue）7.树（Tree）8.堆（Heap）。 **栈定义（百度解释）： ** 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。 可以把栈理解为一个箱子，四周都是封上的，只有
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值