java日志

最新推荐文章于 2024-08-14 07:00:00 发布
最新推荐文章于 2024-08-14 07:00:00 发布
阅读量216 收藏
点赞数
分类专栏： java日志 文章标签： 【数据结构和算法 01】红黑树算法详解和java具体实现

      想具体实现以下红黑树算法已经有很长一段时间了，但是一直没有抽出比较完整的时间来系统整理和实现以下红黑树算法，下面一起来看看红黑树的具体实现吧，想想也很简单。

1. 首先介绍以下红黑树的性质：

    红黑树是一种满足红黑性质的搜索二叉树：

  1. 红黑树的节点是红色或者黑色
  2. 根节点是黑色的
  3. 每个叶子节点是黑色的（这里的叶子节点是指空节点）
  4. 每个红色节点的孩子节点都是黑色的
  5. 每个节点到其后代节点的简单路径上，都包含相同数目的黑色节点

2. 左旋和右旋

    红黑树维持的性质主要通过两个旋转操作(左旋和右旋)、变色实现，变色很容易理解，就是字面意思将节点颜色从一种颜色修改为另外一种，关键是变色的时机和如何变色，比较复杂，这个问题会在后面的实现步骤讲解中涉及，这里主要针对左旋和右旋进行讲解。

因为后面设计代码具体实现，这里首先给出java红黑树节点类的实现。

[java] view plain copy
print ?
  1. public class RBNode<T extends Comparable<T>> {  
  2.         boolean color;//节点颜色  
  3.         T key; //关键字（键值）  
  4.         RBNode<T> left;//坐孩子节点  
  5.         RBNode<T> right;//右孩子节点  
  6.         RBNode<T> parent;//父节点  
  7.   
  8.   
  9.         //节点构造函数  
  10.         public RBNode(T key, boolean color, RBNode<T> parent, RBNode<T> left, RBNode<T> right) {  
  11.             this.key = key;  
  12.             this.color = color;  
  13.             this.parent = parent;  
  14.             this.left = left;  
  15.             this.right = right;  
  16.         }  
  17.   
  18.         public T getKey(){  
  19.             return key;  
  20.         }  
  21.   
  22.         public String toString(){  
  23.             return “”+key+“:”+(this.color == true? “R”:“B”);  
  24.         }  
  25.     }  
public class RBNode<T extends Comparable<T>> {
        boolean color;//节点颜色
        T key; //关键字（键值）
        RBNode<T> left;//坐孩子节点
        RBNode<T> right;//右孩子节点
        RBNode<T> parent;//父节点


        //节点构造函数
        public RBNode(T key, boolean color, RBNode<T> parent, RBNode<T> left, RBNode<T> right) {
            this.key = key;
            this.color = color;
            this.parent = parent;
            this.left = left;
            this.right = right;
        }

        public T getKey(){
            return key;
        }

        public String toString(){
            return ""+key+":"+(this.color == true? "R":"B");
        }
    }

左旋

     左旋的意思就是以一个节点为轴，向左旋转，将右节点的左子树作为该节点的右字树连接到该节点上，该节点的右节点作为该节点的父节点替换轴节点原来的位置，如下图所示：

 

左旋代码具体实现：

