Java实现红黑树并绘制红黑树

最新推荐文章于 2024-09-18 16:34:34 发布
最新推荐文章于 2024-09-18 16:34:34 发布
阅读量328 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 红黑树 绘制二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29648139/article/details/124590909
版权

步骤一：实现红黑树

定义红黑树节点类

package rbtree;


import java.util.List;

public class RBTreeNode<T> {
    private T val;//值
    private boolean red;//是否为红
    private RBTreeNode<T> parentNode;//父节点
    private RBTreeNode<T> leftNode;//左节点
    private RBTreeNode<T> rightNode;//右节点
    public RBTreeNode() {
    }

    public RBTreeNode(T val, boolean red) {
        this.val = val;
        this.red = red;
    }


    public RBTreeNode(T val, boolean red, RBTreeNode<T> parentNode) {
        this.val = val;
        this.red = red;
        this.parentNode = parentNode;
    }

    public RBTreeNode(T val, boolean red, RBTreeNode<T> parentNode, RBTreeNode<T> leftNode, RBTreeNode<T> rightNode) {
        this.val = val;
        this.red = red;
        this.parentNode = parentNode;
        this.leftNode = leftNode;
        this.rightNode = rightNode;
    }

    public RBTreeNode<T> getParentNode() {
        return parentNode;
    }

    public void setParentNode(RBTreeNode<T> parentNode) {
        this.parentNode = parentNode;
    }

    public RBTreeNode<T> getLeftNode() {
        return leftNode;
    }

    public void setLeftNode(RBTreeNode<T> leftNode) {
        this.leftNode = leftNode;
    }

    public RBTreeNode<T> getRightNode() {
        return rightNode;
    }

    public void setRightNode(RBTreeNode<T> rightNode) {
        this.rightNode = rightNode;
    }

    public boolean isRed() {
        return red;
    }

    public void setRed(boolean red) {
        this.red = red;
    }

    public T getVal() {
        return val;
    }

    public void setVal(T val) {
        this.val = val;
    }

    /**
     * 中序遍历 左根右
     */
    public void middleIterator() {
        if(leftNode != null) {
            leftNode.middleIterator();
        }
        System.out.println(String.format("%s_%s",val,isRed() ? "R" :"B"));
        if(rightNode != null) {
            rightNode.middleIterator();
        }
    }

    /**
     * 中序遍历 并且计算出所有节点的位置坐标和连线
     * @param circularList 
     * @param lineList
     * @param coordinate
     * @return
     */
    public Coordinate middleIterator(List<Circular> circularList, List<Line> lineList, Coordinate coordinate) {
        int curY = coordinate.getCurY();
        if(leftNode != null) {
            coordinate.setCurY(curY + 1);
            coordinate = leftNode.middleIterator(circularList, lineList,coordinate);
            //当前节点-左节点
            lineList.add(new Line(coordinate.getCurX(),curY,coordinate.getNextX(),curY+1));
        }
        circularList.add(new Circular(coordinate.getCurX(),curY,String.valueOf(val),red));
        int curX = coordinate.getCurX();
        coordinate.setCurX(curX + 1);
        if(rightNode != null) {
            coordinate.setCurY(curY + 1);
            coordinate = rightNode.middleIterator(circularList, lineList,coordinate);
            //当前节点-右节点
            lineList.add(new Line(curX,curY,coordinate.getNextX(),curY+1));

        }
        coordinate.setNextX(curX);
        return coordinate;
    }


}

逻辑实现红黑树

package rbtree;


import java.util.List;


public class RBTree<T> {

    private RBTreeNode<T> root;

    /**
     * 添加节点
     * @param t
     */
    public void addNode(T t){
        //插入元素
        RBTreeNode insertNode = insertNode(t);
        if(insertNode == root){
            return;
        }
        //旋转或变色处理
        rotateOrChangeColor(insertNode);

    }

