手写红黑树（插入）

已于 2023-10-09 10:24:32 修改
阅读量81 收藏
点赞数
分类专栏： 算法 文章标签： java 算法
于 2023-01-12 11:41:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44673447/article/details/128656639
版权

需求

红黑树实现。由于最近刚好有空闲，秉持着偷懒不学习的程序员不是好会计的原则，重新复习一下红黑树的结构。

实现中的难点问题

红黑树最主要的问题是树的修复，树的修复分为以下几种情况：

父节点与叔叔节点都为红色：

父节点与叔叔节点变黑色
祖父节点变红色
以祖父节点为支点，递归进行树的修复

LL双红：

父节点变黑色
祖父节点变红色
以祖父节点为支点，进行右旋

RL双红：

以父节点为支点，进行右旋
以父节点为支点，递归进行树的修复

RR双红：

父节点变黑色
祖父节点变红色
以祖父节点为支点，进行左旋

LR双红：

以父节点为支点，进行左旋
以父节点为支点，递归进行树的修复

step1: 先写一个树节点对象

package com.tfxing.index.dataStructure;

import com.tfxing.index.common.utils.handle.MyJsonUtilPlus;
import com.tfxing.index.enums.RBTreeColorEnum;
import lombok.Data;

/**
 * @author :tanfuxing
 * @date :2023/1/10
 * @description :
 */
@Data
public class TreeNode<T> {
    
    private Boolean color;
    
    private T value;
    
    //父节点
    private TreeNode<T> parent;
    
    //左子树
    private TreeNode<T> left;
    
    //右子树
    private TreeNode<T> right;

    public TreeNode(T t,boolean color) {
        this.value = t;
        this.color = color;
    }
    
    public void setParent(TreeNode<T> parent) {
        this.parent = parent;
    }

    public void setLeft(TreeNode<T> left) {
        this.left = left;
    }
    
    public void setRight(TreeNode<T> right) {
        this.right = right;
    }
    
    public int getHashCode() {
        return value.hashCode();
    }
    
    public String toString() {
        String result = "{\"value\":\"%s\", \n \"color\":\"%s\", \n \"left\":%s, \n \"right\":%s}";
        result = String.format(result,this.value, RBTreeColorEnum.getDescByKey(this.color),getToString(this.left),getToString(this.right));
        return result;
    }

    /**
     * 返回toString字符串
     * @param treeNode
     * @return
     */
    private String getToString(TreeNode<T> treeNode) {
        return null == treeNode ? null : treeNode.toString();
    }
}

step2：再写一个红黑树的封装对象

package com.tfxing.index.dataStructure;

import com.tfxing.index.enums.RBTreeColorEnum;
import lombok.Data;

/**
 * @author :tanfuxing
 * @date :2023/1/10
 * @description :
 */
@Data
public class RBTree<T> {
    
    //根节点
    private TreeNode<T> root;
    
    public RBTree() {}

    /**
     * 插入元素
     * @param t
     */
    public void add(T t) {
        TreeNode<T> currentNode = createTreeNode(t);
        insertTree(currentNode,this.root);
        
    }

    /**
     * 插入树节点
     * @param currentNode
     */
    private void insertTree(TreeNode<T> currentNode, TreeNode treeNode) {
        
        if(isNull(treeNode)) {
            if(isNull(this.root)) {
                this.root = currentNode;
            } else {
                TreeNode<T> parentNode = currentNode.getParent();
                if(compare(parentNode,currentNode)) {
                    parentNode.setLeft(currentNode);
                } else {
                    parentNode.setRight(currentNode);
                }
            }
            //树修复
            treeFixHandle(currentNode);
            return;
        }
        
        currentNode.setParent(treeNode);
        if(compare(treeNode,currentNode)) {
            insertTree(currentNode,treeNode.getLeft());
        } else {
            insertTree(currentNode,treeNode.getRight());
        }
        
    }

    /**
     * 对象是否为空
     * @param t
     * @return
     */
    private <T> boolean isNull(T t) {
        return null == t;
    }

