红黑树学习和代码实现

最新推荐文章于 2024-01-23 13:24:22 发布
最新推荐文章于 2024-01-23 13:24:22 发布
阅读量133 收藏
点赞数
分类专栏： 笔记 java基础 文章标签： 数据结构 java 红黑树 算法 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/X_ABU/article/details/109844967
版权

文章目录

一、介绍

红黑树是一种特殊的二叉搜索平衡树，特点：

  1. 每个结点不是红色就是黑色（两种颜色的结点就可以了，为了研究方便这里使用了红黑色）
  2. 不可能有连在一起的结点
  3. 根结点都是黑色 root
  4. 每个红色结点的子结点都是黑色
  5. 叶子结点都是黑色 [注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！]
  6. 从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

二、旋转方式

这里说明站在绿色结点的角度说的，但是左旋右旋操作是对黄色结点来说的，下面是黄色结点的左旋右旋

1、左旋

（1）以父结点为旋转点，当前结点是他的右子结点，当前结点逆时针旋转120度
（2）使得原先的父结点变成左子结点，当前结点，变成父结点
（3）同时祖父结点把指向原来父结点是指针指向当前结点
（4）此时当前结点的左子结点成为原来父结点的右子结点
如图：
在这里插入图片描述

2、右旋

（1）以父结点为旋转点，当前结点是他的左子结点，当前结点顺时针旋转120度
（2）使得原先的父结点变成右子结点，当前结点，变成父结点
（3）同时祖父结点把指向原来父结点是指针指向当前结点
（4）此时当前结点的右子结点成为原来父结点的左子结点
如图：

在这里插入图片描述

三、变换规则

所以的插入结点都是红色

1、变色

当前结点的父结点和叔结点都是红色：
（1）父结点和叔结点设置为黑色
（2）祖父结点设置为红色
（3）把指向当前的操作指针指向祖父结点（操作对象由当前结点变更成祖父结点，对祖父结点操作）

2、左旋

当前结点的父结点是红色，叔结点是黑色，且当前结点是右子树：
（1）以父结点左旋
（2）把指向当前的操作指针指向原来的父结点

3、右旋

当前结点的父结点是红色，叔结点是黑色，且当前结点是左子树：
（1）把父结点设置成黑色
（2）把祖父结点设置成红色
（3）以祖父结点右旋
（2）把指向当前的操作指针指向原来的祖父结点

4、例子

向一个红黑树中插入一条记录6，看红黑树调整过程，这里省去了NIL结点，菱形表示当前操作结点

如图：

在这里插入图片描述

到这里完成了红黑树的调整，再次变成红黑树了

四、代码实现

首先定义一下结点：

public class Node {
    /**
     * 保存的数据
     */
    private int data;

    /**
     * 颜色
     */
    private String color;

    /**
     * 左子结点
     */
    private Node left;

    /**
     * 右子节点
     */
    private Node right;

    /**
     * 父结点
     */
    private Node parent;

    /**
     * 相对父结点的位置
     */
    private String place;
    
    /******************** 此处省略getter和setter ************************
}

创建红黑树对象

public class RedBlackTree {
    // 结点颜色
    public static final String CR = "red";
    public static final String CB = "black";

    // 相对于父结点的位置
    public static final String L = "left";
    public static final String R = "right";

    /**
     * 根节点
     */
    private Node root;

    /**
     * 树的数据
     */
    private Node tree;

    /**
     * 创建根结点
     *
     * @param date
     */
    public RedBlackTree(int date) {
        Node node = new Node();
        node.setData(date);
        node.setColor(CB);
        this.root = node;
        this.tree = node;
    }

    /**
     * 获取当前树的根结点
     *
     * @return
     */
    public RedBlackTree updateRoot() {
        if (this.root.getParent() == null) {
            return this;
        } else {
            this.root = this.root.getParent();
            return updateRoot();
        }
    }

    /**
     * 添加结点
     *
     * @param args
     * @return
     */
    public Node addNode(int[] args) {
        for (int i : args) {
            add(tree, i);
            // 更新当前的根结点
            updateRoot();
        }
        return root;
    }

