红黑树原理与代码

已于 2023-02-06 14:32:52 修改
阅读量314 收藏
点赞数
分类专栏： 数据结构 文章标签： 算法 数据结构
于 2023-02-06 14:29:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44316314/article/details/128901002
版权

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。
通过任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。
红黑树不追求绝对平衡，只需保证最长路径不超过最短路径的2倍，相对而言，降低了平衡时旋转的次数，所以在经常进行增删的结构中性能比AVL树更优。

红黑树的性质:
性质1：每个节点要么是黑色，要么是红色。
性质2：根节点是黑色。
性质3：每个叶子节点是黑色。
性质4：每个红色节点的两个子节点一定都是黑色。不能有两个红色节点相连。
性质5：任意一节点到每个叶子节点的路径都包含数量相同的黑结点。俗称：黑高！
从性质5又可以推出：如果一个节点存在黑色子节点，那么该结点肯定有两个子节点
左子树和右子树的黑结点的层数是相等的，也即任意一个结点到到每个叶子结点的路径都包含数量相同的黑结点(性质5)。所以我们叫红黑树这种平衡为黑色完美平衡。

红黑树能保持这些性质，它靠的是什么？三种操作：左旋、右旋和变色。
1.变色：结点的颜色由红变黑或由黑变红。
2.左旋：以某个结点作为支点(旋转结点)，其右子结点变为旋转结点的父结点，右子结点的左子结点变为旋转结点的右子结点，左子结点保持不变。
3.右旋：以某个结点作为支点(旋转结点)，其左子结点变为旋转结点的父结点，左子结点的右子结点变为旋转结点的左子结点，右子结点保持不变。

插入后修复红黑树平衡的方法

  • 情景1：红黑树为空树,根节点变成黑色即可
  • 情景2：插入节点的key已经存在,不用处理
  • 情景3：插入节点的父节点为黑色,不用处理
  • 情景4：插入节点的父节点为红色
    • 情景4.1：叔叔节点存在，并且为红色（父-叔 双红）。将叔父节点变黑，爷爷节点变红，继续对爷爷节点进行处理
    • 情景4.2：叔叔节点不存在，或者为黑色，父节点为爷爷节点的左子树
      • 情景4.2.1：插入节点为其父节点的左子节点（LL情况），父节点变黑，爷爷节点变红，右旋爷爷节点。
      • 情景4.2.2：插入节点为其父节点的右子节点（LR情况），左旋（父节点），当前节点设置为父节点，变成LL情况处理。
    • 情景4.3：叔叔节点不存在，或者为黑色，父节点为爷爷节点的右子树
      • 情景4.3.1：插入节点为其父节点的右子节点（RR情况）,父节点变黑，爷爷节点变红，左旋爷爷节点。
      • 情景4.3.2：插入节点为其父节点的左子节点（RL情况），右旋（父节点），当前节点设置为父节点，变成RR情况处理。
/**
 * ①创建RBTree，定义颜色
 * ②创建RBNode
 * ③辅助方法定义：parentOf(node)，isRed(node)，setRed(node)，setBlack(node)，inOrderPrint(RBNode tree)
 * ④左旋方法定义：leftRotate(node)
 * ⑤右旋方法定义：rightRotate(node)
 * ⑥公开插入接口方法定义：insert(K key, V value);
 * ⑦内部插入接口方法定义：insert(RBNode node);
 * ⑧修正插入导致红黑树失衡的方法定义：insertFIxUp(RBNode node);
 * ⑨测试红黑树正确性
 *
 *
 * @author 巍巍老师
 * @since 1.0.0
 */
public class RBTree <K extends Comparable<K>, V> {
    //定义颜色常量
    private static final boolean RED = true;
    private static final boolean BLACK = false;

    //红黑树的树根
    private RBNode root;

    public RBNode getRoot() {
        return root;
    }

    /**
     * 公开的插入接口
     * @param key 键
     * @param value 值
     */
    public void insert(K key, V value) {
        RBNode node = new RBNode();
        node.setKey(key);
        node.setValue(value);
        node.setColor(RED);
        insert(node);
    }