[java] view plain copy
print ?
  1. /** 
  2.     * 节点左旋 
  3.     * @param x 旋转时作为轴的节点 
  4.     * 
  5.     *        X                     Y 
  6.     *     /    \                /    \ 
  7.     *    A     Y     ->        X     RB 
  8.     *   / \   / \            /  \ 
  9.     *  LA RA LB  RB         A  LB 
  10.     *                      / \ 
  11.     *                     LA RA 
  12.     * 
  13.     * 节点左旋的主要工作： 
  14.     * 1.x节点的左孩子变为y节点的右孩子，y左孩子的父节点变为了x 
  15.     * 2.x节点变为y节点的左孩子，y变为x父节点的子节点 
  16.     * 3.x变为了y的子孩子，x的父节点变为y 
  17.     * 每个节点的父节点，左右孩子节点都要注意维护 
  18.     */  
  19.    private void leftRotate(RBNode<T> x){  
  20.        //将x节点的右孩子修改为y节点的左孩子  
  21.        RBNode<T> y = x.right;  
  22.        x.right = y.left;  
  23.   
  24.        //如果y的左孩子不是null，修改左孩子的父节点，左孩子其他节点不需要变化  
  25.        if(y.left != null)  
  26.            y.left.parent = x;  
  27.   
  28.        //y节点的父节点修改为x的父节点,左孩子变为了x，右孩子不需要修改  
  29.        y.parent = x.parent;  
  30.   
  31.        if(x.parent == null)  
  32.            //如果x的父节点为null，则x原来为根节点，现在根节点修改为y  
  33.            this.root = y;  
  34.        else {  
  35.            //判断x是父节点的左孩子还是右孩子，为父节点的子节点赋值  
  36.            if(x == x.parent.left)  
  37.                x.parent.left = y;  
  38.            else  
  39.                x.parent.right = y;  
  40.        }  
  41.   
  42.        y.left = x;  
  43.        //x的父节点修改为y  
  44.        x.parent = y;  
  45.   
  46.    }  
 /**
     * 节点左旋
     * @param x 旋转时作为轴的节点
     *
     *        X                     Y
     *     /    \                /    \
     *    A     Y     ->        X     RB
     *   / \   / \            /  \
     *  LA RA LB  RB         A  LB
     *                      / \
     *                     LA RA
     *
     * 节点左旋的主要工作：
     * 1.x节点的左孩子变为y节点的右孩子，y左孩子的父节点变为了x
     * 2.x节点变为y节点的左孩子，y变为x父节点的子节点
     * 3.x变为了y的子孩子，x的父节点变为y
     * 每个节点的父节点，左右孩子节点都要注意维护
     */
    private void leftRotate(RBNode<T> x){
        //将x节点的右孩子修改为y节点的左孩子
        RBNode<T> y = x.right;
        x.right = y.left;

        //如果y的左孩子不是null，修改左孩子的父节点，左孩子其他节点不需要变化
        if(y.left != null)
            y.left.parent = x;

        //y节点的父节点修改为x的父节点,左孩子变为了x，右孩子不需要修改
        y.parent = x.parent;

        if(x.parent == null)
            //如果x的父节点为null，则x原来为根节点，现在根节点修改为y
            this.root = y;
        else {
            //判断x是父节点的左孩子还是右孩子，为父节点的子节点赋值
            if(x == x.parent.left)
                x.parent.left = y;
            else
                x.parent.right = y;
        }

        y.left = x;
        //x的父节点修改为y
        x.parent = y;

    }

右旋

    右旋的机制和左旋相同，只改变了旋转的方向，如下图所示。


节点右旋实现：

左旋右旋很好理解，关键是节点位置变化后，需要细心维护节点的父亲和孩子节点的变化。

[java] view plain copy
print ?
  1. /** 
  2.      * 节点右旋 
  3.      * @param x 旋转时作为轴的节点 
  4.      * 
  5.      *        |                     | 
  6.      *        X                     Y 
  7.      *     /    \                /    \ 
  8.      *    Y     B     ->        LA     X 
  9.      *   / \   / \                   /  \ 
  10.      *  LA RA LB  RB                RA  B 
  11.      *                                 / \ 
  12.      *                                LB RB 
  13.      * 
  14.      * 节点左旋的主要工作： 
  15.      * 1.y节点的右孩子变为x节点的左孩子，y右孩子的父节点变为了x 
  16.      * 2.x节点变为y节点的右孩子，x变为y父节点的子节点 
  17.      * 3.x变为了y的子孩子，x的父节点变为y 
  18.      * 每个节点的父节点，左右孩子节点都要注意维护 
  19.      */  
  20.     private void rightRotate(RBNode<T> x){  
  21.         //将x节点的左孩子修改为y节点的右孩子  
  22.         RBNode<T> y = x.left;  
  23.         x.left = y.right;  
  24.   
  25.         //如果y的右孩子不是null，修改右孩子的父节点，右孩子其他节点不需要变化  
  26.         if(y.right != null)  
  27.             y.right.parent = x;  
  28.   
  29.         //y节点的父节点修改为x的父节点,右孩子变为了x，左孩子不需要修改  
  30.         y.parent = x.parent;  
  31.   
  32.   
  33.         if(x.parent == null)  
  34.             //如果x的父节点为null，则x原来为根节点，现在根节点修改为y  
  35.             this.root = y;  
  36.         else {  
  37.             //判断x是父节点的左孩子还是右孩子，为父节点的子节点赋值  
  38.             if(x == x.parent.left)  
  39.                 x.parent.left = y;  
  40.             else  
  41.                 x.parent.right = y;  
  42.         }  
  43.   
  44.         y.right = x;  
  45.         //x的父节点修改为y  
  46.         x.parent = y;  
  47.   
  48.     }  
