简单易懂的红黑树代码—java

最新推荐文章于 2023-11-22 16:35:20 发布
最新推荐文章于 2023-11-22 16:35:20 发布
阅读量465 收藏 4
点赞数
文章标签： 数据结构 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43925037/article/details/107309598
版权

首先定义一颗树：

/**
 * 红黑树
 * @param <K>
 * @param <V>
 *
 *     红黑树的特性：
 *     1. 根节点必须是黑色
 *     2. 叶子节点（NIL）必须是黑色
 *     3. 从根节点到叶子节点的黑色节点的数量一致
 *     4. 不能有两个相邻的红色节点
 *     5. 红黑树要么是红色/要么是黑色
 *     6. 新增节点一般是红色 （为红色不一定会破坏红黑树的特性  为黑色则一定会破坏红黑数的特性）
 */
public class RBTree <K extends Comparable,V>{

    private Boolean BLACK=false;
    private Boolean RED=true;
    private RBNode root;  // 根节点
    static class RBNode<K extends Comparable,V>{
        private RBNode left;
        private RBNode right;
        private RBNode parent;
        private K key;
        private V value;
        private Boolean color;
    }

定义基础操作方法：

/**
     *  变色
     */
    private void setColor(RBNode node,Boolean color){

        if(node == null){
            return;
        }
        node.setColor(color);
    }

    /**
     * 获取父级节点
     * @param node
     * @return
     */
    private RBNode getParent(RBNode node){
        if(node == null){
            return null;
        }

        return node.getParent();
    }
/**
     * 是否是红色
     * @param node
     * @return
     */
    private Boolean isRed(RBNode node){
        if(node == null){
            return false;
        }
        return node.getColor()==RED;
    }
 /**
     * 中序遍历
     */
    public void print(){
        RBNode node = this.root;
        print(root);
        System.out.println("root: "+node.getKey());
    }

    private void print(RBNode root){
        if(root ==null){
            return ;
        }
        print(root.left);
        String color=root.getColor()?"红色":"黑色";
        System.out.println("key:  "+ root.getKey()+"   value: "+ root.getValue()+"   color:   "+ color);
        print(root.right);
    }

定义左旋右旋：
左旋： 将右子节点的左子节点变为右子节点，将原来的右子节点指向x的父级节点。
右旋：将左子节点的右子节点变为左子节点，将原来的左子节点指向x的父级节点

/**
     * 左旋
     * 1. 找到node节点的right节点，先将y的left节点变为x的right节点，不为空的话将parent指向x；
     * 2. 将y的父级指向x的父级   将x在父级的位置指向y
     */
    private void leftRotate(RBNode x){
        RBNode y = x.right;
        x.right = y.left;
        if(y.left !=null){
            y.left.parent = x;
        }
        // 获取x的父级节点  将y的父级指向x的父级节点
        RBNode parent = getParent(x);
        if(parent !=null){
            y.parent = parent;
            if(x == parent.left){
                parent.left = y;
            }else{
                parent.right = y;
            }
        }else{
            // 表示x是root节点  直接赋值y
            this.root = y;
            y.parent = null;
        }

        x.parent = y;
        y.left = x;
    }


    /**
     * 右旋
     * 1. 找到node节点的right节点，先将y的left节点变为x的right节点，不为空的话将parent指向x；
     * 2. 将y的父级指向x的父级   将x在父级的位置指向y
     */
    private void rightRotate(RBNode x){
        RBNode y = x.left;
        x.left = y.right;
        if(y.right !=null){
            y.right.parent = x;
        }
        // 获取x的父级节点  将y的父级指向x的父级节点
        RBNode parent = getParent(x);
        if(parent !=null){
            y.parent = parent;
            if(x == parent.left){
                parent.left = y;
            }else{
                parent.right = y;
            }
        }else{
            // 表示x是root节点  直接赋值y
            this.root = y;
            y.parent = null;
        }

        x.parent = y;
        y.right = x;
    }

定义插入，及插入后调整方法：

/**
     * 对外insert接口
     * @param key
     * @param value
     */
    public void insert(K key,V value){
        RBNode node = new RBNode<>();
        node.setColor(RED);
        node.setKey(key);
        node.setValue(value);
        insert(node);
    }

    /**
     * 插入元素   先找到parent
     * @param node
     */
    private void insert(RBNode node){
        RBNode parent= null;
        RBNode root = this.root;
        while(root !=null){
            parent = root;
            int tem = node.getKey().compareTo(root.getKey());
            if(tem > 0){
                root = root.right;
            }else if(tem == 0){
                root.setValue(node.getValue());
                return;
            }else{
                root = root.left;
            }
        }
        if(parent ==null){
            this.root = node;
        }else{
            node.setParent(parent);
            int tem = node.getKey().compareTo(parent.getKey());
            if(tem > 0){
                parent.right = node;
            }else{
                parent.left = node;
            }
        }
        ficUp(node);
    }