    /**
     * 内部插入接口定义
     */
    private void insert(RBNode node) {
        //1.找到插入的位置
        RBNode parent = null;
        RBNode x = this.root;   // 从根开始找
        while(x != null) {
            parent = x;
            //a > b 则返回 1，否则返回 -1 ，相等返回0
            int cmp = node.key.compareTo(parent.key);
            if(cmp < 0) {
                x = x.left;
            } else if(cmp == 0) {
                parent.setValue(node.value);   // 相等直接设置value即可
                return;
            } else {
                x = x.right;
            }
        }
        node.parent = parent;
        if(parent != null) {
            if(node.key.compareTo(parent.key) < 0) {   // 看看放左边还是右边
                parent.left = node;
            } else {
                parent.right = node;
            }
        } else {
            this.root = node;   // 父节点为空,说明创建的是根
        }
        //插入之后需要进行修复红黑树，让红黑树再次平衡。
        insertFixUp(node);
    }


    /**
     * 插入后修复红黑树平衡的方法
     *     |---情景1：红黑树为空树,根节点变成黑色即可
     *     |---情景2：插入节点的key已经存在,不用处理
     *     |---情景3：插入节点的父节点为黑色,不用处理
     *
     *     情景4 需要咱们去处理
     *     |---情景4：插入节点的父节点为红色
     *          |---情景4.1：叔叔节点存在，并且为红色（父-叔 双红）
     *          |---情景4.2：叔叔节点不存在，或者为黑色，父节点为爷爷节点的左子树
     *               |---情景4.2.1：插入节点为其父节点的左子节点（LL情况）
     *               |---情景4.2.2：插入节点为其父节点的右子节点（LR情况）
     *          |---情景4.3：叔叔节点不存在，或者为黑色，父节点为爷爷节点的右子树
     *               |---情景4.3.1：插入节点为其父节点的右子节点（RR情况）
     *               |---情景4.3.2：插入节点为其父节点的左子节点（RL情况）
     */
    private void insertFixUp(RBNode node) {
        RBNode parent = parentOf(node);
        RBNode gparent = parentOf(parent);
        //存在父节点且父节点为红色
        if(isRed(parent)) {
            //父节点是红色的，那么一定存在爷爷节点
            //父节点为爷爷节点的左子树
            if(parent == gparent.left) {
                RBNode uncle = gparent.right;
                //4.1：叔叔节点存在，并且为红色（父-叔 双红）
                //将父和叔染色为黑色，再将爷爷染红，并将爷爷设置为当前节点，进入下一次循环判断
                if(isRed(uncle)) {
                    setBlack(parent);
                    setBlack(uncle);
                    setRed(gparent);
                    insertFixUp(gparent);
                    return;
                }
                //叔叔节点不存在，或者为黑色，父节点为爷爷节点的左子树
                if(uncle == null || isBlack(uncle)) {
                    //插入节点为其父节点的右子节点（LR情况）=>
                    //左旋（父节点），当前节点设置为父节点，进入下一次循环
                    if(node == parent.right) {
                        leftRotate(parent);
                        insertFixUp(parent);
                        return;
                    }
                    //插入节点为其父节点的左子节点（LL情况）=>
                    //变色（父节点变黑，爷爷节点变红），右旋爷爷节点
                    if(node == parent.left) {
                        setBlack(parent);
                        setRed(gparent);
                        rightRotate(gparent);
                    }
                }

            } else {//父节点为爷爷节点的右子树
                RBNode uncle = gparent.left;
                //4.1：叔叔节点存在，并且为红色（父-叔 双红）
                //将父和叔染色为黑色，再将爷爷染红，并将爷爷设置为当前节点，进入下一次循环判断
                if(uncle != null && isRed(uncle)) {
                    setBlack(parent);
                    setBlack(uncle);
                    setRed(gparent);
                    insertFixUp(gparent);
                    return;
                }

                //叔叔节点不存在，或者为黑色，父节点为爷爷节点的右子树
                if(uncle == null || isBlack(uncle)) {
                    //插入节点为其父节点的左子节点（RL情况）
                    //右旋（父节点）得到RR情况，当前节点设置为父节点，进入下一次循环
                    if(node == parent.left) {
                        rightRotate(parent);
                        insertFixUp(parent);
                        return;
                    }

                    //插入节点为其父节点的右子节点（RR情况）=>
                    //变色（父节点变黑，爷爷节点变红），右旋爷爷节点
                    if(node == parent.right) {
                        setBlack(parent);
                        setRed(gparent);
                        leftRotate(gparent);
                    }
                }

            }
        }
        setBlack(this.root);
    }


