红黑树的实现原理及应用

最新推荐文章于 2024-06-17 19:15:39 发布
最新推荐文章于 2024-06-17 19:15:39 发布
阅读量2.4k 收藏 2
点赞数 1
分类专栏： 容器 文章标签： 红黑树 hashmap 二叉树 ConcurrentHashMap java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wau_hua/article/details/85325767
版权

@OTC

什么是红黑树

红黑树(R-B Tree, 全称 Red-Black Tree)是一种特殊的二叉查找树, 其中每个节点都有颜色, 红色或者黑色.
红黑树的特性:

  1. 树的节点是黑色或者红色
  2. 树的根节点和指向null的叶子节点都是黑色
  3. 不能有两个红色节点是连续的
  4. 每个节点至为null的子节点的任何路径, 都含有相同数量的黑色节点

示例:

             8B
            / \
           4R  9B
          /  \
        2B    6B
       /  \   / \
      1R  3R 5R  7R

红黑树的应用和时间复杂度

  1. 主要是 Java 中的 TreeMap 和 TreeSet. jdk1.8 之后, HashMap 的table中的链表长度大于8的时候也是用 红黑树.
  2. 时间复杂度: 查找, 插入, 删除都可以在 O(log n) 内完成. 且节点数为 n 的数高度最大为 2log(n+1).

红色树的操作

节点的基本定义
    //节点定义
    public class RBTNode<T extends Comparable<T>> {
        public boolean isBlack;
        public T key;
        public RBTNode<T> parent;
        public RBTNode<T> left;
        public RBTNode<T> right;

        public RBTNode(T key, RBTNode<T> parent, RBTNode<T> left, RBTNode<T> right, boolean isBlack) {
            this.isBlack = isBlack;
            this.key = key;
            this.parent = parent;
            this.left = left;
            this.right = right;
        }
    
        public String toString() {
            return "key: " + key + (isBlack ? " B " : " R ") +
                    (parent != null ? (
                            ((parent.left != null && parent.left == this) ?
                                    parent.key + " Left" :
                                    (parent.right != null && parent.right == this) ?
                                    parent.key + " Right" : ""))
                            : "");
        }
    }
旋转 - 左旋转的两种情况

旋转的中心思想是: 从新设置 x 节点, y 节点的 左 父 右 节点, 并设置关联变化的节点的父节点.

    px                   px             |                px                    px                     
     \                    \             |               /                     /                  
      x                    y            |              x           ->        y                                 
     / \      ->          / \           |             / \                   / \                       
   lx   y                x  ry          |            lx  y                 x   ry                        
       / \              / \             |               / \               / \                           
     ly  ry            lx  ly           |              ly  ry            lx ly                       

    // 对 x 进行左旋转, 将 x 是 y 的父节点变成, y 是 x 的父节点.
    private void rotateLeft(RBTNode<T> x) {
        RBTNode<T> y = x.right;
        // 1. 设置x 的 左 父 右 节点
        // 1-1 x的左节点无变化
        // 1-2 x的右节点, 设置x右节点的父节点
        x.right = y.left;
        if(y.left != null) y.left.parent = x;
        // 1-3 x的父节点无变化

        //2. 设置y 的 左 父 右 节点
        //2-1: 设置y的父节点
        y.parent = x.parent;
 
        if (x.parent == null) this.root = y;
        else if (x.parent.left == x) x.parent.left = y;
        else x.parent.right = y;

        //2-2: 设置y 的左节点
        y.left = x;
        x.parent = y;

        //2-3: y节点的右节点无变化
    }
旋转 - 右旋转的两种情况
          py                py         |              py                   py           
         /                 /           |               \                    \         
        y                 x            |                y        ->          x        
       / \        ->     / \           |               / \                  / \       
      x   ry           lx   y          |              x  ry               lx   y      
     / \                   / \         |             / \                      / \     
    lx rx                 rx  ry       |            lx rx                    rx  ry   

    // 对 y 进行右旋转, 将 y 是 x 的父节点 变成 x 是 y 的父节点                                                                                                                  
    private void rotateRight(RBTNode<T> y) {
        RBTNode<T> x = y.left;

        //1: 设置y 的左 父 右 节点
        //1-1: 设置y 的左节点, 并设置其父节点
        y.left = x.right;
        if (x.right != null) x.right.parent = y;

        //2-2: 设置x的父节点
        x.parent = y.parent;
        //1-3: y的右节点无变化

        //2: 设置x 的左 右 父节点

        //2-2: 设置x 的父节点, 及其父节点的子节点
        if (y.parent == null) this.root = x;
        else if (y == y.parent.right) y.parent.right = x;
        else y.parent.left = x;

        //2-1: 设置 x的右节点, 并设置其父节点
        x.right = y;
        //1-2: 设置y 的父节点
        y.parent = x;
        //2-3 x的左节点无变化
    }