    /**
     * 树修复
     * @param currentNode
     */
    private void treeFixHandle(TreeNode<T> currentNode) {
        if(isRoot(currentNode)) {
            colorChangeHandle(currentNode,RBTreeColorEnum.BLACK.getKey());
        } else if(isRed(currentNode.getParent())) {
            TreeNode<T> parentNode = currentNode.getParent();
            TreeNode<T> grandPaNode = parentNode.getParent();
            TreeNode<T> uncleNode = getUncleNode(currentNode);
            //如果父节点和叔叔节点都为红色
            if(isRed(parentNode) && isRed(uncleNode)) {
                colorChangeHandle(parentNode,RBTreeColorEnum.BLACK.getKey());
                colorChangeHandle(uncleNode,RBTreeColorEnum.BLACK.getKey());
                colorChangeHandle(grandPaNode,RBTreeColorEnum.RED.getKey());
                treeFixHandle(grandPaNode);
            } else {
                if(isLeftNode(currentNode)) {
                    if(isLeftNode(parentNode)) { //LL双红
                        colorChangeHandle(parentNode,RBTreeColorEnum.BLACK.getKey());
                        colorChangeHandle(grandPaNode,RBTreeColorEnum.RED.getKey());
                        rightRotation(grandPaNode);
                    } else { //RL双红
                        rightRotation(parentNode);
                        treeFixHandle(parentNode);
                    }
                } else if(isRightNode(currentNode)) { 
                    if(isRightNode(parentNode)) { //RR双红
                        colorChangeHandle(parentNode,RBTreeColorEnum.BLACK.getKey());
                        colorChangeHandle(grandPaNode,RBTreeColorEnum.RED.getKey());
                        leftRotation(grandPaNode);
                    } else { //LR双红
                        leftRotation(parentNode);
                        treeFixHandle(parentNode);
                    }
                }
            }
        }
    }

    /**
     * 当前节点是否为右子节点
     * @param currentNode
     * @return
     */
    private boolean isRightNode(TreeNode<T> currentNode) {
        TreeNode<T> parentNode = currentNode.getParent();
        return parentNode.getRight() == currentNode;
    }

    /**
     * 当前节点是否为红色
     * @param currentNode
     * @return
     */
    private boolean isRed(TreeNode<T> currentNode) {
        //如果为空，则为黑色
        if(isNull(currentNode)) return false;
        return !currentNode.getColor();
    }

    /**
     * 变色：指定颜色
     * @param currentNode
     * @param color
     */
    private void colorChangeHandle(TreeNode<T> currentNode, boolean color) {
        currentNode.setColor(color);
    }

    /**
     * 获取当前节点的叔叔节点
     * @param currentNode
     * @return
     */
    private TreeNode<T> getUncleNode(TreeNode<T> currentNode) {
        TreeNode<T> parentNode = currentNode.getParent();
        TreeNode<T> grandPaNode = parentNode.getParent();
        TreeNode<T> uncleNode = isLeftNode(parentNode) ? grandPaNode.getRight() : grandPaNode.getLeft();
        return uncleNode;
    }

    /**
     * 右旋
     * @param currentNode
     */
    private void rightRotation(TreeNode<T> currentNode) {
        TreeNode<T> parentNode = currentNode.getParent();
        TreeNode<T> leftNode = currentNode.getLeft();
        TreeNode<T> leftRightNode = leftNode.getRight();
        if (!isNull(parentNode)) {
            if(isLeftNode(currentNode)) {
                parentNode.setLeft(leftNode);
            } else {
                parentNode.setRight(leftNode);
            }
        }
        leftNode.setParent(parentNode);
        leftNode.setRight(currentNode);
        currentNode.setParent(leftNode);
        currentNode.setLeft(leftRightNode);
        
        if(isRoot(currentNode)) {
            this.root = leftNode;
        }
    }

    /**
     * 左旋
     * @param currentNode
     */
    private void leftRotation(TreeNode<T> currentNode) {
        TreeNode<T> parentNode = currentNode.getParent();
        TreeNode<T> rightNode = currentNode.getRight();
        TreeNode<T> rightLeftNode = rightNode.getLeft();
        if(!isNull(parentNode)) {
            if(isLeftNode(currentNode)) {
                parentNode.setLeft(rightNode);
            } else {
                parentNode.setRight(rightNode);
            }
        }
        rightNode.setParent(parentNode);
        rightNode.setLeft(currentNode);
        currentNode.setParent(rightNode);
        currentNode.setRight(rightLeftNode);
        
        if(isRoot(currentNode)) {
            this.root = rightNode;
        }
    }

    /**
     * 当前节点是否为左子节点
     * @param currentNode
     * @return
     */
    private boolean isLeftNode(TreeNode<T> currentNode) {
        TreeNode<T> parentNode = currentNode.getParent();
        return parentNode.getLeft() == currentNode;
    }
    

    /**
     * 是否是根节点
     * @param currentNode
     * @return
     */
    private boolean isRoot(TreeNode<T> currentNode) {
        return this.root == currentNode;
    }

    /**
     * 比较：第一个值是否大于第二个值
     * @param currentNode
     * @param treeNode
     * @return
     */
    private boolean compare(TreeNode<T> currentNode, TreeNode<T> treeNode) {
        return currentNode.getHashCode() > treeNode.getHashCode() ? true : false;
    }