    /**
     * 左旋方法
     * 左旋示意图：左旋x节点
     *    p                   p
     *    |                   |
     *    x                   y
     *   / \         ---->   / \
     *  lx  y               x   ry
     *     / \             / \
     *    ly  ry          lx  ly
     *
     * 左旋做了几件事？
     * 1.将y的左子节点赋值给x的右边，并且把x设置为y的左子节点的父节点
     * 2.将x的父节点（非空时）指向y，更新y的父节点为x的父节点
     * 3.将y的左子节点指向x，更新x的父节点为y
     */
    private void leftRotate(RBNode x) {
        RBNode y = x.right;
        //将y的左子节点赋值给x的右边
        x.right = y.left;
        //并且把x设置为y的左子节点的父节点
        if(y.left != null) {
            y.left.parent = x;
        }

        //将x的父节点（非空时）指向y
        if(x.parent != null) {
            //如果x是parent左子树，则把y安放到parent的左边
            if(x.parent.left == x) {
                x.parent.left = y;
            } else {//否则把y安放到parent的右边
                x.parent.right = y;
            }
            //更新y的父节点为x的父节点
            y.parent = x.parent;
        } else {
            this.root = y;
            this.root.parent = null;
        }

        y.left = x;
        x.parent = y;
    }


    /**
     * 右旋方法
     * 右旋示意图：右旋y节点
     *
     *    p                       p
     *    |                       |
     *    y                       x
     *   / \          ---->      / \
     *  x   ry                  lx  y
     * / \                         / \
     *lx  ly                      ly  ry
     *
     * 右旋都做了几件事？
     * 1.将x的右子节点 赋值 给了 y 的左子节点，并且更新x的右子节点的父节点为 y
     * 2.将y的父节点（不为空时）指向x，更新x的父节点为y的父节点
     * 3.将x的右子节点指向y，更新y的父节点为x
     */
    private void rightRotate(RBNode y) {
        //1.将x的右子节点赋值给y的左子节点，并将y赋值给x右子节点的父节点（x右子节点非空时）
        RBNode x = y.left;
        y.left = x.right;
        if(x.right != null) {
            x.right.parent = y;
        }

        //2.将y的父节点p（非空时）赋值给x的父节点，同时更新p的子节点为x（左或右）
        x.parent = y.parent;

        if(y.parent != null) {
            if(y.parent.left == y) {
                y.parent.left = x;
            } else {
                y.parent.right = x;
            }
        } else {
            this.root = x;
            this.root.parent = null;
        }

        //3.将x的右子节点赋值为y，将y的父节点设置为x
        x.right = y;
        y.parent = x;
    }


    /**
     * 获取当前节点的父节点
     */
    private RBNode parentOf(RBNode node) {
        if(node != null) {
            return node.parent;
        }
        return null;
    }

    /**
     * node节点是否为红色
     * @return boolean true 表示是红色  false 表示不是红色
     */
    private boolean isRed(RBNode node) {
        if(node != null) {
            return node.isColor() == RED;
        }
        return false;
    }

    /**
     * 设置节点为红色
     */
    private void setRed(RBNode node) {
        if(node != null) {
            node.setColor(RED);
        }
    }

    /**
     * 设置节点为黑色
     */
    private void setBlack(RBNode node) {
        if(node != null) {
            node.setColor(BLACK);
        }
    }

    /**
     * 中序打印，可以将二叉查找树有顺序的打印出来
     */
    public void inOrderPrint() {
        if(this.root != null) {
            inOrderPrint(this.root);
        }
    }

    private void inOrderPrint(RBNode node) {
        if(node != null) {
            inOrderPrint(node.left);
            System.out.println("key -> " + node.key + ", value -> " + node.value);
            inOrderPrint(node.right);
        }
    }