/**
     * 节点右旋
     * @param x 旋转时作为轴的节点
     *
     *        |                     |
     *        X                     Y
     *     /    \                /    \
     *    Y     B     ->        LA     X
     *   / \   / \                   /  \
     *  LA RA LB  RB                RA  B
     *                                 / \
     *                                LB RB
     *
     * 节点左旋的主要工作：
     * 1.y节点的右孩子变为x节点的左孩子，y右孩子的父节点变为了x
     * 2.x节点变为y节点的右孩子，x变为y父节点的子节点
     * 3.x变为了y的子孩子，x的父节点变为y
     * 每个节点的父节点，左右孩子节点都要注意维护
     */
    private void rightRotate(RBNode<T> x){
        //将x节点的左孩子修改为y节点的右孩子
        RBNode<T> y = x.left;
        x.left = y.right;

        //如果y的右孩子不是null，修改右孩子的父节点，右孩子其他节点不需要变化
        if(y.right != null)
            y.right.parent = x;

        //y节点的父节点修改为x的父节点,右孩子变为了x，左孩子不需要修改
        y.parent = x.parent;


        if(x.parent == null)
            //如果x的父节点为null，则x原来为根节点，现在根节点修改为y
            this.root = y;
        else {
            //判断x是父节点的左孩子还是右孩子，为父节点的子节点赋值
            if(x == x.parent.left)
                x.parent.left = y;
            else
                x.parent.right = y;
        }

        y.right = x;
        //x的父节点修改为y
        x.parent = y;

    }

3. 红黑树的插入操作

    红黑树的插入操作主要分为以下几个步骤：

  1. 找到插入节点的位置（这里位置的寻找和二叉搜索树的方式相同）
  2. 插入成功后对红黑树的性质进行维护调整
