红黑树JAVA代码实现

已于 2022-03-06 21:06:24 修改
阅读量722 收藏 3
点赞数
分类专栏： 复习总结 文章标签： java 算法 数据结构
于 2020-02-20 01:23:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GQCMYS/article/details/104403690
版权 
//手写红黑树
package com.nko.tree;

/**
 * 1.创建RBTree，定义颜色
 * 2.创建RBNode
 * 3.辅助方法定义：parentOf(node)，isRed(node)，setRed(node)，setBlack(node)，inOrderPrint()
 * 4.左旋方法定义：leftRotate(node)
 * 5.右旋方法定义：rightRotate(node)
 * 6.公开插入接口方法定义：insert(K key, V value)
 * 7.内部插入接口方法定义：insert(RBNode node)
 * 8.修正插入导致红黑树失衡的方法定义：insertFixUp(RBNode node)
 * 9.测试红黑树正确性
 */
public class RBTree<K extends Comparable<K>, V> {
    //定义颜色
    private static boolean RED = true;
    private static boolean BLACK = false;
    private RBNode root;

    public RBNode getRoot() {
        return root;
    }

    static class RBNode<K extends Comparable<K>, V> {
        private RBNode parent;
        private RBNode left;
        private RBNode right;
        private boolean color;
        private K key;
        private V value;
        //树根的引用

        public RBNode(RBNode parent, RBNode left, RBNode right, boolean color, K key, V value) {
            this.parent = parent;
            this.left = left;
            this.right = right;
            this.color = color;
            this.key = key;
            this.value = value;
        }

        public RBNode() {
        }