    /**
     *  调整符合红黑树特性的操作
     *  情况分为：
     *      1.root节点为空 ，插入后将root节点班委黑色。
     *      2. 插入节点的父级节点为黑色    不违反红黑树特性 不做调整
     *      3. 插入节点已存在   insert中已覆盖
     *      4.  插入节点的父级节点为红色：{
     *          1. 如果叔叔级节点为红色  为双红   将父级节点和叔叔级节点变为黑色，将爷爷级节点变为红色  以爷爷节点进行再次处理
     *          2. 如果叔叔级节点不存在或为黑色：{
     *              1. 父级节点在爷爷级节点的left，插入节点在父级节点的left  为（LL）双红  父级变为黑色，爷爷变为红色。 以爷爷节点进行右旋
     *              2. 插入节点在父级的右侧，为（LR） 双红， 以父级节点进行左旋  变为（LL双红）
     *              3. 父级节点在爷爷级节点的右侧，插入节点在父级节点的right 为（RR）双红  父级变为黑色，爷爷变为红色。 以爷爷节点进行左旋
     *              4. 插入节点在父级的左侧 为（RL）双红 ， 以父级节点进行右旋  变为（RR）双红
     *         }
     *      }
     */
    private void ficUp(RBNode node){
        this.root.setColor(BLACK);
        RBNode parent = getParent(node);
        RBNode gParent = getParent(parent);
        if(parent !=null && isRed(parent)){
            RBNode uncle = null;
            if(gParent.left == parent){
                uncle = gParent.right;
            }else{
                uncle = gParent.left;
            }
            if(uncle != null && isRed(uncle)){
                parent.setColor(BLACK);
                uncle.setColor(BLACK);
                gParent.setColor(RED);
                ficUp(gParent);
                return;
            }else{
                if(parent == gParent.left){
                    if(parent.left == node){
                        parent.setColor(BLACK);
                        gParent.setColor(RED);
                        rightRotate(gParent);
                    }else{
                        leftRotate(parent);
                        ficUp(parent);
                        return;
                    }
                }else{
                    if(parent.left == node){
                        rightRotate(parent);
                        ficUp(parent);
                        return;

                    }else{
                        parent.setColor(BLACK);
                        gParent.setColor(RED);
                        leftRotate(gParent);
                    }
                }
            }
        }
    }

完整代码如下：



import com.sun.org.apache.xpath.internal.operations.Bool;

import java.util.Collections;
import java.util.TreeMap;

/**
 * 红黑树
 * @param <K>
 * @param <V>
 *
 *     红黑树的特性：
 *     1. 根节点必须是黑色
 *     2. 叶子节点（NIL）必须是黑色
 *     3. 从根节点到叶子节点的黑色节点的数量一致
 *     4. 不能有两个相邻的红色节点
 *     5. 红黑树要么是红色/要么是黑色
 *     6. 新增节点一般是红色 （为红色不一定会破坏红黑树的特性  为黑色则一定会破坏红黑数的特性）
 */
public class RBTree <K extends Comparable,V>{

    private Boolean BLACK=false;
    private Boolean RED=true;
    private RBNode root;  // 根节点
    static class RBNode<K extends Comparable,V>{
        private RBNode left;
        private RBNode right;
        private RBNode parent;
        private K key;
        private V value;
        private Boolean color;


        public RBNode getLeft() {
            return left;
        }

        public void setLeft(RBNode left) {
            this.left = left;
        }

        public RBNode getRight() {
            return right;
        }

        public void setRight(RBNode right) {
            this.right = right;
        }

        public RBNode getParent() {
            return parent;
        }

        public void setParent(RBNode parent) {
            this.parent = parent;
        }

        public K getKey() {
            return key;
        }

        public void setKey(K key) {
            this.key = key;
        }

        public V getValue() {
            return value;
        }

        public void setValue(V value) {
            this.value = value;
        }

        public Boolean getColor() {
            return color;
        }

        public void setColor(Boolean color) {
            this.color = color;
        }

        public RBNode() {
        }
    }
    /**
     *  变色
     */
    private void setColor(RBNode node,Boolean color){

        if(node == null){
            return;
        }
        node.setColor(color);
    }

    /**
     * 获取父级节点
     * @param node
     * @return
     */
    private RBNode getParent(RBNode node){
        if(node == null){
            return null;
        }

        return node.getParent();
    }

