一天一个算法——>红黑树JAVA实现

简介: 一天一个算法——>红黑树JAVA实现

代码均为自己的思路,手动敲写,如有bug,或者思路错误,欢迎指正,多多交流。

package tree;
/**
 * 红黑树(R-B Tree)
 * 递归方式空间复杂度为O(log n),且受栈内存限制,故能使用循环的尽量使用循环,本例子使用while循环
 * 这里只模拟int类型实现,如果需要其他类型,请将int类型修改为泛型,并实现extends Comparable<T>接口,方便比较compareTo
 * 动态模拟实现:https://www.cs.usfca.edu/~galles/visualization/RedBlack.html
 * GitHub地址:https://github.com/hack-feng/algorithm
 * 理论知识:https://blog.csdn.net/qq_34988304/article/details/100135759
 * CSDN博客地址:
 * 联系作者:1150640979@qq.com
 *
 * 红黑树的特性:
 * (1)每个节点或者是黑色,或者是红色。
 * (2)根节点是黑色。
 * (3)每个叶子节点(NIL)是黑色。 [注意:这里叶子节点,是指为空(NIL或NULL)的叶子节点!]
 * (4)如果一个节点是红色的,则它的子节点必须是黑色的。
 * (5)从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。
 */
public class RedBlackTree {
    private RBNode root;    // 根结点
    private static final boolean RED   = false;
    private static final boolean BLACK = true;
    static class RBNode{
        // 节点颜色, 红:false   黑:true
        boolean color;
        int data;
        RBNode left;
        RBNode right;
        RBNode parent;
        RBNode(int data, RBNode left, RBNode right){
            this.data = data;
            this.left = left;
            this.right = right;
        }
    }
    private void insert(int data){
        RBNode node = new RBNode(data, null, null);
        insert(node);
    }
    private void insert(RBNode node){
        // 定义node的根节点
        RBNode pNode = null;
        // 定义一个临时节点
        RBNode tempNode = this.root;
        // 取出root的根节点
        while(tempNode != null){
            pNode = tempNode;
            if(tempNode.data > node.data){
                tempNode = tempNode.left;
            }else{
                tempNode = tempNode.right;
            }
        }
        // 设置node的父节点
        node.parent = pNode;
        // 判断将node放在其父节点的左节点还是右节点
        if(pNode != null){
            if(pNode.data > node.data){
                pNode.left = node;
            }else{
                pNode.right = node;
            }
        }else{
            this.root = node;
        }
        // 初始化节点的颜色为红色
        node.color = RED;
        // 修正为红黑树
        insertFixUp(node);
    }
    /**
     * 修正红黑树
     * 分为一下几种情况:
     * 1:如果是父节点,直接变成黑色
     * 2:如果父节点是黑色,不违背特性,直接添加即可
     * 3:如果父节点是红色,添加违背特性。则又分为一下几种情况:
     *  3.1:父节点是祖父节点的左节点
     *      3.1.1:如果叔叔节点为黑的时候
     *          3.1.1.1:如果插入的节点是父节点的左节点
     *              父节点变色,祖父节点变色,祖父节点右旋
     *          3.1.1.2:如果插入的节点是父节点的右节点
     *              父节点左旋,然后父节点变色,祖父节点变色,祖父节点右旋
     *      3.1.2:如果叔叔节点为红的时候
     *          直接将父节点和叔叔节点涂黑,祖父节点涂红就可以了
     *  3.2:父节点是祖父节点的右节点
     *      3.2.1:如果叔叔节点为黑的时候
     *          3.2.1.1:如果插入的节点是父节点的左节点
     *              父节点变色,祖父节点变色,祖父节点左旋
     *          3.2.1.2:如果插入的节点是父节点的右节点
     *              父节点右旋,然后父节点变色,祖父节点变色,祖父节点左旋
     *      3.2.2:如果叔叔节点为红的时候
     *          直接将父节点和叔叔节点涂黑,祖父节点涂红就可以了
     */
    private void insertFixUp(RBNode node) {
        RBNode pNode, gNode;
        // 如果父节点不为空,并且父节点的颜色是红色,则会触发树旋转
        while((pNode = node.parent) != null && isRed(pNode.color)){
            gNode = pNode.parent;
            // 父节点为祖父节点的左节点时
            if(gNode.left == pNode){
                RBNode uNode = gNode.right;
                //叔叔节点为红色
                if(uNode != null && isRed(uNode.color)){
                    pNode.color = BLACK;
                    uNode.color = BLACK;
                    gNode.color = RED;
                    node = gNode;
                }else{
                    // 叔叔节点为黑色,当前节点在父节点的右节点
                    if(pNode.right == node){
                        // 先把父节点左旋
                        leftRotate(pNode);
                    }
                    // 叔叔节点为黑色,当前节点在父节点的左节点
                    pNode.color = BLACK;
                    gNode.color = RED;
                    rightRotate(gNode);
                }
            }else{
                RBNode uNode = gNode.left;
                //叔叔节点为红色
                if(uNode != null && isRed(uNode.color)){
                    pNode.color = BLACK;
                    uNode.color = BLACK;
                    gNode.color = RED;
                    node = gNode;
                }else{
                    // 叔叔节点为黑色,当前节点在父节点的左节点
                    if(pNode.left == node){
                        // 先把父节点右旋
                        rightRotate(pNode);
                    }
                    // 叔叔节点为黑色,当前节点在父节点的右节点
                    pNode.color = BLACK;
                    gNode.color = RED;
                    leftRotate(gNode);
                }
            }
        }
        // 将根节点设为黑色
        this.root.color = BLACK;
    }
    // 右旋
    private void rightRotate(RBNode node){
        // 取出当前节点的左节点始终,赋值给leftNode
        RBNode leftNode = node.left;
        // 将leftNode的右节点赋值给node的左节点
        node.left = leftNode.right;
        // 因为下面leftNode.right = node, 所以如果leftNode.right != null,修改leftNode.right.parent = node
        if(leftNode.right != null){
            leftNode.right.parent = node;
        }
        // 设置leftNode.parent
        leftNode.parent = node.parent;
        if(node.parent == null){
            // 如果node.parent为null,说明node原来为根节点,则将leftNode设为新的根节点
            this.root = leftNode;
        }else{
            // 将指向node的父节点更改为leftNode
            if(node.parent.right == node){
                node.parent.right = leftNode;
            }else{
                node.parent.left = leftNode;
            }
        }
        // 设置leftNode.right
        leftNode.right = node;
        // 设置node.parent
        node.parent = leftNode;
    }
    // 左旋,解释同右旋
    private void leftRotate(RBNode node){
        RBNode rightNode = node.right;
        node.right = rightNode.left;
        if(rightNode.left != null){
            rightNode.left.parent = node;
        }
        rightNode.parent = node.parent;
        if(node.parent == null){
            this.root = rightNode;
        }else{
            if(node.parent.left == node){
                node.parent.left = rightNode;
            }else{
                node.parent.right = rightNode;
            }
        }
        rightNode.left = node;
        node.parent = rightNode;
    }
    private boolean isRed(boolean color){
        return !color;
    }
    public static void main(String[] args){
        RedBlackTree rbTree = new RedBlackTree();
//        int[] dataArray = new int[]{1, 2, 3, 4, 5, 6, 7, 8};
//        int[] dataArray = new int[]{8, 7, 6, 5, 4, 3, 2, 1};
        // 测试
        int[] dataArray = new int[]{3, 5, 8, 4, 7, 1, 6, 2};
        for (int i : dataArray) {
            rbTree.insert(i);
        }
        System.out.println(123);
    }
}
目录
相关文章
|
1月前
|
存储 算法 安全
探究‘公司禁用 U 盘’背后的哈希表算法与 Java 实现
在数字化办公时代,信息安全至关重要。许多公司采取“禁用U盘”策略,利用哈希表算法高效管理外接设备的接入权限。哈希表通过哈希函数将设备标识映射到数组索引,快速判断U盘是否授权。例如,公司预先将允许的U盘标识存入哈希表,新设备接入时迅速验证,未授权则禁止传输并报警。这有效防止恶意软件和数据泄露,保障企业信息安全。 代码示例展示了如何用Java实现简单的哈希表,模拟公司U盘管控场景。哈希表不仅用于设备管理,还在文件索引、用户权限等多方面助力信息安全防线的构建,为企业数字化进程保驾护航。
|
2月前
|
监控 算法 网络协议
Java 实现局域网电脑屏幕监控算法揭秘
在数字化办公环境中,局域网电脑屏幕监控至关重要。本文介绍用Java实现这一功能的算法,涵盖图像采集、数据传输和监控端显示三个关键环节。通过Java的AWT/Swing库和Robot类抓取屏幕图像,使用Socket进行TCP/IP通信传输图像数据,并利用ImageIO类在监控端展示图像。整个过程确保高效、实时和准确,为提升数字化管理提供了技术基础。
84 15
|
4月前
|
存储 人工智能 算法
数据结构与算法细节篇之最短路径问题:Dijkstra和Floyd算法详细描述,java语言实现。
这篇文章详细介绍了Dijkstra和Floyd算法,这两种算法分别用于解决单源和多源最短路径问题,并且提供了Java语言的实现代码。
125 3
数据结构与算法细节篇之最短路径问题:Dijkstra和Floyd算法详细描述,java语言实现。
|
11天前
|
存储 算法 Java
解锁“分享文件”高效密码:探秘 Java 二叉搜索树算法
在信息爆炸的时代,文件分享至关重要。二叉搜索树(BST)以其高效的查找性能,为文件分享优化提供了新路径。本文聚焦Java环境下BST的应用,介绍其基础结构、实现示例及进阶优化。BST通过有序节点快速定位文件,结合自平衡树、多线程和权限管理,大幅提升文件分享效率与安全性。代码示例展示了文件插入与查找的基本操作,适用于大规模并发场景,确保分享过程流畅高效。掌握BST算法,助力文件分享创新发展。
|
24天前
|
存储 人工智能 算法
解锁分布式文件分享的 Java 一致性哈希算法密码
在数字化时代,文件分享成为信息传播与协同办公的关键环节。本文深入探讨基于Java的一致性哈希算法,该算法通过引入虚拟节点和环形哈希空间,解决了传统哈希算法在分布式存储中的“哈希雪崩”问题,确保文件分配稳定高效。文章还展示了Java实现代码,并展望了其在未来文件分享技术中的应用前景,如结合AI优化节点布局和区块链增强数据安全。
|
26天前
|
算法 安全 Java
Java线程调度揭秘:从算法到策略,让你面试稳赢!
在社招面试中,关于线程调度和同步的相关问题常常让人感到棘手。今天,我们将深入解析Java中的线程调度算法、调度策略,探讨线程调度器、时间分片的工作原理,并带你了解常见的线程同步方法。让我们一起破解这些面试难题,提升你的Java并发编程技能!
65 16
|
1月前
|
运维 监控 算法
企业局域网监控软件中 Java 优先队列算法的核心优势
企业局域网监控软件是数字化时代企业网络安全与高效运营的基石,犹如一位洞察秋毫的卫士。通过Java实现的优先队列算法,它能依据事件优先级排序,确保关键网络事件如异常流量、数据泄露等被优先处理,保障系统稳定与安全。代码示例展示了如何定义网络事件类并使用PriorityQueue处理高优先级事件,尤其在面对疑似风险时迅速启动应急措施。这一核心技术助力企业在复杂网络环境中稳健前行,护航业务腾飞。
65 32
|
1月前
|
存储 监控 算法
剖析基于Java算法驱动的智能局域网管控之道
本文探讨了基于Java语言的局域网控制方案,结合链表数据结构与令牌桶算法,解决设备管理和流量调度难题。通过链表灵活存储网络设备信息,实现高效设备管理;令牌桶算法则精准控制流量,确保网络平稳运行。二者相辅相成,为校园、企业等局域网提供稳固高效的控制体系,保障业务连续性和数据安全。
|
29天前
|
算法 搜索推荐 Java
【潜意识Java】深度解析黑马项目《苍穹外卖》与蓝桥杯算法的结合问题
本文探讨了如何将算法学习与实际项目相结合,以提升编程竞赛中的解题能力。通过《苍穹外卖》项目,介绍了订单配送路径规划(基于动态规划解决旅行商问题)和商品推荐系统(基于贪心算法)。这些实例不仅展示了算法在实际业务中的应用,还帮助读者更好地准备蓝桥杯等编程竞赛。结合具体代码实现和解析,文章详细说明了如何运用算法优化项目功能,提高解决问题的能力。
58 6
|
29天前
|
算法 Java C++
【潜意识Java】蓝桥杯算法有关的动态规划求解背包问题
本文介绍了经典的0/1背包问题及其动态规划解法。
48 5

热门文章

最新文章