        public RBNode getParent() {
            return parent;
        }

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

        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 boolean isColor() {
            return color;
        }

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

        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;
        }
    }

    /**
     * 获取当前节点的父节点
     *
     * @param node
     * @return
     */
    private RBNode parentOf(RBNode node) {
        if (node != null) {
            return node.parent;
        }
        return null;
    }

    /**
     * 节点是否为红色
     *
     * @param node
     * @return
     */
    private boolean isRed(RBNode node) {
        if (node != null) {
            return node.color == RED;
        }
        return false;
    }

    /**
     * 节点是否为黑色
     *
     * @param node
     * @return
     */
    private boolean isBlack(RBNode node) {
        if (node != null) {
            return node.color == BLACK;
        }
        return false;
    }

    /**
     * 设置节点为红色
     *
     * @param node
     */
    private void setRed(RBNode node) {
        if (node != null) {
            node.color = RED;
        }
    }

    /**
     * 设置节点为黑色
     *
     * @param node
     */
    private void setBlack(RBNode node) {
        if (node != null) {
            node.color = BLACK;
        }
    }

    /**
     * 中序打印二叉树
     */
    public void inOrderPrint() {
        inOrderPrint(this.root);
    }

    private void inOrderPrint(RBNode node) {
        if (node != null) {
            inOrderPrint(node.left);
            System.out.println("key:" + node.key + ",value:" + node.value);
            inOrderPrint(node.right);
        }
    }

    /**
     * 插入节点
     *
     * @param key
     * @param value
     */
    public void insert(K key, V value) {
        RBNode node = new RBNode();
        node.setKey(key);
        node.setValue(value);
        //新节点一定为红色
        node.setColor(RED);
        insert(node);
    }

    private void insert(RBNode node) {
        //1.查找当前node的父节点
        RBNode parent = null;
        RBNode x = this.root;
        while (x != null) {
            parent = x;
            //cmp > 0 说明node.key大于x.key 需要到x的右子树查找
            //cmp == 0 说明node.key对于x.key 需要进行替换操作
            //cmp < 0 说明node.key小于x.key 需要到x的左子树查找
            int cmp = node.key.compareTo(x.key);
            if (cmp > 0) {
                x = x.right;
            } else if (cmp == 0) {
                x.setValue(node.getValue());
                return;
            } else {
                x = x.left;
            }
        }
        node.parent = parent;
        if (parent != null) {
            //判断node与parent的key谁大
            int cmp = node.key.compareTo(parent.key);
            if (cmp > 0) {
                //当前node的key比parent的key大，需要把node放入parent的右子节点
                parent.right = node;
            } else {
                //当前node的key比parent的key小，需要把node放入parent的左子节点
                parent.left = node;
            }
        } else {
            this.root = node;
        }
        //需要调用修复红黑树平衡的方法
        insertFixUp(node);
    }

    /**
     * 插入后修复红黑树平衡的方法
     * 1.红黑树为空树，将根节点染色为黑色
     * 2.插入节点的key已经存在，不需要处理
     * 3.插入节点的父节点为黑色，因为你所插入的路径，黑色节点没有变化，所以红黑树依然平衡，所以不需要处理
     * <p>
     * 4.插入节点的父节点为红色
     * 4.1：叔叔节点存在，并且为红色（父-叔 双红），将父亲和叔叔染色为黑色，将爷爷染色为红色，并且再以爷爷节点为当前节点，进行下一轮处理
     * 4.2：叔叔节点不存在，或者为黑色，父节点为爷爷节点的左子树
     * 4.2.1：插入节点为其父节点的左子节点（LL情况），将父亲节点染色为黑色，将爷爷节点染色为红色，然后以爷爷节点右旋，就完成了
     * 4.2.2：插入节点为其父节点的右子节点（LR情况），以父亲节点进行一次左旋，得到LL双红的情景（4.2.1），然后指定父亲节点为当前节点进行下一轮处理
     * 4.3：叔叔节点不存在。或者为黑色，父节点为爷爷节点的右子树
     * 4.3.1：插入节点为其父节点的右子节点（RR情况），将父亲节点染色为黑色，将爷爷节点染色为红色，然后以爷爷节点左旋，就完成了
     * 4.3.2：插入节点为其父节点的左子节点（RL情况），以父亲节点进行一次右旋，得到RR双红的情景（4.3.1），然后指定父亲节点为当前节点进行下一轮处理
     */

    private void insertFixUp(RBNode node) {
        //第一种情况
        this.root.setColor(BLACK);

        //第四种情况
        RBNode parent = parentOf(node);
        RBNode gparent = parentOf(parent);
        if (parent != null && isRed(parent)) {
            //如果父节点为红色，那么一定存在爷爷节点，因为根节点不可能是红色
            RBNode uncle = null;
            if (parent == gparent.left) {
                uncle = gparent.right;
                //情景4.1：叔叔节点存在且为红色（父-叔 双红）
                if (uncle != null && isRed(uncle)) {
                    //将父亲和叔叔染色为黑色，将爷爷染色为红色，并且再以爷爷节点为当前节点进行下一轮处理
                    setBlack(parent);
                    setBlack(uncle);
                    setRed(gparent);
                    insertFixUp(gparent);
                    return;
                }
                //情景4.2：叔叔节点不存在，或者为黑色，父节点为爷爷节点的左子树
                if (uncle == null || isBlack(uncle)) {
                    //情景4.2.1：插入节点为其父节点的左子节点（LL情况），将父亲节点染色为黑色，将爷爷节点染色为红色，然后以爷爷节点右旋，就完成了
                    if (node == parent.left) {
                        setBlack(parent);
                        setRed(gparent);
                        rightRotate(gparent);
                        return;
                    }
                    //情景4.2.2：插入节点为其父节点的右子节点（LR情况），以父亲节点进行一次左旋，得到LL双红的情景（4.2.1），然后指定父亲节点为当前节点进行下一轮处理
                    if (node == parent.right) {
                        leftRotate(parent);
                        insertFixUp(parent);
                        return;
                    }
                }
            } else {
                uncle = gparent.left;
                //父亲节点为爷爷节点的右子树
                //情景4.1：叔叔节点存在且为红色（父-叔 双红）
                if (uncle != null && isRed(uncle)) {
                    //将父亲和叔叔染色为黑色，将爷爷染色为红色，并且再以爷爷节点为当前节点进行下一轮处理
                    setBlack(parent);
                    setBlack(uncle);
                    setRed(gparent);
                    insertFixUp(gparent);
                    return;
                }

                //情景4.3：叔叔节点不存在。或者为黑色，父节点为爷爷节点的右子树
                if (uncle == null || isBlack(uncle)) {
                    //情景4.3.1：插入节点为其父节点的右子节点（RR情况），将父亲节点染色为黑色，将爷爷节点染色为红色，然后以爷爷节点左旋，就完成了
                    if (node == parent.right) {
                        setBlack(parent);
                        setRed(gparent);
                        leftRotate(gparent);
                        return;
                    }
                    //情景4.3.2：插入节点为其父节点的左子节点（RL情况），以父亲节点进行一次右旋，得到RR双红的情景（4.3.1），然后指定父亲节点为当前节点进行下一轮处理
                    if (node == parent.left) {
                        rightRotate(parent);
                        insertFixUp(parent);
                        return;
                    }
                }
            }
        }
    }


    /**
     * 左旋示意图
     * 左旋示意图：左旋X节点
     *      P           p
     *      |           |
     *      x           y
     *     / \    -->  / \
     *    lx  y       x   ry
     *       / \     / \
     *      ly ry   lx  ly
     * <p>
     * 1.将y的左子节点的父节点更新为x，并将x的右子节点指向y的左子节点（ly）
     * 2.当x的父节点（不为空时），更新y的父节点为x的父节点，并将x的父节点指定子树（当前x的子树位置）指定为y
     * 3.将x的父节点更新为y，将y的左子节点更新为x
     */

    private void leftRotate(RBNode x) {
        //获取当前y节点
        RBNode y = x.right;
        //1.将x的右子节点指向y的左子节点（ly）
        x.right = y.left;
        //将y的左子节点的父节点更新为x
        if (y.left != null) {
            y.left.parent = x;
        }
        //2.当x的父节点（不为空时），更新y的父节点为x的父节点，并将x的父节点指定子树（当前x的子树位置）指定为y
        if (x.parent != null) {
            y.parent = x.parent;
            if (x == x.parent.left) {
                x.parent.left = y;
            } else {
                x.parent.right = y;
            }
        } else {
            //说明x为根节点，此时需要更新y为根节点引用
            this.root = y;
            this.root.parent = null;
        }
        //3.将x的父节点更新为y，将y的左子节点更新为x
        x.parent = y;
        y.left = x;
    }

    /**
     * 右旋方法
     * 右旋示意图：右旋y节点
     * <p>
     *      P               P
     *      |               |
     *      y               x
     *     / \    -->      / \
     *    x  ry           lx  y
     *   / \                 / \
     *  lx ly               ly ry
     * <p>
     * 1.将y的左子节点指向x的右子节点，并更新x的右子节点的父节点为y
     * 2.当y的父节点不为空时，更新x的父节点为y的父节点，更新y的父节点指定子节点（y当前的位置）为x
     * 3.更新y的父节点为x，更新x的右子节点为y
     */

    private void rightRotate(RBNode y) {
        //获取当前x的位置
        RBNode x = y.left;
        //1.将y的左子节点指向x的右子节点，并更新x的右子节点的父节点为y
        y.left = x.right;
        if (x.right != null) {
            x.right.parent = y;
        }
        //2.当y的父节点不为空时，更新x的父节点为y的父节点，更新y的父节点指定子节点（y当前的位置）为x
        if (y.parent != null) {
            x.parent = y.parent;
            if (y == y.parent.left) {
                y.parent.left = x;
            } else {
                y.parent.right = x;
            }
        } else {
            this.root = x;
            this.root.parent = null;
        }
        //3.更新y的父节点为x，更新x的右子节点为y
        y.parent = x;
        x.right = y;
    }
}