    /**
     * node节点是否为黑色
     * @return boolean true 表示是黑色  false 表示不是黑色
     */
    private boolean isBlack(RBNode node) {
        if(node != null) {
            return node.isColor() == BLACK;
        }
        return false;
    }




    /**
     * 红黑树Node
     */
    static class RBNode<K extends Comparable<K>, V> {
        //颜色
        private boolean color;
        //左子节点
        private RBNode left;
        //右子节点
        private RBNode right;
        //父节点
        private RBNode parent;
        //key
        private K key;
        //value
        private V value;

        public RBNode(boolean color, RBNode left, RBNode right, RBNode parent, K key, V value) {
            this.color = color;
            this.left = left;
            this.right = right;
            this.parent = parent;
            this.key = key;
            this.value = value;
        }

        public RBNode() {
        }

        public boolean isColor() {
            return color;
        }

        public void setColor(boolean color) {
            this.color = color;
        }

        public RBNode getLeft() {
            return left;
        }

        public void setLeft(RBNode left) {
            this.left = left;
        }

        public RBNode getRight() {
            return right;
        }

        public void setRight(RBNode right) {
            this.right = right;
        }

        public RBNode getParent() {
            return parent;
        }

        public void setParent(RBNode parent) {
            this.parent = parent;
        }

        public K getKey() {
            return key;
        }

        public void setKey(K key) {
            this.key = key;
        }

        public V getValue() {
            return value;
        }

        public void setValue(V value) {
            this.value = value;
        }
    }


    /*****************************************************************************
     * Print Method
     *****************************************************************************/



    public void padding ( String ch, int n ) {
        int i;
        for ( i = 0; i < n; i++ )
            System.out.printf(ch);

    }

    void print_node (RBNode root, int level ) {
        if ( root == null ) {
            padding ( "\t", level );
            System.out.println( "NIL" );

        } else {
            print_node ( root.right, level + 1 );
            padding ( "\t", level );
            if(root.color == BLACK) {
                System.out.printf(root.key + "(" + (root.isColor() ? "红" : "黑") +")" + "\n");
            } else
                System.out.printf(root.key  + "(" + (root.isColor() ? "红" : "黑") +")" + "\n");
            print_node ( root.left, level + 1 );
        }
    }