插入并修正
  1. 若root 是null , 则插入节点就是root 节点.
  2. 若root 不是null, 则向下查找node 的父节点, 并根据与父节点的大小关系, 写入待插入节点. 插入的节点都是红色
  3. 修正插入的树.
  4. 修正过程, 修正的核心思想是: 将红色节点移动到根节点, 将根节点设为黑色.
违背原则4现象说明处理策略
情况1isRed(parent), isRed(uncle)1. setBlack(parent);
2. setBlack(uncle);
3. setRed(grandParent);
4. current = grandParent;
5. 检测 current 是否违背原则并处理
情况2isRed(parent), isBlack(uncle), uncle == grandParent.left, current == parent.right1. setBlack(parent);
2. setRed(grandParent);
3. rotateLeft(grandParent);
情况3isRed(parent), isBlack(uncle), uncle == grandParent.left, current == parent.left1. current = parent;
2. rotateRight(current);
3. 检测 current 是否违背原则并处理
情况4isRed(parent), isBlack(uncle), uncle == grandParent.right, current == parent.right1. current = parent;
2. rotateLeft(current);
3. 检测 current 是否违背原则并处理
情况5isRed(parent), isBlack(uncle), uncle == grandParent.right, current == parent.left1. setBlack(parent);
2. setRed(grandParent);
3. rotateRight(grandParent);

    // 插入修正
    private void insertFix(RBTNode<T> node) {
        RBTNode<T> parent;
        RBTNode<T> grandParent;
        while (isRed(parentOf(node))) {
            parent = parentOf(node);
            grandParent = parentOf(parent);
            RBTNode<T> uncle;
            if (parent == grandParent.left) {
                uncle = grandParent.right;
                if (isRed(uncle)) {  // 情况 1
                    setBlack(parent);
                    setBlack(uncle);
                    setRed(grandParent);
                    node = grandParent;
                    continue;
                }
                if (isBlack(uncle)) {
                    if (parent.right == node) { // 情况 4
                        node = parent;
                        rotateLeft(grandParent);
                    } else { // 情况 5
                        setBlack(parent);
                        setRed(grandParent);
                        rotateRight(grandParent);
                    }
                }
            } else {
                uncle = grandParent.left;
                if (isRed(uncle)) { // 情况 1
                    setBlack(uncle);
                    setBlack(parent);
                    setRed(grandParent);
                    node = grandParent;
                    continue;
                }
                if (isBlack(uncle)) {
                    if (parent.left == node) { // 情况 2
                        node = parent;
                        rotateRight(node);
                    } else { // 情况 3
                        setBlack(parent);
                        setRed(grandParent);
                        rotateLeft(grandParent);
                    }
                }
            }
        } 
    }   

    // 插入
    public void insert(RBTNode<T> node) {
        if (this.root == null) {
            this.root = node;
        } else {
            int compare = 0;
            RBTNode<T> temp = null;
            RBTNode<T> current = this.root;

            //1. 先查找二叉树, 确定node的插入位置
            while (current != null) {
                temp = current;
                compare = node.getKey().compareTo(current.getKey());
                if (compare < 0) current = current.getLeft(); 
                else current = current.getRight(); 
            }

            node.setParent(temp);
            compare = node.getKey().compareTo(temp.getKey());
            if (compare < 0) temp.setLeft(node);
            else temp.setRight(node);
        } 
        insertFix(node);
        setBlack(root);
    }
删除并修正
  1. 核心思想: 将被删节点所包含的额外黑色节点(右节点)不断往根节点方向移动并按照情况修正
  2. 修正的方法