//打印红黑树树形结构
package com.nko.tree;


// TreeOperation.java
public class TreeOperation {
    /*
    树的结构示例：
              1
            /   \
          2       3
         / \     / \
        4   5   6   7
    */

    // 用于获得树的层数
    public static int getTreeDepth(RBTree.RBNode root) {
        return root == null ? 0 : (1 + Math.max(getTreeDepth(root.getLeft()), getTreeDepth(root.getRight())));
    }


    private static void writeArray(RBTree.RBNode currNode, int rowIndex, int columnIndex, String[][] res, int treeDepth) {
        // 保证输入的树不为空
        if (currNode == null) return;
        // 先将当前节点保存到二维数组中
        res[rowIndex][columnIndex] = String.valueOf(currNode.getKey() + "-" + (currNode.isColor() ? "R" : "B") + "");

        // 计算当前位于树的第几层
        int currLevel = ((rowIndex + 1) / 2);
        // 若到了最后一层，则返回
        if (currLevel == treeDepth) return;
        // 计算当前行到下一行，每个元素之间的间隔（下一行的列索引与当前元素的列索引之间的间隔）
        int gap = treeDepth - currLevel - 1;

        // 对左儿子进行判断，若有左儿子，则记录相应的"/"与左儿子的值
        if (currNode.getLeft() != null) {
            res[rowIndex + 1][columnIndex - gap] = "/";
            writeArray(currNode.getLeft(), rowIndex + 2, columnIndex - gap * 2, res, treeDepth);
        }

        // 对右儿子进行判断，若有右儿子，则记录相应的"\"与右儿子的值
        if (currNode.getRight() != null) {
            res[rowIndex + 1][columnIndex + gap] = "\\";
            writeArray(currNode.getRight(), rowIndex + 2, columnIndex + gap * 2, res, treeDepth);
        }
    }