    /**
     * 旋转或变色处理
     * @param insertNode
     */
    private void rotateOrChangeColor(RBTreeNode insertNode){
        RBTreeNode<T> parentNode = insertNode.getParentNode();//父节点
        RBTreeNode<T> uncleNode = null;//叔父节点
        RBTreeNode<T> grandParentNode = null;//祖父节点
        //2.变色旋转
        while (parentNode != null){
            if(!parentNode.isRed()){
                //2.1.插入节点的父节点为黑色节点，则无需做任何操作
                return;
            }
            //获取祖父节点与叔父节点
            grandParentNode = parentNode.getParentNode();
            if(grandParentNode.getLeftNode() == parentNode){
                uncleNode = grandParentNode.getRightNode();
            }else{
                uncleNode = grandParentNode.getLeftNode();
            }
            if(uncleNode != null && uncleNode.isRed()){
                //2.2.父节点与叔父节点同色 变色处理即可
                //1) 父节点和叔父节点变为黑色
                parentNode.setRed(false);
                uncleNode.setRed(false);
                //2)祖父节点为根节点则无需做任何操作
                if(grandParentNode == root){
                    return;
                }
                //3)祖父节点设置为红色
                grandParentNode.setRed(true);
                //4)将祖父节点当成插入节点继续判断
                insertNode = grandParentNode;
                parentNode = grandParentNode.getParentNode();

            }else{
                //2.3插入节点的叔父节点为空或者黑色
                if(insertNode == parentNode.getLeftNode() && grandParentNode.getRightNode() == parentNode){
                    //插入节点为父节点的左节点且父节点为祖父节点的右节点 需要先右旋再左旋
                    rightRotate(insertNode);
                    leftRotate(insertNode);
                    return;
                }
                if(insertNode == parentNode.getLeftNode() && grandParentNode.getLeftNode() == parentNode){
                    //插入节点为父节点的左节点且父节点为祖父节点的左节点 只需要右旋一次
                    rightRotate(parentNode);
                    return;
                }
                if(insertNode == parentNode.getRightNode() && grandParentNode.getRightNode() == parentNode){
                    //插入节点为父节点的右节点且父节点为祖父节点的右节点 只需要左旋一次
                    leftRotate(parentNode);
                    return;
                }
                if(insertNode == parentNode.getRightNode() && grandParentNode.getLeftNode() == parentNode){
                    //插入节点为父节点的右节点且父节点为祖父节点的左节点 需要先左旋再右旋一次
                    leftRotate(insertNode);
                    rightRotate(insertNode);
                    return;
                }
            }
        }

    }

    /**
     * 将当前元素插入到红黑树中
     * @param t 元素
     * @return
     */
    private RBTreeNode insertNode(T t){
        //1.将当前节点插入到红黑树中
        if(root == null){
            //根节点必须为黑色节点
            root = new RBTreeNode<>(t,false);
            return root;
        }
        RBTreeNode<T> tempNode = root;//临时节点
        RBTreeNode<T> insertNode = null;//插入节点
        while (tempNode != null){
            if(t.hashCode() < tempNode.getVal().hashCode()){
                //如果插入节点值小于遍历节点值往左插入
                RBTreeNode<T> leftNode = tempNode.getLeftNode();
                if(leftNode == null){
                    //左节点为空赋值操作 插入节点父节点为遍历节点且颜色必须为红色，遍历节点左节点值赋值为插入节点
                    insertNode = new RBTreeNode<>(t, true, tempNode);
                    tempNode.setLeftNode(insertNode);
                    break;
                }
                //左节点不为空继续往下遍历
                tempNode = leftNode;
            }else{
                //如果插入节点值大于等于遍历节点值往右插入
                RBTreeNode<T> rightNode = tempNode.getRightNode();
                if(rightNode == null){
                    //右节点为空赋值操作 插入节点父节点为遍历节点且颜色必须为红色，遍历节点右节点值赋值为插入节点
                    insertNode = new RBTreeNode<>(t, true, tempNode);
                    tempNode.setRightNode(insertNode);
                    break;
                }
                //右节点不为空继续往下遍历
                tempNode = rightNode;
            }
        }
        return insertNode;
    }