    /**
     * 创建树节点
     * @param t
     * @return
     */
    private TreeNode<T> createTreeNode(T t) {
        return new TreeNode<>(t, RBTreeColorEnum.RED.getKey());
    }
    
    public String toString() {
        return this.root.toString();
    }
}

step3：颜色枚举类

	package com.tfxing.index.enums;

/**
 * @author :tanfuxing
 * @date :2023/1/10
 * @description :
 */
public enum RBTreeColorEnum {
    
    BLACK(true,"BLACK"),
    
    RED(false,"RED");
    
    private final Boolean color;
    
    private final String desc;
    
    
    private RBTreeColorEnum(boolean color, String desc) {
        this.color = color;
        this.desc = desc;
    }
    
    public static String getDescByKey(Boolean color) {
        String desc = "";
        for (RBTreeColorEnum rbTreeColorEnum : RBTreeColorEnum.values()) {
            if(rbTreeColorEnum.color.equals(color)) {
                desc = rbTreeColorEnum.desc;
                break;
            }
        }
        return desc;
    }

    public boolean getKey() {
        return this.color;
    }
    
    public String getDesc() {
        return this.desc;
    }
    
}

    }

step4：测试效果

@Test
    void testRBTree() {
        RBTree<Integer> rbTree = new RBTree<>();
        rbTree.add(324);
        rbTree.add(245);
        rbTree.add(643);
        rbTree.add(211);
        rbTree.add(200);
        rbTree.add(192);
        rbTree.add(195);
        rbTree.add(985);
        rbTree.add(728);
        rbTree.add(120);
        rbTree.add(159);
        System.out.println(rbTree);
    }

输出结果

{
	"value": "211",
	"color": "BLACK",
	"left": {
		"value": "195",
		"color": "RED",
		"left": {
			"value": "159",
			"color": "BLACK",
			"left": {
				"value": "120",
				"color": "RED",
				"left": null,
				"right": null
			},
			"right": {
				"value": "192",
				"color": "RED",
				"left": null,
				"right": null
			}
		},
		"right": {
			"value": "200",
			"color": "BLACK",
			"left": null,
			"right": null
		}
	},
	"right": {
		"value": "324",
		"color": "RED",
		"left": {
			"value": "245",
			"color": "BLACK",
			"left": null,
			"right": null
		},
		"right": {
			"value": "728",
			"color": "BLACK",
			"left": {
				"value": "643",
				"color": "RED",
				"left": null,
				"right": null
			},
			"right": {
				"value": "985",
				"color": "RED",
				"left": null,
				"right": null
			}
		}
	}
}

效果展示图

在这里插入图片描述

其他

红黑树插入效果演示网址：
https://www.cs.usfca.edu/~galles/visualization/RedBlack.html