    /**
     * 逐一添加结点
     *
     * @param tree
     * @param date
     * @return
     */
    private Node add(Node tree, int date) {
        if (tree.getData() < date) {
            if (tree.getRight() == null) {
                Node node = new Node();
                node.setData(date);
                node.setColor(CR);
                node.setParent(tree);
                node.setPlace(R);
                tree.setRight(node);
                /**
                 * 插入数据后可能会破坏红黑树结构
                 * 这里重新获取红黑树结构
                 */
                change(node);
            } else {
                add(tree.getRight(), date);
            }
        } else {
            if (tree.getLeft() == null) {
                Node node = new Node();
                node.setData(date);
                node.setColor(CR);
                node.setParent(tree);
                node.setPlace(L);
                tree.setLeft(node);
                /**
                 * 插入数据后可能会破坏红黑树结构
                 * 这里重新获取红黑树结构
                 */
                change(node);
            } else {
                add(tree.getLeft(), date);
            }
        }
        return tree;
    }

    /**
     * 输出当前结点的树
     *
     * @param tree
     */
    public void print(Node tree) {
        if (tree == null) {
            return;
        }

        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("data:").append(tree.getData()).append(",");
        stringBuilder.append("color:").append(tree.getColor()).append(",");
        if (tree.getParent() == null) {
            stringBuilder.append("parent:").append("root").append(",");
        } else {
            stringBuilder.append("parent:").append(tree.getParent().getData()).append(",");
        }

        stringBuilder.append("place:").append(tree.getPlace()).append(",");

        System.out.println(stringBuilder.toString());
        print(tree.getLeft());
        print(tree.getRight());
    }

    /**
     * 根据变换规则实现变色操作
     *
     * @param tree 操作的结点
     * @return 返回操作结点的祖父结点
     */
    public Node changeColor(Node tree) {
        tree.getParent().getParent().getLeft().setColor(CB);
        tree.getParent().getParent().getRight().setColor(CB);
        tree.getParent().getParent().setColor(CR);
        return tree.getParent().getParent();
    }

    /**
     * 实现左旋
     *
     * @param tree 操作的结点
     * @return 然后操作的结点
     */
    public Node spinLeft(Node tree) {
        Node parent = tree.getParent();
        Node right = tree.getRight();
        Node rightLeft = tree.getRight().getLeft();

        if (L.equals(tree.getPlace())) {
            if (parent != null) {
                parent.setLeft(right);
                right.setParent(parent);
                right.setPlace(L);
            } else {
                right.setParent(null);
                right.setPlace(null);
            }


            right.setLeft(tree);
            tree.setParent(right);
            tree.setPlace(L);
            tree.setRight(rightLeft);
            rightLeft.setParent(tree);
            rightLeft.setPlace(R);
        } else {
            if (parent != null) {
                parent.setRight(right);
                right.setParent(parent);
                right.setPlace(R);
            } else {
                right.setParent(null);
                right.setPlace(null);
            }

            right.setLeft(tree);
            tree.setParent(right);
            tree.setPlace(L);
            tree.setRight(rightLeft);
            rightLeft.setParent(tree);
            rightLeft.setPlace(R);
        }
        return tree;
    }

    /**
     * 实现右旋
     *
     * @param tree 操作的结点
     * @return 然后操作的结点
     */
    public Node spinRight(Node tree) {
        Node parent = tree.getParent();
        Node left = tree.getLeft();
        Node leftRight = tree.getLeft().getRight();

        if (L.equals(tree.getPlace())) {
            if (parent != null) {
                parent.setLeft(left);
                left.setParent(parent);
                left.setPlace(L);
            } else {
                left.setParent(null);
                left.setPlace(null);
            }

            left.setRight(tree);
            tree.setParent(left);
            tree.setPlace(R);
            tree.setLeft(leftRight);
            leftRight.setParent(tree);
            leftRight.setPlace(L);
        } else {
            if (parent != null) {
                parent.setRight(left);
                left.setParent(parent);
                left.setPlace(R);
            } else {
                left.setParent(null);
                left.setPlace(null);
            }
            left.setRight(tree);
            tree.setParent(left);
            tree.setPlace(R);
            tree.setLeft(leftRight);
            leftRight.setParent(tree);
            leftRight.setPlace(L);
        }
        return tree;
    }