    void print_tree() {
        print_node(this.root,0);
        System.out.printf("-------------------------------------------\n");
    }
}
run around
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树demo python代码
07-12
对于初学者来说，理解这些代码可以帮助深入理解红黑树的工作原理。通过阅读代码，你可以学习如何在实际编程中应用红黑树的平衡策略，这对于理解和优化数据结构和算法的性能至关重要。同时，这也有助于提升对二叉树和...
红黑树代码
05-07
通过阅读和分析这段代码，可以深入理解红黑树的工作原理及其在实际编程中的应用。 总的来说，红黑树是计算机科学中重要的数据结构之一，理解和掌握其原理对于提升编程能力，尤其是处理动态数据集时的性能优化至关...
红黑树的原理及代码实现
最新发布
qq_52093121的博客
06-28 983
红黑树的原理这篇博文讲解的很详细了，不熟悉红黑树的定义可以看看：红黑树的详细原理讲解咱们直接进入代码实现讲解：创建一棵红黑树，先从创建红黑树的节点开始： 1.红黑树首先是一个二叉树，所以需要一个左儿子节点的指针，右儿子节点的指针 2.红黑树是有BALCK和RED两种颜色的，所以每个节点应该有颜色 3.红黑树是Key-Value存储的 4.因为之后要进行旋转等调整，所以还需要一个父节点的信息 所以红黑树节点定义如下： 2.创建红黑树整体结构 红黑树有五个性质： 为了方便整棵红黑树的维护，我们默认叶子节点是空
红黑树原理详解及代码实现
CodePanda@GPF的博客
05-23 2638
红黑树原理及代码实践
对红黑树的认识总结
热门推荐
张彦峰的博客
05-12 170万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
红黑树原理讲解
冲冲冲的博客
10-23 1045
红黑树原理讲解 |—红黑树的性质 |—红黑树有几种变化策略？（为满足红黑树性质） |—改变颜色 |—左旋 |—右旋 |—红黑树的查找 |—红黑树的插入 |—情景1：红黑树为空树 |—情景2：插入节点的key已经存在 |—情景3：插入节点的父节点为黑色 |—情景4：插入节点的父节点为红色 |—情景4.1：叔叔节点存在，并且为红色（父-叔 双红） |—情景4.2：叔叔节点不存在，或者为黑色，父节点为爷爷节点的左子树 |—情景4.2.1：插入节点为其父节点的左子节点（LL情况） |—情景4.2.2：插入节点为其父
红黑树原理及代码实现（一）
旧时明月丶
08-31 745
红黑树简介 红黑树是一种自平衡的二叉查找树，它的统计性能要优于平衡二叉树，因此在很多地方都有应用，例如Java中的TreeMap，HashMap等数据结构都使用到了红黑树。红黑树对很多人来说熟悉而陌生，熟悉则是因为知道红黑树在很多场景中有使用，但又对其原理很陌生或者一知半解。今天就来剖析一下红黑树原理 红黑树是一种二叉查找树，但是它在二叉查找树基础上增加了着色和相关的性质使得其相对平衡，从而保证了红黑树的查找、插入、删除的时间复杂度最坏为O(log n)。红黑树具备以下5个性质： 1.每个节点要么是黑色，要
HashMap底层红黑树原理（超详细图解）+手写红黑树代码
wenwenaier的博客
11-24 1万+
在看完了小刘老师和黑马的源码视频之后,我整理了一篇HashMap的底层源码文章，学海无涯，这几天看了对红黑树的讲解，故将其整理出来 HashMap底层源码解析上 HashMap底层源码解析下 视频链接 小刘老师讲源码 传智播客-黑马程序员 文章目录红黑树什么是树 红黑树 什么是树 树(tree)是一种抽象数据类型（ADT），用来模拟具有树状结构性质的数据集合，它是由n（n>0）个有限节点通过连接它们的边组成一个具有层次关系的集合。把它叫做“树”是因为他看起来像一颗倒挂的树，也就是说它是根朝上，而叶向
红黑树 图文详解与代码实现
qq_54831038的博客
09-01 996
红黑树被应用于数据结构map/set的封装的底层，也应用于Linux的数据内核，在进程调度CFS，虚拟内存管理，共享内存slab等场景都有广泛应用。数据结构的角度看，（1）用于存储。无论数据是否平衡都可以在O（logN)的复杂度下完成 搜索、插入、删除操作。（2）用于排序。找到最小值和最大值红黑树黑色和红色 也可看成两种状态，红黑区分的状态中，可以根据实际需求添加业务逻辑。......
红黑树实现代码+详细注释
ltrbless的博客
05-19 1549
简介 因为网上太多红黑树原理的讲解了，不需要再去讲解原理，所以在这就提供一些将原理不错的博客，然后主要是给红黑树代码的实现，用的c++语言模板实现红黑树，并附带详细注释。（目前只实现了红黑树的插入与查询操作，并可视化打印红黑树）。 红黑树插入操作的流程图：（参考：红黑树总结 - lukazan - 博客园 (cnblogs.com)，该博客用图详细解释了红黑树插入操作的事件，然后我用红色对其事件进行了编号，以便于和代码注释相对应） 红黑树的本质其实就是2-3树，在上面推荐的博客中也有提到。 代码
红黑树原理简单解析
黄沙客栈
08-19 9870
一、红黑树为什么会出现呢？ 是因为二叉搜索树有可能会出现极端的情况，就是只有一侧有数据，那这样的话就会降级为链表。后来出现了平衡二叉树，但是由于强制平衡所导致付出的代价比较高昂，所以黑红树出现了。 二、简介 红黑树（Red Black Tree） 的实现是基于二叉查找树的，对于含有n个节点的二叉查找树的最坏的情况是这n个节点形成一条单链，此时二叉查找树的高度为n，时间复杂度为O(n)。为了维持O(lg n)的运行时间，就需要采取一些措施在不影响二叉查找树的性质下改变二叉查找树的结构，使之平衡。红黑树就是这样
红黑树java操作代码 红黑树是java里面遍历性能最好数据结构
10-17
红黑树（Red-Black Tree）是一种自平衡二叉查找树，它在计算机...理解和掌握红黑树的原理和实现，对于提升Java开发人员的数据结构和算法能力具有重要意义。通过阅读和分析提供的代码，我们可以更好地理解和应用红黑树。
红黑树与区间树算法实现
04-08
总的来说，这个实验旨在让学习者深入理解红黑树和区间树的原理，以及如何在实际编程中应用它们。通过C++实现和graphviz的可视化，学生能够直观地看到数据结构的操作过程，这对于理解和掌握这些高级数据结构的概念至...
链表和红黑树测试代码
10-09
3. 测试代码：这部分可能演示了如何使用这些数据结构，如何创建和操作链表和红黑树，以及如何将它们编译为库以便在其他项目中复用。 学习这部分内容有助于深入理解Linux内核的工作原理，特别是涉及到内存管理和文件...
线段树分治
weixin_44316314的博客
01-20 1076
线段树分治是一种离线做法，处理的是某种修改对询问的影响，这种影响可以独立也可以不独立。 关键是把一个修改看成一个区间，每个询问是一个叶子。修改是在线段树上打标记。这里把询问看做一个时间点，而修改对应一个时间区间的修改。 做法：在线段树上记录要操作的时间区间，dfs依次执行这一操作，一直到根节点来回答询问，离开时将其撤销。 题目： 有两种操作，一种是将两个点连一条边，另一种就是询问这个点所在的连通块的点数，但是这个边的有效时间只有k天。每次操作过一天。 分析： 如果没有有效时间的话，就是并查集的裸题。那么一次
可持久化并查集
weixin_44316314的博客
08-29 1050
/* 可持久化并查集 并查集的本质就是数组,所以可持久化并查集就是可持久化数组 但是并查集的路径压缩不能用了,因为路径压缩会改变fa数组, 在可持久化里,改变就意味着log的空间复杂度,所以不用路径压缩, 改为秩优化,即将深度小的并到深度大的 所以需要维护两个可持久化数组,开两倍空间 */ #include <iostream> using namespace std; const int maxn = 2e5 + 5; int rootfa[maxn],rootdep[maxn],cn
权值线段树（序列第k大）
weixin_44316314的博客
02-03 933
权值线段树就是在线段树的基础上，将每一个点作为一个桶。区间l到r表示从[l…r]这个数值之间的信息。每个节点维护一个数值的数量，表示[l…r]这个区间有多少个数。 支持的操作： 添加一个元素 查找一个元素出现的次数 查找区间的元素个数 查询所有元素的第k大(小)元素 /* 权值线段树 在线段树的基础上，将每一个点作为一个桶。 区间l到r表示从[l...r]这个数值之间的信息。 每个节点维护一个数值...
线段树分裂与合并
weixin_44316314的博客
03-28 471
对于动态开点的线段树来说，当有很多棵线段树时，我们可以进行线段树合并，合并两棵线段树的复杂度为两棵线段树相同节点的数m*logm。 将y这棵线段树合并到x这棵线段树，对于x没有y有的节点，直接复制y的就行，x有y没有的不用管，都有的加起来即可。 void insert(int &now,int l,int r,int p,int v) //动态开点,将p位置的值加v { if( now == 0 ) now = ++cnt; if( l == r ) { a[now].maxt +=
无旋treap(fhq treap)
weixin_44316314的博客
02-26 336
普通平衡树 /* 无旋treap(fhq treap) treap是二叉搜索树结合二叉堆来的, 它保证树上任意节点,右节点值一定大于当前节点,儿子节点的索引一定小于父亲节点 对于任意一个点随机赋索引,这样的树就保证了随机,从而不会被卡链 无旋treap主要引入了分裂和合并两个操作,从而可用来处理很多问题 */ #include <iostream> #include <cstdlib> #include <ctime> using namespace std; c
hashmap的原理，红黑树
03-01
通过保持一些基本性质，如红色节点的两个子节点必须都是黑色节点，红黑树能够保证树的高度最多是2log(n+1)，其中n是树中节点的数量。 在Java中，HashMap使用哈希表来存储键值对，当哈希冲突发生时，会使用红黑树来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值