情况现象说明处理策略
情况1isRed(current)&&isBlack(brother) or isRed(brother)&&isBlack(current)1. setBlack(current);
2. 执行核心思想移动其子节点
情况2isBlack(current) isBlack(brother) current==root执行核心思想移动子节点
情况3isBlack(current) isBlack(brother) current!=root执行下面4中情况
情况3-1isRed(brother)1. setBlack(brother);
2. setRed(parent);
3. rotateLeft(parent);
4. 重新设置current的brother
情况3-2isBlack(brother), isBlack(brother.left), isBlack(brother.right)1. setRed(brother);
2. current = parent
情况3-3isBlack(brother), isBlack(brother.right), isRed(brother.left)1. setBlack(brother.left);
2. setRed(brother);
3. rotateRight(brother);
4. 重新设置current的brother
情况3-4isBlack(brother), isRed(brother.right)1. brother.color = parent.color;
2. setBlack(parent);
3. setBlack(brother.right);
4. rotateLeft(brother);
5. root = x

完整实现

public class RBTree<T extends Comparable<T>> {

    private RBTNode<T> root;

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

    private void preOrder(RBTNode<T> node) {
        if (node != null) {
            System.out.println(node + " ");
            preOrder(node.left);
            preOrder(node.right);
        }
    }

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

    private void inOrder(RBTNode<T> node) {
        if (node != null) {
            inOrder(node.left);
            System.out.println(node.toString());
            inOrder(node.right);
        }
    }

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

    private void postOrder(RBTNode<T> node) {
        if (node != null) {
            preOrder(node.left);
            preOrder(node.right);
            System.out.println(node + " ");
        }
    }

    public void insert(T key) {
        insert(new RBTNode<T>(key, null, null, null, false));
    }

    private void insert(RBTNode<T> node) { 
    }

    private RBTNode<T> parentOf(RBTNode<T> x) {
        return (x == null ? null : x.parent);
    }

    private boolean isRed(RBTNode<T> x) {
        if (x == null) return false;
        return !x.isBlack;
    }

    private boolean isBlack(RBTNode<T> x) {
        return (x == null || x.isBlack);
    }

    private void setRed(RBTNode<T> x) {
        if (x != null)
            x.isBlack = false;
    }

    private void setBlack(RBTNode<T> x) {
        if (x != null)
            x.isBlack = true;
    }

    private void insertFix(RBTNode<T> node) { 
    }

    private void rotateRight(RBTNode<T> y) {
    }

    private void rotateLeft(RBTNode<T> x) { 
    }

    public void remove(RBTNode<T> node) {
    }
}

//测试代码
public static void main(String[] args) {
        RBTree<Integer> tree = new RBTree<>();
        int[] arr = new int[]{9, 8, 3, 5, 4, 2, 7, 6, 1};
        for (int item : arr)
            tree.insert(9);
        System.out.println("前序");
        tree.preOrder();
        System.out.println("----------------------");
        System.out.println("中序");
        tree.inOrder();
        System.out.println("----------------------");
        System.out.println("后序");
        tree.postOrder();
    }

// 前序
// key: 8 B  
// key: 4 R 8 Left 
// key: 2 B 4 Left 
// key: 1 R 2 Left 
// key: 3 R 2 Right 
// key: 6 B 4 Right 
// key: 5 R 6 Left 
// key: 7 R 6 Right 
// key: 9 B 8 Right 
// ----------------------
// 中序
// key: 1 R 2 Left
// key: 2 B 4 Left
// key: 3 R 2 Right
// key: 4 R 8 Left
// key: 5 R 6 Left
// key: 6 B 4 Right
// key: 7 R 6 Right
// key: 8 B 
// key: 9 B 8 Right
// ----------------------
// 后序
// key: 4 R 8 Left 
// key: 2 B 4 Left 
// key: 1 R 2 Left 
// key: 3 R 2 Right 
// key: 6 B 4 Right 
// key: 5 R 6 Left 
// key: 7 R 6 Right 
// key: 9 B 8 Right 
// key: 8 B

参考文献

  1. https://sandbox.runjs.cn/show/2nngvn8w
  2. http://www.cnblogs.com/skywang12345/p/3624343.html
  3. http://www.cnblogs.com/skywang12345/p/3245399.html