    /**
     * 根据变化规则实现红黑树结果重组
     *
     * @param tree 操作的结点
     * @return 操作的结点
     */
    public Node change(Node tree) {
        Node parent = tree.getParent();

        // 如果没有父结点和祖父结点就不操作
        if (parent == null || parent.getParent() == null) {
            return tree;
        }

        // 获取叔结点
        Node uncle = null;
        if (L.equals(parent.getPlace())) {
            uncle = parent.getParent().getRight();
        } else {
            uncle = parent.getParent().getLeft();
        }

        /**
         * 当前结点的父结点和叔结点都是红色 变色
         */
        Boolean flag1 = CR.equals(parent.getColor()) && CR.equals(uncle.getColor());
        if (flag1) {
            return change(changeColor(tree));
        }

        /**
         * 当前结点的父结点是红色，叔结点是黑色，且当前结点是右子树
         * 对父结点左旋
         * 返回父结点
         */
        Boolean flag2 = CR.equals(parent.getColor()) && CB.equals(uncle.getColor()) && R.equals(tree.getPlace());
        if (flag2) {
            return change(spinLeft(tree.getParent()));
        }

        /**
         * 当前结点的父结点是红色，叔结点是黑色，且当前结点是左子树
         * 把父结点设置成黑色
         * 把祖父结点设置成红色
         * 对祖父结点右旋
         * 返回祖父结点
         */
        Boolean flag3 = CR.equals(parent.getColor()) && CB.equals(uncle.getColor()) && L.equals(tree.getPlace());
        if (flag3) {
            tree.getParent().setColor(CB);
            tree.getParent().getParent().setColor(CR);
            return change(spinRight(tree.getParent().getParent()));
        }

        return tree;
    }

    public Node getRoot() {
        return root;
    }
}

测试函数

public class testTree {
    public static void main(String[] args) {
        // 创建根节点
        RedBlackTree redBlackTree = new RedBlackTree(19);
        // 插入数据
        int[] datas = {5, 30, 1, 12, 7, 13, 35};
        redBlackTree.addNode(datas);
        //获取当前根结点，并输出完整的树
        redBlackTree.print(redBlackTree.getRoot());
    }
}

结果如下

data:19,color:red,parent:root,place:null,
data:5,color:red,parent:19,place:left,
data:1,color:black,parent:5,place:left,
data:12,color:black,parent:5,place:right,
data:7,color:red,parent:12,place:left,
data:13,color:red,parent:12,place:right,
data:30,color:black,parent:19,place:right,
data:35,color:red,parent:30,place:right,

通过上面是数据我们可以获得一棵树，这个树就是上面举例的树

现在再插入6；

public class testTree {
    public static void main(String[] args) {
        // 创建根节点
        RedBlackTree redBlackTree = new RedBlackTree(19);
        // 插入数据
        int[] datas = {5, 30, 1, 12, 7, 13, 35};
        redBlackTree.addNode(datas);

        // 插入数据 6
        int[] datas2 = {6};
        redBlackTree.addNode(datas2);
        //获取当前根结点，并输出完整的树
        redBlackTree.print(redBlackTree.getRoot());
    }
}

输出结果：

data:12,color:black,parent:root,place:null,
data:5,color:red,parent:12,place:left,
data:1,color:black,parent:5,place:left,
data:7,color:black,parent:5,place:right,
data:6,color:red,parent:7,place:left,
data:19,color:red,parent:12,place:right,
data:13,color:black,parent:19,place:left,
data:30,color:black,parent:19,place:right,
data:35,color:red,parent:30,place:right,

输出的正是我们要的最终结果，到这里就完成了上面例子的代码实现了。