    /**
     * 左旋
     * 旋转前 -> 当前节点为父节点的右节点
     * 旋转后 -> 父节点变为当前节点的左节点
     * @param curNode  当前节点--旋转轴点
     */
    private void leftRotate(RBTreeNode<T> curNode){
        //左旋一次处理
        RBTreeNode<T> parentNode = curNode.getParentNode();
        RBTreeNode<T> leftNode = curNode.getLeftNode();
        //1)存在祖父节点，则祖父节点的左/右节点为当前节点，否则说明祖父节点是根节点
        RBTreeNode<T> grandParentNode = parentNode.getParentNode();
        if(grandParentNode != null) {
            if(grandParentNode.getLeftNode() == parentNode){
                grandParentNode.setLeftNode(curNode);
            }else{
                grandParentNode.setRightNode(curNode);
            }
        }else{
            root = curNode;
        }
        //2)当前节点的现父节点为祖父节点 且左节点为原父节点 颜色变黑
        curNode.setParentNode(grandParentNode);
        curNode.setLeftNode(parentNode);
        curNode.setRed(false);
        //3)原父节点的现父节点为当前节点 且右节点为当前节点的原左节点 颜色变红
        parentNode.setParentNode(curNode);
        parentNode.setRightNode(leftNode);
        parentNode.setRed(true);
        //4)当前节点的原左节点的现父节点为当前节点的原父节点
        if(leftNode != null){
            leftNode.setParentNode(parentNode);
        }
    }

    /**
     * 右旋
     * 旋转前 -> 当前节点为父节点的左节点
     * 旋转后 -> 父节点变为当前节点的右节点
     * @param curNode  当前节点--旋转轴点
     */
    private void rightRotate(RBTreeNode<T> curNode){
        //右旋一次处理
        RBTreeNode<T> parentNode = curNode.getParentNode();
        RBTreeNode<T> rightNode = curNode.getRightNode();
        //1)存在祖父节点，则祖父节点的左/右节点为当前节点，否则说明祖父节点是根节点
         RBTreeNode<T> grandParentNode = parentNode.getParentNode();
        if(grandParentNode != null){
            if(grandParentNode.getLeftNode() == parentNode){
                grandParentNode.setLeftNode(curNode);
            }else{
                grandParentNode.setRightNode(curNode);
            }
        }else{
            root = curNode;
        }
        //2)当前节点的父节点为祖父节点 且右节点为原父节点 颜色变黑
        curNode.setParentNode(grandParentNode);
        curNode.setRightNode(parentNode);
        curNode.setRed(false);
        //3)原父节点的现父节点为当前节点 且左节点为当前节点的原右节点 颜色变红
        parentNode.setParentNode(curNode);
        parentNode.setLeftNode(rightNode);
        parentNode.setRed(true);
        //4)当前节点的原右节点的现父节点为当前节点的原父节点
        if(rightNode != null){
            rightNode.setParentNode(parentNode);
        }
    }

    public void iterator(){
        if(root == null){
            System.out.println("无节点元素");
            return;
        }
        System.out.println(String.format("根节点元素:%s",root.getVal()));
        root.middleIterator();
    }

    public void iterator(List<Circular> circularList, List<Line> lineList){
        if(root == null){
            System.out.println("无节点元素");
            return;
        }
        System.out.println(String.format("根节点元素:%s",root.getVal()));
        root.middleIterator(circularList,lineList,new Coordinate());
    }


}

步骤二：绘制红黑树

各节点坐标

package rbtree;


public class Circular {
    private int x;
    private int y;
    private String val;
    private boolean red;

    public Circular() {
    }

    public Circular(int x, int y, String val, boolean red) {
        this.x = x;
        this.y = y;
        this.val = val;
        this.red = red;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public String getVal() {
        return val;
    }

    public void setVal(String val) {
        this.val = val;
    }

    public boolean isRed() {
        return red;
    }

    public void setRed(boolean red) {
        this.red = red;
    }
}

节点与节点之间连线关系

package rbtree;


public class Line {
    private int x1;
    private int y1;
    private int x2;
    private int y2;

    public Line() {
    }

    public Line(int x1, int y1, int x2, int y2) {
        this.x1 = x1;
        this.y1 = y1;
        this.x2 = x2;
        this.y2 = y2;
    }

    public int getX1() {
        return x1;
    }

    public void setX1(int x1) {
        this.x1 = x1;
    }

    public int getY1() {
        return y1;
    }