    public static void show(RBTree.RBNode root) {
        if (root == null) System.out.println("EMPTY!");
        // 得到树的深度
        int treeDepth = getTreeDepth(root);

        // 最后一行的宽度为2的（n - 1）次方乘3，再加1
        // 作为整个二维数组的宽度
        int arrayHeight = treeDepth * 2 - 1;
        int arrayWidth = (2 << (treeDepth - 2)) * 3 + 1;
        // 用一个字符串数组来存储每个位置应显示的元素
        String[][] res = new String[arrayHeight][arrayWidth];
        // 对数组进行初始化，默认为一个空格
        for (int i = 0; i < arrayHeight; i++) {
            for (int j = 0; j < arrayWidth; j++) {
                res[i][j] = " ";
            }
        }

        // 从根节点开始，递归处理整个树
        // res[0][(arrayWidth + 1)/ 2] = (char)(root.val + '0');
        writeArray(root, 0, arrayWidth / 2, res, treeDepth);

        // 此时，已经将所有需要显示的元素储存到了二维数组中，将其拼接并打印即可
        for (String[] line : res) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < line.length; i++) {
                sb.append(line[i]);
                if (line[i].length() > 1 && i <= line.length - 1) {
                    i += line[i].length() > 4 ? 2 : line[i].length() - 1;
                }
            }
            System.out.println(sb.toString());
        }
    }
}