X_ABU
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构系列之Java手写实现红黑树
Nicky's blog
08-18 2669
数据结构系列之Java手写实现红黑树，红黑树是一种自平衡的二叉搜索树，是二叉搜索树的拓展。红黑树只有两种节点，一种是红色的，一种是黑色的。红黑树不像AVL树那样严格，而是近似平衡。
红黑树 图文详解与代码实现
qq_54831038的博客
09-01 959
红黑树被应用于数据结构map/set的封装的底层，也应用于Linux的数据内核，在进程调度CFS，虚拟内存管理，共享内存slab等场景都有广泛应用。数据结构的角度看，（1）用于存储。无论数据是否平衡都可以在O（logN)的复杂度下完成 搜索、插入、删除操作。（2）用于排序。找到最小值和最大值红黑树黑色和红色 也可看成两种状态，红黑区分的状态中，可以根据实际需求添加业务逻辑。......
C++实现红黑树（含完整代码+图）
weixin_44628585的博客
08-09 2199
此文主要记录红黑树的操作，即节点的添加删除操作，并且有完整代码可供学习。欢迎大家阅读，如有问题，麻烦大家指出。
C#红黑树实现代码
xy_learning的博客
10-23 1407
在学习红黑树之前，最好已经学习过AVL树了，因为二者的实现方式是有很大程度类似的（左旋和右旋），但是只不过二叉平衡树是在每次加入节点时，需要计算该节点的左右子树高度差，如果高度差大于一则旋转调节使其平衡；而红黑树是在每次加入节点时计算红黑节点之间的关系，如果关系错误，则通过旋转和改变颜色来调节树的结构。 总之，AVL树也好，RB树也好，都只不过是一种优化二叉查找树的高级方式而已。 下面是C#实...
C++红黑树
~
03-26 6450
C++红黑树零、前言一、红黑树的概念及性质二、红黑树结点的定义三、红黑树的插入操作1、变色处理2、单旋+变色3、双旋+变色4、插入实现四、红黑树的验证五、红黑树的删除六、红黑树与**AVL**树的比较 零、前言 本章继AVL树后继续讲解学习C++中另一个二叉搜索树–红黑树 一、红黑树的概念及性质 概念： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长
红黑树原理及代码实现（一）
旧时明月丶
08-31 739
红黑树简介 红黑树是一种自平衡的二叉查找树，它的统计性能要优于平衡二叉树，因此在很多地方都有应用，例如Java中的TreeMap，HashMap等数据结构都使用到了红黑树。红黑树对很多人来说熟悉而陌生，熟悉则是因为知道红黑树在很多场景中有使用，但又对其原理很陌生或者一知半解。今天就来剖析一下红黑树原理 红黑树是一种二叉查找树，但是它在二叉查找树基础上增加了着色和相关的性质使得其相对平衡，从而保证了红黑树的查找、插入、删除的时间复杂度最坏为O(log n)。红黑树具备以下5个性质： 1.每个节点要么是黑色，要
红黑树（C++代码实现+原理简介）
玩遍每座城
04-04 3404
Red-Black Tree 说明 本文根据<<Introduction to algorithm>>一书的第13章 Red-Black Tree以及MIT OCW课程6.046J对红黑树的教学内容（网易公开课上面有这个课的中文翻译版本），使用C++语言，对书中的红黑树数据结构进行了实现。只是个人的学习笔记记录，除了代码之外，其他部分对红黑树原理的解释比较粗陋，暂不具有太大...
红黑树的理解与代码实现
iwts
02-11 2919
红黑树 我们知道对于二叉搜索树而言，无法保证树的平衡性，从而使得进行操作的时候时间复杂度在O(logn)与O(n)之间。这样是不稳定的。而2-3树则借助于3-结点和临时的4-结点，通过分解，解决了平衡问题。例如对于插入，在最终是3-结点的情况下，临时构成4-结点，然后再分解成3个2-结点，这样令树高度+1，但是整体平衡性不变。而红黑树就是为了实现自平衡这个功能而对2-3树进行了扩...
搜索二叉树 | 红黑树 | 验证是否为红黑树 | 代码实现
qq_63159859的博客
01-23 1140
图解红黑树！
C语言 红黑树分析与实现
C++ 开发者的博客
12-11 1013
重要概念 红黑树的资料网上资料很多，对红黑树的定义、性质、以及操作都做了详细的分析，这篇博文也参考了网上的很多文章，不过主要是学习了腾讯课堂-零声king老师的课之后，对红黑树的一些理解。肯定有一些错误的地方，如果觉得不对，可以给我指出。 参考资料 如果你对红黑树的基本概念，用途，性质等不了解，那么请先看红黑树(一)之 原理和算法详细介绍的文章，里面对红黑树的了解很仔细，这篇博客主要是用C语言来实现红黑树。 红黑树性质 （1）每个节点或者是黑色，或者是红色。 （2）根节点是黑色。 （3）每个叶子节点（NIL
红黑树的实现C++代码
07-27
用C++代码实现了一个红黑树，大家可以一起学习学习，有问题也可以直接给我留言
map与set的底层大概框架-红黑树
最新发布
04-04
学习map和set的友友们如果对红黑树的底层框架很模糊。 可以借鉴一下本文件中的红黑树。 虽然有些地方写的不够全不够好， 但是基本的迭代器功能都已经实现。其实红黑树的学习主要就是学习它的插入， 最重要的就是...
红黑树学习参考资料集合
12-23
包括红黑树PPT，演示FLV， C代码实现，java代码实现，及java中的TreeMap源文件（红黑树的应用）。
二叉查找排序树的实现代码
05-30
最近在研究数据结构这本书，自己动手实现的一个二叉查找排序树的类BinSortTree，实现数据的插入，查找，删除，层序遍历，中序遍历等...其实这个跟stl的set容器已经十分相似，只是set使用查找性能更优越的红黑树来实现
红黑树及其绘制
08-25
红黑树是重要的数据结构，而其操作又很复杂，如果能够可视化地展示插入与删除过程，则学习起来会容易得多。 为了学习它们，我翻译以下文章（论文）并实现了相应算法，并放到网络上，与说中文的程序爱好者共同进步。...
java8计算list对象BigDecimal属性的最大值、最小值、总和、平均值
热门推荐
X_ABU的博客
03-07 1万+
代码举例 @Slf4j public class TestList { @Test public void test01() throws IOException { User user1 = new User(2, "Steven", "@sun123", new Date(), 2000.0, new BigDecimal(2000)); Use...
oracle的varchar2和mysql的varchar字符串长度计算
X_ABU的博客
07-07 2120
1、oracle的varcher2的计算单位是字节，mysql的varchar的计算单位是字符； 2、在utf-8下oracle的vachar2保存一个汉字要3个字节，mysql的varchar需要一个字符； 3、在保存数字和字母的时候oracle的vachar2占一个字节，mysql的varchar需要一个字符。 下面测试: select length('你好'),char_length('你好'); -- 前一个计算字节长度，后一个计算字符长度 select length('hello!'),char_
SpringCloud调用第三方接口实现文件下载——接口穿透
X_ABU的博客
08-31 1434
需求： 现在有两个系统，一个是SSM架构系统，一个是SpringCloud架构系统 现在SpringCloud系统要求下载SSM系统的文件，采取调用SSM系统接口的方式 通过调用SpringCloud接口实现下载 主要操作可以分成三步： 获取token 请求SSM系统获取文件的字节流和文件信息 将请求的字节流重新装配在SpringCloud系统的返回参数里 这样就完成了接口的穿透转载了。 token的获取就不说了，不同的系统获取的方式也不同，下面说一下获取SSM系统的字节流： @Over.
Oracle在Mybatis中获取序列的值
X_ABU的博客
06-08 1056
Mapper 传入序列名称获取，这里使用$符号拼接 <select id="getSeqByName" parameterType="string" resultType="long"> SELECT ${value}.nextval FROM DUAL </select> java mapper 接口接收序列名称 Long getSeqByName(@Param("value") String value); server 使用方法 Long i
学习红黑树的概念及利用python代码实现红黑树三种操作和扩张
11-08
以下是Python代码实现红黑树的三种操作和扩张： ```python class Node: def __init__(self, key): self.key = key self.left = None self.right = None self.parent = None self.color = 1 class RedBlack...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值