    public void setY1(int y1) {
        this.y1 = y1;
    }

    public int getX2() {
        return x2;
    }

    public void setX2(int x2) {
        this.x2 = x2;
    }

    public int getY2() {
        return y2;
    }

    public void setY2(int y2) {
        this.y2 = y2;
    }

    @Override
    public String toString() {
        return "Line{" +
                "x1=" + x1 +
                ", y1=" + y1 +
                ", x2=" + x2 +
                ", y2=" + y2 +
                '}';
    }
}

中序遍历（递归遍历）临时坐标

package rbtree;

public class Coordinate {
    private int nextX;//下一遍历的节点的X坐标
    private int curX;//最后一个遍历的节点的X坐标
    private int curY;//当前遍历节点的Y坐标

    public int getNextX() {
        return nextX;
    }

    public void setNextX(int nextX) {
        this.nextX = nextX;
    }

    public int getCurX() {
        return curX;
    }

    public void setCurX(int curX) {
        this.curX = curX;
    }

    public int getCurY() {
        return curY;
    }

    public void setCurY(int curY) {
        this.curY = curY;
    }
}

面板

package rbtree;

import java.awt.*;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;
import java.util.List;


public class RBTreeFrame<T> extends Frame {

    /**
     * 面板坐标以及宽高
     */
    private static final int FRAME_WIDTH = 1800;
    private static final int FRAME_HEIGHT = 800;
    private static final int FRAME_X = 100;
    private static final int FRAME_Y = 100;

    /**
     * 圆形半径
     */
    private static final int CIRCULAR_RADIUS = 50;

    /**
     *偏移位置
     */
    private static final int X = 50;
    private static final int Y = 50;

    /**
     * 字体
     */

    private static final int FONT_SIZE = 16;
    private static final String FONT_NAME = "宋体";

    private List<Circular> circularList;

    private List<Line> lineList;




    public void showFrame(List<Circular> circularList, List<Line> lineList) {
        this.circularList = circularList;
        this.lineList = lineList;
        setBounds(FRAME_X,FRAME_Y,FRAME_WIDTH,FRAME_HEIGHT);
        this.addWindowListener(new WindowAdapter(){
        public void windowClosing(WindowEvent e) {
            System.exit(0);

        }

        });
        setVisible(true);

    }