    /**
     * 左旋
     * 1. 找到node节点的right节点，先将y的left节点变为x的right节点，不为空的话将parent指向x；
     * 2. 将y的父级指向x的父级   将x在父级的位置指向y
     */
    private void leftRotate(RBNode x){
        RBNode y = x.right;
        x.right = y.left;
        if(y.left !=null){
            y.left.parent = x;
        }
        // 获取x的父级节点  将y的父级指向x的父级节点
        RBNode parent = getParent(x);
        if(parent !=null){
            y.parent = parent;
            if(x == parent.left){
                parent.left = y;
            }else{
                parent.right = y;
            }
        }else{
            // 表示x是root节点  直接赋值y
            this.root = y;
            y.parent = null;
        }

        x.parent = y;
        y.left = x;
    }


    /**
     * 右旋
     * 1. 找到node节点的right节点，先将y的left节点变为x的right节点，不为空的话将parent指向x；
     * 2. 将y的父级指向x的父级   将x在父级的位置指向y
     */
    private void rightRotate(RBNode x){
        RBNode y = x.left;
        x.left = y.right;
        if(y.right !=null){
            y.right.parent = x;
        }
        // 获取x的父级节点  将y的父级指向x的父级节点
        RBNode parent = getParent(x);
        if(parent !=null){
            y.parent = parent;
            if(x == parent.left){
                parent.left = y;
            }else{
                parent.right = y;
            }
        }else{
            // 表示x是root节点  直接赋值y
            this.root = y;
            y.parent = null;
        }

        x.parent = y;
        y.right = x;
    }

    /**
     * 是否是红色
     * @param node
     * @return
     */
    private Boolean isRed(RBNode node){
        if(node == null){
            return false;
        }
        return node.getColor()==RED;
    }

    /**
     * 对外insert接口
     * @param key
     * @param value
     */
    public void insert(K key,V value){
        RBNode node = new RBNode<>();
        node.setColor(RED);
        node.setKey(key);
        node.setValue(value);
        insert(node);
    }

    /**
     * 插入元素   先找到parent
     * @param node
     */
    private void insert(RBNode node){
        RBNode parent= null;
        RBNode root = this.root;
        while(root !=null){
            parent = root;
            int tem = node.getKey().compareTo(root.getKey());
            if(tem > 0){
                root = root.right;
            }else if(tem == 0){
                root.setValue(node.getValue());
                return;
            }else{
                root = root.left;
            }
        }
        if(parent ==null){
            this.root = node;
        }else{
            node.setParent(parent);
            int tem = node.getKey().compareTo(parent.getKey());
            if(tem > 0){
                parent.right = node;
            }else{
                parent.left = node;
            }
        }
        ficUp(node);
    }

    /**
     *  调整符合红黑树特性的操作
     *  情况分为：
     *      1.root节点为空 ，插入后将root节点班委黑色。
     *      2. 插入节点的父级节点为黑色    不违反红黑树特性 不做调整
     *      3. 插入节点已存在   insert中已覆盖
     *      4.  插入节点的父级节点为红色：{
     *          1. 如果叔叔级节点为红色  为双红   将父级节点和叔叔级节点变为黑色，将爷爷级节点变为红色  以爷爷节点进行再次处理
     *          2. 如果叔叔级节点不存在或为黑色：{
     *              1. 父级节点在爷爷级节点的left，插入节点在父级节点的left  为（LL）双红  父级变为黑色，爷爷变为红色。 以爷爷节点进行右旋
     *              2. 插入节点在父级的右侧，为（LR） 双红， 以父级节点进行左旋  变为（LL双红）
     *              3. 父级节点在爷爷级节点的右侧，插入节点在父级节点的right 为（RR）双红  父级变为黑色，爷爷变为红色。 以爷爷节点进行左旋
     *              4. 插入节点在父级的左侧 为（RL）双红 ， 以父级节点进行右旋  变为（RR）双红
     *         }
     *      }
     */
    private void ficUp(RBNode node){
        this.root.setColor(BLACK);
        RBNode parent = getParent(node);
        RBNode gParent = getParent(parent);
        if(parent !=null && isRed(parent)){
            RBNode uncle = null;
            if(gParent.left == parent){
                uncle = gParent.right;
            }else{
                uncle = gParent.left;
            }
            if(uncle != null && isRed(uncle)){
                parent.setColor(BLACK);
                uncle.setColor(BLACK);
                gParent.setColor(RED);
                ficUp(gParent);
                return;
            }else{
                if(parent == gParent.left){
                    if(parent.left == node){
                        parent.setColor(BLACK);
                        gParent.setColor(RED);
                        rightRotate(gParent);
                    }else{
                        leftRotate(parent);
                        ficUp(parent);
                        return;
                    }
                }else{
                    if(parent.left == node){
                        rightRotate(parent);
                        ficUp(parent);
                        return;

                    }else{
                        parent.setColor(BLACK);
                        gParent.setColor(RED);
                        leftRotate(gParent);
                    }
                }
            }
        }
    }
    /**
     * 中序遍历
     */
    public void print(){
        RBNode node = this.root;
        print(root);
        System.out.println("root: "+node.getKey());
    }