//测试类
package com.nko.tree;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class RBTreeTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        RBTree<String,Object> rbt = new RBTree<String, Object>();
        while (true){
            System.out.println("请输入key：");
            String key = scanner.next();
            System.out.println();
            rbt.insert(key,null);

            Map map = new HashMap();

            TreeOperation.show(rbt.getRoot());
        }
    }
}
java算法实现红黑树完整代码示例
08-28
"java算法实现红黑树完整代码示例" 红黑树（英语：Red–black tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。红黑树的另一种定义是含有红黑链接并满足下列条件的...
Java红黑树代码实现
weixin_42591413的博客
02-10 255
Java红黑树是一种自平衡二叉搜索树，它是在二叉查找树的基础上添加了一些限制，以保证树的平衡。红黑树的着色性质，即每个节点要么是红色的，要么是黑色的，并且有以下几条性质： 每个节点要么是红色的，要么是黑色的。 根节点是黑色的。 每个叶子节点都是黑色的。 如果一个节点是红色的，那么它的子节点一定是黑色的。 对于任意一个节点，从该节点到其子孙节点的所有路径上包含相同数目的黑色节点。 下面是一个Ja...
java红黑树代码实现
weixin_35749796的博客
02-15 228
红黑树是一种自平衡二叉查找树，它在保持二叉查找树基本性质的同时，通过对节点进行染色，保持了树的平衡，从而保证了最坏情况下的时间复杂度为 O(log n)。 下面是一个简单的 Java 实现： ```java public class RedBlackTree<K extends Comparable, V> { private static final boolean RED ...
Java中的红黑树（如果想知道Java中有关红黑树的知识点，那么只看这一篇就足够了！）
最新发布
秋刀鱼不做梦的编程日常
09-18 6239
Java中的红黑树（如果想知道Java中有关红黑树的知识点，那么只看这一篇就足够了！）
红黑树理解以及Java实现
热门推荐
qq_41854763的博客
09-13 1万+
我对红黑树的理解 红黑树本身并不复杂，只是在插入删除的时候情况比较多，如果强行记忆的话会显得比较困难，而且容易忘记。所以以前对红黑树一直没有很好的掌握。恰好这次借着复习数据结构的机会，静下心来仔细的学习了一下红黑树，所以用这篇文章把我对红黑树的操作的理解记录下来，在理解的基础上记忆会容易得多，这样以后就不用重复学习啦！ 1. 红黑树的定义 红黑树是一颗二叉查找树，且具有如下...
红黑树(二)之Java实现
Manofletters的博客
02-15 644
红黑树的原理以及Java代码实现红黑树
Java-红黑树的实现
xhmico的博客
04-12 1331
数据结构可视化-红黑树因为红黑树中有变色左旋右旋等变化，不是很容易理解，如果能自己对红黑树进行操作，那么这些概念上的东西相对而言就好接受一点了。红黑树是一种自平衡二叉查找树，和AVL 树类似，都是在进行插入和删除时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。红黑树虽然复杂，但它的最坏情况运行时间仍非常好，并且在实践中效率很高，它可以在O(logn)实践内进行查找、插入和删除操作，其性能要优于AVL 树。（1）其节点要么是红色，要么是黑色（2）根节点是黑色的（3）每个叶子节点都是黑色的。
红黑树实现（java代码）
10-07
红黑树创建，插入，删除操作代码。包括创建，插入操作，删除操作，代码有详细的注释，java代码实现。
java 红黑树实现.rar
04-27
在Java中，红黑树被广泛应用于`java.util.TreeMap`、`java.util.TreeSet`以及`java.util.HashMap`的内部实现。 红黑树的特性： 1. 每个节点要么是红色，要么是黑色。 2. 根节点是黑色。 3. 所有叶子节点（NIL或空...
红黑树实现java代码
11-01
红黑树实现java代码，供大家参考，具体详解请参见我的博客http://blog.csdn.net/clamclam/article/details/49545477
红黑树的Java实现参考源码
02-18
在提供的链接博客中，博主详细讲解了红黑树的插入、删除和查找过程，并给出了具体的Java代码实现。这是一份很好的学习资料，通过阅读源码，你可以深入理解红黑树的内部机制。 在压缩包文件`src`中，可能包含了实现...
java 红黑树的代码。
laocooon的博客
03-16 275
【代码】java 红黑树的代码。
数据结构与算法【红黑树】的Java实现+图解
zmbwcx的博客
11-22 940
红黑树也是一种自平衡的二叉搜索树，较之 AVL，插入和删除时旋转次数更少。首先介绍代码实现会用到的概念兄弟节点：具有同一个父结点的一对节点可以互称为兄弟节点叔叔节点：父结点的兄弟节点。
红黑树以及JAVA实现
JHIII的博客
08-26 1495
红黑树是一种特殊的B树是B树种2-3-4树的一种特殊实现，红黑树保证了每个节点只会有两个子节点，通过对每个节点进行染色，然后通过不同颜色的节点组合来分别代表2-3-4的2节点、3节点、4节点树的情况。在学习红黑树之前，我们需要先去了解2-3-4树。红黑树，本质上其实就是将一个B树（我们这里讨论2-3-4树）转化为一个二叉树。那么如何去转化的同时又能继承B树绝对平衡性呢？答案就是通过染色和旋转，到这里打住，让我们先来看红黑树的定义所有的节点不是黑色就是红色根节点是黑色的所有叶子节点是黑色的。...
Java代码实现红黑树
yiguang_820的博客
04-03 1020
目录： 红黑树的特性 节点不是红色就是黑色 根节点为黑色 叶子节点为黑色 每个红色节点其子节点必须是黑色节点。 任意节点到到其任意的子节点的所有路径的黑色节点的数量相等 红黑树维持其特性的方法：变色和旋转 算法 插入 删除 一.红黑树维持其特性的方法：变色和旋转 红黑树的基本操作包括删除和添加。在删除或者添加一个节点的时候就有可能打破原有的红黑树维...
红黑树的实现（Java）
xiaochen的博客
07-03 679
Java实现红黑树 红黑树的特点以及左旋右旋的颜色变换规则
红黑树学习，Java实现
fengxiandada的博客
07-13 563
红黑树学习！通俗但不易懂，请多看几遍！
Java——红黑树
m0_60867520的博客
12-14 1927
红黑树的概念，性质，插入的详细代码及讲解，验证红黑树的代码及详解，附带详细图解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值