    public void paint(Graphics g) {
        Font font = new Font(FONT_NAME,Font.BOLD,FONT_SIZE);	//加粗
        for(Line line : lineList){
            g.setColor(Color.BLACK);
            g.drawLine((line.getX1() + 1) * X  + CIRCULAR_RADIUS/2,(line.getY1() + 1) * X + CIRCULAR_RADIUS/2,(line.getX2() + 1) * X + CIRCULAR_RADIUS/2,(line.getY2() + 1) * X + CIRCULAR_RADIUS/2);
        }
        for(Circular circular : circularList){
            if(circular.isRed()){
                g.setColor(Color.RED);
            }else{
                g.setColor(Color.BLACK);
            }
            int x = (circular.getX() + 1) * X;
            int y = (circular.getY() + 1) * Y;

            g.fillOval(x, y, CIRCULAR_RADIUS, CIRCULAR_RADIUS);
            g.setColor(Color.WHITE);
            g.setFont(font);
            int len = circular.getVal().length();
            if(len == 1){
                g.drawString(circular.getVal(),x + CIRCULAR_RADIUS/2 - 6,y+CIRCULAR_RADIUS/2 + 6);
            }else if(len == 2){
                g.drawString(circular.getVal(),x + CIRCULAR_RADIUS/2 - 9,y+CIRCULAR_RADIUS/2 + 6);
            }else{
                g.drawString(circular.getVal(),x + CIRCULAR_RADIUS/2 - 13,y+CIRCULAR_RADIUS/2 + 6);
            }
        }


    }

}

步骤三： 测试

测试类

package rbtree;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;


public class Demo {
    public static void main(String[] args) {
        int num = 30;
        Random random = new Random();
        RBTree<Integer> rbTree = new RBTree<>();
        List<Integer> list = new ArrayList<>();
        for(int i = 0; i < num; i++){
            int randomNum = random.nextInt(1000);
            list.add(randomNum);
            rbTree.addNode(randomNum);
        }
        System.out.println(list);
        //rbTree.iterator();
        List<Circular> circularList = new ArrayList<>();
        List<Line> lineList = new ArrayList<>();
        rbTree.iterator(circularList,lineList);
        if(circularList.size() > 0){
            new RBTreeFrame().showFrame(circularList,lineList);
        }

    }
}

效果图

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

补充

1）目前实现不考虑删除节点。
2）基本是通过红黑树链接插入数据，看效果图，找规律(自己总结理解起来更深刻)。
3）为了方便验证自己写的红黑树没有问题，并把红黑树绘制出来相对更加直观，但不确保百分之百没有问题。

呆呆槑呆呆
关注
专栏目录
红黑树之 Java的实现
Java_Pluto的博客
05-27 265
红黑树的介绍 红黑树(Red-Black Tree，简称R-B Tree)，它一种特殊的二叉查找树。 红黑树是特殊的二叉查找树，意味着它满足二叉查找树的特征：任意一个节点所包含的键值，大于等于左孩子的键值，小于等于右孩子的键值。 除了具备该特性之外，红黑树还包括许多额外的信息。 红黑树的每个节点上都有存储位表示节点的颜色，颜色是红(Red)或黑(Black)。 红黑树的特性: (1) 每个节点或者是黑色，或者是红色。 (2) 根节点是黑色。 (3) 每个叶子节点是黑色。 [注意：这里叶子节点，是指为空的叶子
亲自动手画红黑树
小张的专栏
09-16 3915
在前面我们学习了平衡二叉树，伸展树，今天我们来看看另外一种平衡二叉树—红黑树，本来这篇博客早在一年前就该写的，后来发生了太多故事，博客停止了更新了一年，如今又有了最初的斗志，决定好好把博客写下去，对知识的梳理的同时，也不断巩固。 对于各种平衡树，我只能进行简单的理解和实现，无法涉及太多的应用，主要的还是本身自己知识广度和深度有限，不过我相信：不积跬步，无以至千里 本文主要参考了算法导论一书 ...
红黑树实现java代码
11-01
红黑树实现java代码，供大家参考，具体详解请参见我的博客http://blog.csdn.net/clamclam/article/details/49545477
java实现红黑树
weixin_42609225的博客
12-30 251
红黑树是一种平衡二叉搜索树，它的每个节点都有一个颜色属性，可以是红色或黑色。为了保证红黑树的平衡，它有以下五条性质： 每个节点要么是红色，要么是黑色。 根节点是黑色。 叶子节点(最后一层的节点)是黑色。 如果一个节点是红色，则它的两个儿子都是黑色。 对于每个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点。 下面是一个 Java 实现红黑树的例子： ```java pub...
Java中的红黑树（如果想知道Java中有关红黑树的知识点，那么只看这一篇就足够了！）
最新发布
秋刀鱼不做梦的编程日常
09-18 6409
Java中的红黑树（如果想知道Java中有关红黑树的知识点，那么只看这一篇就足够了！）
红黑树理解以及Java实现
热门推荐
qq_41854763的博客
09-13 1万+
我对红黑树的理解 红黑树本身并不复杂，只是在插入删除的时候情况比较多，如果强行记忆的话会显得比较困难，而且容易忘记。所以以前对红黑树一直没有很好的掌握。恰好这次借着复习数据结构的机会，静下心来仔细的学习了一下红黑树，所以用这篇文章把我对红黑树的操作的理解记录下来，在理解的基础上记忆会容易得多，这样以后就不用重复学习啦！ 1. 红黑树的定义 红黑树是一颗二叉查找树，且具有如下...
红黑树的Java实现 [z]
liudaoru - 悟
12-23 98
From: http://www.blogjava.net/javacap/archive/2007/12/20/169120.html 红黑树可能是要考虑情况最多的BST树了，它有自己的规则（见代码的注释），通过这些规则可以保证花费较小的代价来达到相对平衡。 注意，红黑树仍然不是平衡树，但是统计性能要好于AVL树。 要保持红黑树的规则，主要通过两类操作，一类是换色，一类还是旋转。 红黑树插入主要...
Java实现红黑树
HMH_huige的博客
06-06 258
Java实现红黑树
Java红黑树实现与可视化技术解析
资源摘要信息:"本文档介绍了如何通过Java编程语言实现红黑树的构建，并通过图形化界面展示红黑树的操作过程。红黑树是一种自平衡的二叉查找树，它在每个节点上增加了一个存储位表示节点的颜色，可以是红色或黑色。...
亲自动手绘图——红黑树，我不信还手撕不清楚
诗与远方的博客
06-27 238
前言 红黑树是自平衡的二叉查找树，在许多地方都有实际应用比如JAVA的HashMap，在链表长度大于8就会转化为红黑树；在linux经典的epoll中也使用了红黑树来保存文件描述符的插入删除操作。如果频繁地对数据进行插入删除，还要保证效率，使用红黑树是比较好的选择。 红黑树在实际表现上，还是一颗二叉树。在许多性质上和二叉树一样，所以要从二叉树查找开始讲起。 二叉查找树 二叉查找树是最简单的实现，规定左子节点一定小于右子节点。 插入情况只需要对当前节点比大小，不断的递归直到遇到空节点插入。 查询和插入相同，不
红黑树详解及其模板类实现
Moyu的专栏
01-29 1099
一、历史 1972年，Rudolf Bayer发明了一种数据结构，这是一种特殊的4阶B树。这些树维护从根到叶的所有路径保持相同数量的节点，从而创建完美平衡的树。但是，它们不是二叉搜索树。Bayer在他的论文中将它们称为“对称二叉B树”（symmetric binary B-tree），后来它们作为2-4树（也称2-3-4树）变得流行。 在1978年的一篇论文“平衡树的二色框架”中，Leonid...
Java 实现 红黑树（通俗易懂）
lllsure的博客
08-07 1621
红黑树的概念和模拟实现
红黑树Java实现
TigRer的博客
03-30 185
红黑树代码： package b; public class RBTree <K extends Comparable<K>, V> { // 定义颜色 private static final Boolean RED = true; private static final Boolean BLACK = false; // 定义红黑树的根root private RBNode root; public RBNode getRoo
红黑树java实现
a1362619536的博客
02-23 277
通过学习某up主的红黑树教学视频，整理了相关知识和代码 相关知识点在代码注释中标出 红黑树构造： public class RBTree <K extends Comparable<K>,V>{ private static final boolean RED=true; private static final boolean BLACK=false; //树根的引用 private RBNode root; public RBN
Java代码实现红黑树
yiguang_820的博客
04-03 1030
目录： 红黑树的特性 节点不是红色就是黑色 根节点为黑色 叶子节点为黑色 每个红色节点其子节点必须是黑色节点。 任意节点到到其任意的子节点的所有路径的黑色节点的数量相等 红黑树维持其特性的方法：变色和旋转 算法 插入 删除 一.红黑树维持其特性的方法：变色和旋转 红黑树的基本操作包括删除和添加。在删除或者添加一个节点的时候就有可能打破原有的红黑树维...
Java-红黑树的实现
xhmico的博客
04-12 1337
数据结构可视化-红黑树因为红黑树中有变色左旋右旋等变化，不是很容易理解，如果能自己对红黑树进行操作，那么这些概念上的东西相对而言就好接受一点了。红黑树是一种自平衡二叉查找树，和AVL 树类似，都是在进行插入和删除时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。红黑树虽然复杂，但它的最坏情况运行时间仍非常好，并且在实践中效率很高，它可以在O(logn)实践内进行查找、插入和删除操作，其性能要优于AVL 树。（1）其节点要么是红色，要么是黑色（2）根节点是黑色的（3）每个叶子节点都是黑色的。
java 红黑树_Java实现红黑树
weixin_29758911的博客
02-12 244
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实现红黑树数据结构
"Java实现的红黑树，包含TreeNode、RBTree及RBTreeTest三个类文件，用于创建、插入节点并保持红黑树性质。" 红黑树是一种自平衡二叉查找树，它在计算机科学中被广泛用于数据存储和排序操作。这种数据结构的关键特性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值