朝夕夕夕夕
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅析红黑树底层原理及实现
qq_39344902的博客
08-12 4266
我们在上一篇博客认识到了平衡二叉树(AVLTree)，了解到平衡二叉树的性质，其实平衡二叉树最大的作用就是查找,AVL树的查找、插入和删除在平均和最坏情况下都是O(logn)。AVL树的效率就是高在这个地方。如果在AVL树中插入或删除节点后，使得高度之差大于1。此时，AVL树的平衡状态就被破坏，它就不再是一棵二叉树；为了让它重新维持在一个平衡状态，就需要对其进行旋转处理, 现在呢，我们来思考一下虽...
红黑树初解
qq_35540164的博客
08-22 759
红黑树初解 今天来复习一下红黑树的知识点，推荐51CTO这个微信公众号。 学过数据结构都知道二叉树的概念，而又有多种比较常见的二叉树类型，比如完全二叉树、满二叉树、二叉搜索树、均衡二叉树、完美二叉树等。 今天我们要说的红黑树就是就是一棵非严格均衡的二叉树，均衡二叉树又是在二叉搜索树的基础上增加了自动维持平衡的性质，插入、搜索、删除的效率都比较高。红黑树也是实现 TreeMap 存储结构的基石。 二...
红黑树的实现原理和应用场景
2301_77783312的博客
05-19 885
对每个结点，从该结点到其子孙结点的所有路径上包含相同数目的黑结点。）如果一个结点是红的，那么它的俩个儿子都是黑的。有如图所示的表，现在希望查询的结果将列成行。每个虚拟地址区域都对应红黑树的一个节点。）每个结点要么是红的，要么是黑的。左指针指向相邻的地址 虚拟存储区域。右指针指向相邻的高地址虚拟地址空间。可以很快的得到距离当前最小的定时器。）每个叶结点，即空结点是黑的。进程的虚拟内存 区域都。的实现采用红黑树组织管理。一棵自平衡的排序二叉树。用红黑树管理进程控制块。，以支持快速的增删改查。
红黑树的由来，特性，原理以及适用场景分析
Alan-zzx的博客
11-16 2819
注意：本文不涉及红黑树的具体实现，并且默认读者已经对二叉树，二叉查找树，AVL树等已经了解并熟悉。 一、平衡二叉查找树 定义：树中任意一个节点的左右子树高度差不大于1。 AVL树是一种严格按照定义来实现的平衡二叉查找树，所以，它的查找效率非常稳定，是O(log n)，由于严格按照左右子树高度差不大于一的规则，插入和删除操作中需要大量的操作来保持树的平衡，比较耗时。 因此，AVL树适用于大量查询，少...
【数据结构】红黑树实现详解
最新发布
EWIAW_ilove的博客
06-17 736
红黑树是一棵二叉搜索树，它的结点不是黑的就是红的，其中它有一个非常重要的通过对任何一条从根到叶子的路径上各个结点的着色控制，保证了红黑树没有一条路径会比最短路径长出两倍，达到接近平衡的特点。看到这句话，可能你还云里雾里的，但是不要怕，简单的来说，红黑树的特点就是：找出树中最短的路径和最长的路径，其中这条最长路径的长度不会大于最短路径长度的两倍。如下图所示：在这棵红黑树中，最短的路径是最左边的那条，长度为3，最长的路径是最右边的那条，长度为4，即4 < 2*3，最长的路径不会大于最短路径的两倍。
深入理解数据结构——红黑树
haha与长颈鹿的博客
12-04 242
本篇文章深入讲述红黑树的原理与实现。红黑树是一个非常重要的数据结构，也是面试中的常考知识点。其本质上是一个平衡搜索树，可是其“平衡”的条件和AVL树不同。在深入了解红黑树之前要先熟悉平衡搜索树的相关知识，这里就不再介绍。
数据结构 - 红黑树原理及其在Java中的应用
尘世中迷途小码农的专栏
03-15 683
简介 红黑树又名Red Black Tree（RBT），是一种平衡二叉查找树，每个节点都有颜色，要么红色要么黑色。有以下性质： 根节点是黑色 叶子节点都是不存储数据的黑色空节点 红色节点的儿子节点都是黑色 任何一个节点到其所有叶子节点路径上的黑色节点数相同 注意： 特性2中的叶子节点，是只为空(NIL或null)的黑色节点，不存储任何数据。 特性3和4可以保证没有一条路径会比其他路径长出一倍，因为最坏情况就是某节点的一个子树的每个黑色节点中间都有一个红色节点，而另一个子树中全都是黑色节点。 下
深入解析红黑树（RB-Tree）：原理、操作及应用
无敌岩雀的博客
03-17 1681
红黑树作为一种自平衡的二叉搜索树，在计算机科学领域中占据着重要的地位。它的设计旨在在维持树的平衡性的同时，保证各种操作的时间复杂度始终稳定在较低水平。红黑树的灵活性和高效性使得它成为众多编程语言和系统实现中不可或缺的数据结构之一。本文将带领读者深入探究红黑树的结构与原理。（c++实现）
红黑树的原理与应用
m0_73811154的博客
04-09 361
它通过保持一些特定的性质来保证树的平衡，从而具有快速的查找、插入和删除操作，时间复杂度通常为O(log n)。它需要维护节点的颜色信息，因此在内存使用方面比普通二叉搜索树更加耗费空间，同时插入和删除节点时需要进行旋转操作，时间复杂度相对较高。本文将介绍红黑树的原理，包括定义、性质以及旋转操作，并探讨红黑树在实际应用中的优缺点。在插入和删除节点时，可能会破坏红黑树的平衡，需要进行旋转操作来重新平衡树。总之，红黑树是一种非常实用的数据结构，具有自平衡和快速操作的优点，在实际应用中被广泛使用。
红黑树: 理论与实现
04-19
红黑树是一种很有意思的平衡检索树。它的统计性能要好于平衡二叉树(有些书籍根据作者姓名，Adelson-Velskii和Landis，将其称为AVL-树)，因此，红黑树在很多地方都有应用。在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操作的支持)。
红黑树的应用及原理(干货)
weixin_34764432的博客
08-03 2016
介绍： 红黑树是应用很广泛的一种数据结构，主要得益于其查找的性能以及
红黑树的实现与应用
09-03
用C语言写的基于红黑树实现的图书管理系统，数据结构课程设计，压缩包里边包括设计的程序和设计说明书。在图书管理系统中, 当图书的数量非常大时, 那么查找效率就会明显变低, 此时采用 一些优化手段就非常必要。采用红黑树这种数据结构来提高系统性能。......因为红黑树的查找效率高, 所以此方法可以提高系统性能。
红黑树与AVL树 数据结构高级篇
02-13
红黑树与AVL树 数据结构高级篇
红黑树的原理及实现
菊头蝙蝠的博客
03-26 3291
红黑树一、 一、
红黑树的实现原理和场景
荣山的博客
12-14 340
红黑树的实现原理和场景
红黑树基本原理和简单实现
qq_59535638的博客
06-01 402
红黑树的基本性质，插入情况的详细分析与简单实现
二叉搜索树：红黑树的原理和实现
Pursue quality, not quantity.
03-30 1103
程序员的“浪漫”——手撕红黑树
红黑树的原理及实现（TypeScript）
weixin_43930923的博客
04-04 1029
前言：找博客学习红黑树，发现有些比较晦涩难懂，有些讲的不清不楚。幸运地在B站找到一部视频，按照算法导论讲的例子，听懂了。所以好的教材挺重要的。 然后决定自己写一篇博客讲解一下我的理解和实现，希望能帮助到有需要的小伙伴。 视频链接：1小时搞定红黑树_哔哩哔哩_bilibili，感兴趣的可以去看看 抱歉，写完之后发现图里的树画得不严谨，不完整，看上去不是平衡的，但是我也懒得改了。请大家主要考虑情况和解决方案即可。可自行画一个完整的红黑树，再按照...
红黑树的实现原理和应用场景；
11-22
红黑树是一种自平衡二叉搜索树，它在二叉搜索树的基础上增加了颜色约束，确保树的高度在最坏情况下保持O(log n)，从而实现高效的查找、插入和删除操作。红黑树的实现原理如下： 1.每个节点要么是红色，要么是黑色。 2.根节点是黑色的。 3.每个叶子节点（NIL节点，空节点）是黑色的。 4.如果一个节点是红色的，则它的两个子节点都是黑色的。 5.对于每个节点，从该节点到其所有后代叶子节点的简单路径上，均包含相同数目的黑色节点。 红黑树的应用场景包括但不限于： 1.在Java集合框架中，TreeMap和TreeSet都是基于红黑树实现的，用于实现有序映射和有序集合。 2.在Linux内核中，红黑树被广泛应用于进程调度、文件系统以及网络协议栈等方面。 3.在数据库索引中，红黑树也是一种常见的数据结构，用于实现高效的索引查找。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值