    private void print(RBNode root){
        if(root ==null){
            return ;
        }
        print(root.left);
        String color=root.getColor()?"红色":"黑色";
        System.out.println("key:  "+ root.getKey()+"   value: "+ root.getValue()+"   color:   "+ color);
        print(root.right);
    }

    
}

编写Test 类进行测试：

public class RBTest {
    public static void main(String[] args) {
    //    int a[] = { 16, 88, 7, 11, 9, 26, 18, 14, 15 };
        int a[] = { 1,5,9,2,8,4,6,3,7,15};
        RBTree tree = new RBTree();
        for(int i = 0;i<a.length;i++){
            tree.insert(a[i],null);
        }
        tree.print();
    }
}

OK !

嗯嗯！
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HashMap的工作原理和底层实现（二）红黑树的左旋、右旋
01-07
 HashMap是java最常用的容器之一，本文会通过阅读源码的方式来理解HashMap中是如何进行红黑树的左旋和右旋 一、什么是左旋和右旋  红黑树的性质 每个节点要么是黑色，要么是红色。 根节点是黑色。 每个叶子...
Java代码实现红黑树
yiguang_820的博客
04-03 893
目录： 红黑树的特性 节点不是红色就是黑色 根节点为黑色 叶子节点为黑色 每个红色节点其子节点必须是黑色节点。 任意节点到到其任意的子节点的所有路径的黑色节点的数量相等 红黑树维持其特性的方法：变色和旋转 算法 插入 删除 一.红黑树维持其特性的方法：变色和旋转 红黑树的基本操作包括删除和添加。在删除或者添加一个节点的时候就有可能打破原有的红黑树维...
java 红黑树的代码。
laocooon的博客
03-16 240
【代码】java 红黑树的代码。
数据结构与算法【红黑树】的Java实现+图解
最新发布
zmbwcx的博客
11-22 579
红黑树也是一种自平衡的二叉搜索树，较之 AVL，插入和删除时旋转次数更少。首先介绍代码实现会用到的概念兄弟节点：具有同一个父结点的一对节点可以互称为兄弟节点叔叔节点：父结点的兄弟节点。
java红黑树代码
weixin_43646100的博客
06-11 115
用java实现红黑树 增 删 改 查 package com.jason.RBT; public class redBlackTree { //num是用来记录查找了多少次 static int num = 0; //测试 public static void main(String[] args) { redBlackTree redBlack = new redBlackTree(); // int[] a = {5,7,1,12,13,19,
Java——红黑树
m0_60867520的博客
12-14 1812
红黑树的概念，性质，插入的详细代码及讲解，验证红黑树的代码及详解，附带详细图解
java8集合源码分析-Happy-With-Data-Structure:学习数据结构的一些代码，包括数组，链表，二分搜索树，集合，并查集，
06-04
哈希表的操作时间复杂度为o(1),但失去了可比较性实现的哈希表要求键必须为可比较的对象，Java8之后当哈希冲突达到一定程度后每个位置会从链表变成红黑树。 在线段树中，不考虑添加元素，即区间固定，假设区间有n个...
leetcode分类-JavaStudy:Java学习
06-29
leetcode 分类 Introduction 本项目用于学习java各种知识 记录下学习过程中的demo 目前已经有的功能 Java基础 动态代理demo 实现 反射的各种基础 反射和注解的结合 ...红黑树的实现 (看了很多篇，这
leetcode中文版-algorithm:leetcode一些示例代码
06-29
leetcode中文版 Java常见面试算法考试大全 如何使用本仓库 我会在README里面写总结跟一些技巧 大量的细节跟注释都在代码附近，遵从一个知识离代码最近的原则...在达到8个hash冲突链表后会转成红黑树， 而在理论学习的阶
Java数据结构和算法中文第二版
05-21
全书共分为15章，分别讲述了基本概念、数组、简单排序、堆和队列、链表、递归、进阶排序、二叉树、红黑树、哈希表及图形等知识。附录中则提供了运行专题Applet和例程、相关书籍和问题解答。本书提供了学完一门编程...
红黑树理解以及Java实现
热门推荐
qq_41854763的博客
09-13 1万+
我对红黑树的理解 红黑树本身并不复杂，只是在插入删除的时候情况比较多，如果强行记忆的话会显得比较困难，而且容易忘记。所以以前对红黑树一直没有很好的掌握。恰好这次借着复习数据结构的机会，静下心来仔细的学习了一下红黑树，所以用这篇文章把我对红黑树的操作的理解记录下来，在理解的基础上记忆会容易得多，这样以后就不用重复学习啦！ 1. 红黑树的定义 红黑树是一颗二叉查找树，且具有如下...
Java红黑树代码实现
weixin_42591413的博客
02-10 182
Java红黑树是一种自平衡二叉搜索树，它是在二叉查找树的基础上添加了一些限制，以保证树的平衡。红黑树的着色性质，即每个节点要么是红色的，要么是黑色的，并且有以下几条性质： 每个节点要么是红色的，要么是黑色的。 根节点是黑色的。 每个叶子节点都是黑色的。 如果一个节点是红色的，那么它的子节点一定是黑色的。 对于任意一个节点，从该节点到其子孙节点的所有路径上包含相同数目的黑色节点。 下面是一个Ja...
java红黑树代码实现
weixin_35749796的博客
02-15 169
红黑树是一种自平衡二叉查找树，它在保持二叉查找树基本性质的同时，通过对节点进行染色，保持了树的平衡，从而保证了最坏情况下的时间复杂度为 O(log n)。 下面是一个简单的 Java 实现： ```java public class RedBlackTree<K extends Comparable, V> { private static final boolean RED ...
红黑树定义及其代码实现
公众号：风景邮递Yuan的博客
06-16 694
红黑树是一种自平衡二叉查找树，它在每个节点上增加了一个存储位来表示节点的颜色，可以是红色或黑色。通过对任何一条从根到叶子节点的路径上各个节点的颜色进行约束，红黑树确保没有一条路径会比其他路径长出两倍，因此，红黑树是近似平衡的。5. 对于每个节点，从该节点到其所有后代叶子节点的简单路径上，均包含相同数目的黑色节点。4. 如果一个节点是红色的，则它的两个子节点都是黑色的。3. 每个叶子节点（NIL节点，空节点）是黑色的。1. 每个节点要么是红色，要么是黑色。2. 根节点是黑色的。
红黑树的原理及代码实现
qq_52093121的博客
06-28 926
红黑树的原理这篇博文讲解的很详细了，不熟悉红黑树的定义可以看看：红黑树的详细原理讲解咱们直接进入代码实现讲解：创建一棵红黑树，先从创建红黑树的节点开始： 1.红黑树首先是一个二叉树，所以需要一个左儿子节点的指针，右儿子节点的指针 2.红黑树是有BALCK和RED两种颜色的，所以每个节点应该有颜色 3.红黑树是Key-Value存储的 4.因为之后要进行旋转等调整，所以还需要一个父节点的信息 所以红黑树节点定义如下： 2.创建红黑树整体结构 红黑树有五个性质： 为了方便整棵红黑树的维护，我们默认叶子节点是空
红黑树实现代码+详细注释
ltrbless的博客
05-19 1522
简介 因为网上太多红黑树原理的讲解了，不需要再去讲解原理，所以在这就提供一些将原理不错的博客，然后主要是给红黑树代码的实现，用的c++语言模板实现红黑树，并附带详细注释。（目前只实现了红黑树的插入与查询操作，并可视化打印红黑树）。 红黑树插入操作的流程图：（参考：红黑树总结 - lukazan - 博客园 (cnblogs.com)，该博客用图详细解释了红黑树插入操作的事件，然后我用红色对其事件进行了编号，以便于和代码注释相对应） 红黑树的本质其实就是2-3树，在上面推荐的博客中也有提到。 代码
红黑树原理详解及代码实现
CodePanda@GPF的博客
05-23 2552
红黑树原理及代码实践
红黑树（图文详解+C语言200行代码实现）
zhao_Tao_WA的博客
07-04 2073
本文以图文形式详细介绍了红黑树的性质以及各种调整策略，包括插入调整和删除调整，最后以200行精简的C语言代码实现了红黑树
java 红黑树代码
08-20
下面是一个Java实现的红黑树代码示例： ```java // 定义红黑树的节点 class Node { int key; Node parent; Node left; Node right; int color; } // 定义红黑树 class RedBlackTree { private Node root; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值