以下代码是查找插入位置的代码具体实现：
[java] view plain copy
print ?
  1. public void insert(T key){  
  2.        RBNode<T> node = new RBNode<>(key,RED,null,null,null);  
  3.        if(node != null){  
  4.            insertNode(node);  
  5.        }  
  6.    }  
  7.   
  8.    private void insertNode(RBNode<T> node){  
  9.   
  10.        //首先需要找到插入节点的位置，这里和二叉搜索树的过程是一样的  
  11.        //从根节点开始遍历  
  12.        RBNode<T> cur = this.root;  
  13.        RBNode<T> p = null;  
  14.        while (cur != null){  
  15.            //记录最后插入位置的父节点  
  16.            p = cur;  
  17.   
  18.            int cmp = node.getKey().compareTo(cur.key);  
  19.            if(cmp >0){  
  20.                cur = cur.right;  
  21.            }else {  
  22.                cur = cur.left;  
  23.            }  
  24.        }  
  25.   
  26.        //修改node的父节点  
  27.        node.parent = p;  
  28.   
  29.        //判断node是插在左节点还是右节点  
  30.        if(p != null){  
  31.            int cmp = node.getKey().compareTo(p.key);  
  32.   
  33.            if(cmp < 0){  
  34.                p.left = node;  
  35.            }else {  
  36.                p.right = node;  
  37.            }  
  38.        }else {  
  39.            this.root = node;  
  40.        }  
  41.   
  42.   
  43.        //插入之后对红黑树进行调整  
  44.        insertFixUp(node);  
  45.   
  46.    }  
 public void insert(T key){
        RBNode<T> node = new RBNode<>(key,RED,null,null,null);
        if(node != null){
            insertNode(node);
        }
    }

    private void insertNode(RBNode<T> node){

        //首先需要找到插入节点的位置，这里和二叉搜索树的过程是一样的
        //从根节点开始遍历
        RBNode<T> cur = this.root;
        RBNode<T> p = null;
        while (cur != null){
            //记录最后插入位置的父节点
            p = cur;

            int cmp = node.getKey().compareTo(cur.key);
            if(cmp >0){
                cur = cur.right;
            }else {
                cur = cur.left;
            }
        }

        //修改node的父节点
        node.parent = p;

        //判断node是插在左节点还是右节点
        if(p != null){
            int cmp = node.getKey().compareTo(p.key);

            if(cmp < 0){
                p.left = node;
            }else {
                p.right = node;
            }
        }else {
            this.root = node;
        }


        //插入之后对红黑树进行调整
        insertFixUp(node);

    }

      以上代码比较容易理解，最后主要是讲解insertFixUp(node)函数对红黑树的性质进行维护，通过以上代码我们可以发现新插入节点是红色节点，那么来分析一下什么情况会破坏红黑树的性质，首先如果插入节点的父节点是黑色的，那么很理想，不需要对红黑树进行调整，如果父节点为红色，那么很遗憾与红黑树的性质发生了冲突，所以首要前提是插入节点父节点为红色节点。

      在满足父节点为红色的情况下，分为以下三种情况需要对红黑树进行不同的变色和旋转调整（以下情况的前提是插入节点的父节点为左孩子）：

  1. 插入节点(z)的叔叔节点(y)是红色的：这种情况只要把z.parent和y修改为黑色，这样解决了z和z.parent都是红色的问题，同时把z.p.p变为红色，这样保证了树的黑色高度不变，同时将z修改为z.p.p来继续检查。这样操作后，z可能满足1，2，3中的任意一种情况，或者直接z.p为黑色节点直接退出。
  2. 插入节点(z)的叔叔节点(y)是黑色(或者叔叔节点不存在)并且z是一个右孩子：此时以z.parent为轴左旋，并且z和parent互换，此时的z和z.parent还是都为红色，这是z的特征正好满足3的情况。
  3. 插入节点(z)的叔叔节点(y)是黑色(或者叔叔节点不存在)并且z是一个左孩子：这时把z.parent修改为黑色，z.p.p修改为红色，再以z.p.p为轴右旋，因为y为黑色，所以并不会产生颜色冲突，同时替换z.p.p的和z.p同为黑色，也不会影响高度（因为z.p开始时是红色才需要调整，所以z.p.p一定是黑色）。
            </div>***重点内容***