link_ya
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
原生js手写tree树形分类选择插件
05-06
原生js结合jquery手写树形插件，详解编码思路，具体可使用示例，下载即可使用
纯JS+JQ手写web树
08-22
支持动态生成树，区分叶子节点和根节点的点击方式，纯JS+JQ编写，代码易懂，支持修改。
手写红黑树插入各种场景
t_zht的博客
09-05 235
删除的细致过程后续补充。。。。有点小懒，看不进去了。。
C语言-手写红黑树
weixin_45203607的博客
09-02 383
C语言-手写红黑树
java手写红黑树_手写红黑树的简单实现
weixin_33910191的博客
02-27 300
基于《算法》一书的红黑树的插入和删除。看过不同的教材，也有不同的实现方式，但是最终的结果也大致相同，感觉这个比较容易理解，就采用这种的方式来进行简单实现。定义树节点的实体类型private static final boolean RED = true;private static final boolean BLACK = false;/*** 红黑树的节点结构* 保存的值，左节点，右节点以及颜...
手写红黑树【数据结构】
小心星的博客
03-30 877
手写红黑树【数据结构】
JAVA手写红黑树
瑞文のBlog
01-13 820
既然我们需要手写红黑树，那么我们能就要高清书什么是红黑树 红黑树（Red Black Tree）是一种自平衡二叉查找树，是在计算机与科学用到的一种数据结构，典型的用途是实现关联数组 基本特征 每个节点不是红色就是黑色 不可能有连在一起的红色节点 根节点都是黑色 每个红色节点的两个子节点都是黑色 接下我我们欣赏一颗红黑树 红黑树变换规则： 改变节点颜色 左旋转 右旋转 变色 适用于： 当前父节点是红色且他的祖父节点（父亲的父亲）的另一个子节点也是红色（叔叔节点） 规则： 将父亲节点设置为黑色
android手写识别SDK
10-30
Google ML Kit 子组件 Ink Recognition
基于python生成手写字体
12-11
使用hangright库生成手写字 也可用于艺术字生成 也可以仿照他人的手写笔记生成字体
手写字迹识别C++代码
02-01
手写识别（HandWriting Recognition）是指将在手写设备上书写时产生的有序轨迹信息化转化为汉字内码的过程，实际上是手写轨迹的坐标序列到汉字的内码的一个映射过程，是人机交互最自然、最方便的手段之一。...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 692
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Java爬虫之Jsoup爬Html网页链接
withme977的博客
06-20 249
Java爬虫Jsoup
Java面试八股之简述JVM内存结构
u012151345的博客
06-20 732
在Java 8之前，永久代（Permanent Generation）是方法区的实现，之后被元空间（Metaspace）取代。总结来说，JVM内存结构设计精巧，通过区分线程私有和共享区域，以及细致划分各个区域的功能，确保了Java程序的高效、安全运行。每个线程都有自己的栈，用于存储方法调用时的信息，包括局部变量表、操作数栈、动态链接、方法出口等。方法区的一部分，存放编译期生成的各种字面量和符号引用，如字符串字面量、类名、方法名等。JVM中最大的一块内存区域，用于存储几乎所有的对象实例和数组。
Spring 事务传播行为之Propagation.NESTED REQUIRES_NEW等探讨
chengmin123456789的博客
06-17 225
当一个事务方法（标记为@Transactional(propagation = Propagation.NESTED))被另一个活动事务调用时，它会创建一个“保存点”（Savepoint）作为新的事务开始点。这意味着，如果这个嵌套事务方法内部发生异常并导致回滚，事务会回滚到这个保存点，而不会影响到外部事务的其他操作。如果一切正常，嵌套事务会在外部事务结束时一起提交。
Geoserver源码解读三 GeoServerBasePage
Yuanben_wuxin的博客
06-19 963
GeoServerBasePage 登录
Java中的Continue语句及其示例
Muhtar_的博客
06-20 142
Continue语句主要用于循环内部。每当在循环中遇到它时，控件都会直接跳到循环的开头进行下一次迭代，跳过当前迭代中循环体中语句的执行。当您希望继续循环，但不希望循环体中的其余语句（在continue语句之后）为该特定迭代执行时，这一点尤其有用。和你在这里看到的一样。我们将计数器值从10迭代到0，当计数器值为7时，循环跳过print语句并开始while循环的下一次迭代。示例：在While循环中使用continue。do-Wile循环中continue的示例。Java中的Continue语句及其示例。
Javase.认识异常
最新发布
Joseit的博客
06-21 1147
在Java开发中，异常处理是确保程序稳定性和可靠性的关键环节。这篇blog深入解析了Java异常的概念、体系、处理策略及自定义异常类。它介绍了异常的基本概念与分类，详细阐述了异常抛出、捕获与处理的最佳实践，包括防御式编程策略、try-catch结构的使用、以及finally块在资源清理中的作用。此外，还涵盖了自定义异常类以满足特定业务需求的重要性。通过学习本blog，读者可以深入理解Java异常处理机制，提升代码质量。
Java SE入门及基础（55）& Stream流及常用API
m0_63181360的博客
06-19 498
通过外部迭代，你的应用程序既可以确定要迭代的集合，又可以确定迭代的方式。它可以更轻松地利用并行计算的优势，这涉及将问题分为子问题，同时解决这些问题，然后将解决方案的结果组合到子问题中。）会产生非流结果，例如原始值（如双精度值），集合，或者在forEach的情况下根本没有任何值。它们处理流中的元素：聚合操作从流中而不是直接从集合中处理元素。流将一个基本数据类型的数组转换为包装类型的数组，再将包装类型的数组转换基本数据类型数组。筛选器操作返回一个新流，该流包含与筛选条件（此操作的参数）匹配的元素。
高通Android 12/13 Launcher3修改RecentView与屏幕方向保持一致
qq_15950325的博客
06-18 371
最近同事遇到一个需求说，recentview应用预览与屏幕方向不一致，问题，于是加了一些日志，实现此需求。3、最后展示RecentView与屏幕方向保持一致。2、源码修改diff如下所示。源码修改路径汇总如下。
手写红黑树
05-25
红黑树是一种自平衡的二叉搜索树，它的平衡保证了在最坏情况下的查找、插入和删除操作的时间复杂度均为 O(log n)。红黑树的每个节点都有一个颜色属性，可以是红色或黑色。在插入和删除节点时，需要通过变换节点的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值