天_河
关注
专栏目录
JAVA日记
06-24
JAVA日记JAVA日记
浅谈java日志格式化
08-26
浅谈Java日志格式化 在软件开发中，日志是一个非常重要的数据，特别是在程序发生异常时，日志可以提供非常有价值的信息。但是，并不是打印的日志越多越好，我们需要的是有用的日志。下面我们来讨论一下Java日志格式...
Java日志
zhao1949的专栏
10-12 743
http://www.cnblogs.com/bird-li/p/4696662.html *************************************************         日志对于一个系统来说非常重要，查找异常信息、分析系统运行情况等都需要用到日志。所以无论是JDK还是第三方都提供了关于日志的相关工具，本文分别介绍以下几种工具，以及各种工具间的整合、
万字长文带你了解Java日志框架
最新发布
再小的帆也能远航，把分享变成一种习惯
08-14 1005
日志的重要性不用我多说了，日志，简单来说就是记录。用来记录程序运行时发生的事情。比如，程序启动了、执行了某个操作、遇到了问题等等，这些都可以通过日志记录下来。想象一下，你开了一家店，每天的营业额、顾客的反馈、商品的进出、库存等等，你都会记录下来。这就像是程序的日志。
Java 应用中的日志
芋道源码
10-17 448
点击上方“芋道源码”，选择“置顶公众号”技术文章第一时间送达！源码精品专栏 精尽 Dubbo 原理与源码 69 篇精尽 Netty 原理与源码 61 篇中文详细注释的开源...
Java之日志
daimenglaoshi的博客
07-16 2367
日志
java 日志的数据脱敏的实现方法
08-26
Java日志数据脱敏是为了确保在记录日志时，敏感信息不会被泄露，从而保护用户隐私和企业数据安全。在本文中，我们将探讨如何在Java应用程序中实现这一目标。 首先，理解数据脱敏的重要性至关重要。在处理包含敏感...
efk7.13搜集java日志-filebeat配置详解
06-29
efk7.13搜集java日志—filebeat配置详解笔记总结
java日志文件过滤
08-09
总的来说，这个“java日志文件过滤”项目提供了一个便捷的工具，帮助开发者快速处理和分析日志数据，提高了问题排查和系统监控的效率。通过学习和理解这个项目，你可以深化对Java日志处理、文件I/O和条件过滤等技术...
java代码实例-日志规范史上最全java日志攻略（附教程）
06-16
日志框架 JAVA中现有的日志框架 JUL "JUL入门使用 日志的级别 Appender的介绍 日志的布局和格式" Log4J "Log4J的入门使用 Log4j的配置 输出日志文件 将日志信息存入数据库" Apache JCL "common log介绍 log中的接口...
Java| Java日志
YvesHe的专栏
09-07 265
Java日志组件 Java 日志 API 由以下三个核心组件组成：Loggers：Logger 负责捕捉事件并将其发送给合适的 Appender。Appenders：也被称为 Handlers，负责将日志事件记录到目标位置。在将日志事件输出之前， Appenders 使用Layouts来对事件进行格式化处理。Layouts：也被称为 Formatters，它负责对日志事件中的数据进行转换和格式化。Layouts 决定了数据在一条日志记录中的最终形式。 当 Logger 记录一个事件时，它将事件转发给适当
JAVA日志使用
qq_44126768的博客
01-04 197
[转]JAVA日志使用 原创 ...
Java日志系统研究
yanboy的专栏
06-16 279
Java日志系统研究   日志，源于log，有航海日志的意思。指记录海员记录每天的行程，生活及发生的事件。在软件开发领域，用来监控代码中变量变化，跟踪代码运行的轨迹，在开发环境中担当调试器作用，向控制台或文件输出信息。   几乎所有的软件开发语言（平台）都有自己的日志系统，java，.net，ruby，php等。在java领域，存在大量的日志组件，open-open收录了21个日志组件。 从功能...
java日志（全）
spring_zhangH的博客
12-22 510
java日志 SLF4j是日志门面api，log4j、log4j2、logback才是真正的日志实现库。 各个库单独使用 1 log4j <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.1...
Java - 日志（入门篇）
OneFine的技术博客
03-04 1130
一、日志框架 日志门面：日志的统一的接口层（抽象层） 日志实现：日志接口的实现层 日志门面 （日志的抽象层） 日志实现 JCL（Jakarta Commons Logging） SLF4j（Simple Logging Facade for Java） jboss-logging Log4j JUL（java.util.logging） Log4j2 Logback ...
Java日志框架解析：从JUL到Logback
"Java日志笔记" 在Java开发中，日志扮演着至关重要的角色，它可以帮助开发者记录程序运行情况，定位错误，以及提取关键信息。这篇笔记主要介绍了Java日志的一些基础知识，包括常见的Java日志框架和它们之间的关系。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值