手撕红黑树代码（Java）

已于 2023-04-20 21:05:26 修改
阅读量178 收藏 4
点赞数 5
分类专栏： 面试题 算法 Java 文章标签： java 数据结构
于 2023-04-02 12:02:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52485934/article/details/129907915
版权
面试题 同时被 3 个专栏收录
17 篇文章 0 订阅
订阅专栏
算法
13 篇文章 0 订阅
订阅专栏
Java
7 篇文章 0 订阅
订阅专栏

目录

1.特性

2.恢复二叉树特性方法：

3.插入

4.源码

        本文是我跟着视频大佬一起写的Java红黑树代码，如果想要学习红黑树还是需要自己去动手敲一下，（本文实现了红黑树的查找和插入操作）

1.特性

        在敲代码之前我们应该首先了解一下红黑树的几个特性。

  1.  根节点是黑色。
  2. 每个节点或者是黑色，或者是红色。
  3. 每个叶子节点是黑色。 [注意：这里叶子节点，是指为空的叶子节点！]
  4. 如果一个节点是红色的，则它的子节点必须是黑色的。
  5. 从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑色节点。

      我们看到这些红黑树的特性，可能觉得头大（最初我也是这么觉得），但是只要一条一条分析，其实就完全可以理解，现在有一个红黑树的图，可以稍微了解一下。

         红黑树从叶子节点（为Null）从下往根节点数，路过的黑色节点数一定相同。

        在进行学习红黑树的前面我们要先导入一个思想，红黑树的插入和删除操作会打乱红黑树的结构，所以为了继续遵守这些特性，我们需要一些操作，来使其一直保持这些特性。

        由于查找的操作很简单，它的中序遍历和二分查找的时间复杂度相同，所以我就不过多的解释，直接把方法说出了， 就是从根节点开始判断，要查找的A值和root的大小比较，A值大就与root.right比较，反之和root.left比较，重复操作就可以得到A（部分代码如下）。

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

        接下来就是比较重要的操作：插入。

2.恢复二叉树特性方法：

        由于插入可能会导致红黑树的形状改变，所以我们应该学一下恢复红黑树特性的三个方法。

1.变色

        可以将红黑树进行变色处理，黑变红，红变黑。

2.左旋

        左旋大致可以分为三个步骤，我可以看一下下面这个图：

        根据图所示，看得出来，x和y节点交换了位置，并且y节点的左子节点变为了x的右子节点，根据以上的变换我们可以分为三个步骤进行操作。         

  1. 将y节点的左子节点变为x的右子节点：我们首先将x的右子节点指向y的左子节点（首先这个步骤可以防止y的左子节点为空）,然后将y的左子节点的父节点指向x。
  2. 更新x的父节点的位置，首先判断x有没有父节点，有的话就可以将y的父节点变为x的父节点，将x的父节点变为y。如果x就是root，那么就要将y变为root。
  3. 最后一步，将x的父节点更新为y，将y的左子节点更新为x。

根据上面的步骤，我们可以得到代码：

    private  void leftRotate(RBNode x){
        RBNode y=x.right;
        //将x的右子节点指定为x的左子节点,将y的左子节点的父节点指定为x，
        x.right=y.left;
        if (y.left!=null) {
            y.left.parent=x;
        }
        //将y的父节点更新为x的父节点，将x的父节点指定为y
        if(x.parent!=null){
           x.parent=y.parent;
            if (x==x.parent.left) {
                x.parent.left=y;
            }else{
                x.parent.right=y;
            }
        }else{//y现在为根节点
            this.root=y;
            this.root.parent=null;
        }
        //将x的父节点更新为Y,将y的左子节点更新为x
        x.parent=y;
        y.left=x;
    }

3.右旋:

        与左旋类似，先看图： 

        根据图所示，看得出来，x和y节点交换了位置，并且x节点的右子节点变为了y的左子节点，根据以上的变换我们可以分为三个步骤进行操作。         

  1. 将x节点的右子节点变为y的左子节点：我们首先将y的左子节点指向x的右子节点（首先这个步骤可以防止x的右子节点为空）,然后将x的右子节点的父节点指向y。
  2. 更新y的父节点的位置，首先判断y有没有父节点，有的话就可以将x的父节点变为y的父节点，将y的父节点变为x。如果y就是root，那么就要将x变为root。
  3. 最后一步，将y的父节点更新为x，将x的右子节点更新为y。

根据上面的步骤，我们可以得到代码：

    private void rightRotate(RBNode y){
        RBNode x=y.left;
        //将y的左子节点指向x的右子节点，更新x的右子节点的父节点为y
        y.left=x.right;
        if (x.right!=null) {
            x.right.parent=y;
        }
        //当y的父节点不为空时，更新x的父节点为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;

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

至此我们已经学会了对二叉树的一些基本操作，现在我们就可以开始学习下一个部分。

3.插入

        插入也会有多种情况，主要是判断插入节点的父节点的颜色（插入节点为红色，因为插入的红色节点一定没有子节点，而把它作为其他节点的子节点时，可以将它变为黑色节点以满足上述特性），如果要插入位置的父节点为红色，这样就违反了第四条原则，（也就是两个红色的节点不能相连）。于是根据不同的类型，分为了四大类。

     1.红黑树为空树        

                处理方法：将root着色为黑色

     2.插入节点的key已经存在

                处理方法：不用处理

     3.插入节点的父节点为黑色

                处理方法：不用处理

     4.插入节点为红色

                4.1，判断插入节点的叔叔节点存在，并且是为红色（由于它的父节点为红色，那么我们可以根据第一条特性得到，他一定有爷爷节点，就是它的父节点一定有父节点，而且为黑色）

                         处理方法：将插入节点的父节点和它的叔叔节点（他们都为红色）着色为黑色，将爷爷节点染色为红色，然后再以爷爷节点为当前节点，继续递归这个操作。

                4.2，判断叔叔节点不存在，或者叔叔节点为黑色，如果插入节点的父节点为爷爷节点的左子树（left）

                        4.2.1，插入节点为父节点的左子节点（LL双红类型）

                                处理方法：将插入节点的父节点着色为黑色，将爷爷节点染色为红色，然后将爷爷节点进行右旋操作。

                        4.2.2，插入节点为父节点的右子节点（LR双红类型）

                                处理类型：将父节点左旋，（然后变为和LL双红类型一样），将插入节点的父节点着色为黑色，将爷爷节点染色为红色，然后将爷爷节点进行右旋操作。

                4.3，判断叔叔节点不存在，或者叔叔节点为黑色，如果插入节点的父节点为爷爷节点的右子树（right）

                        4.3.1，插入节点为父节点的右子节点（RR双红类型）

                                处理方法：将插入节点的父节点着色为黑色，将爷爷节点染为红色，然后将爷爷节点进行左旋操作。

                        4.3.2，插入节点为父节点的左子节点（RL双红类型）

                                处理方法：将父节点右旋，（然后变为和RR双红类型一样），将插入节点的父节点着色为黑色，将爷爷节点染为红色，然后将爷爷节点进行左旋操作。

        最终就完成了插入操作的全部，是不是挺简单的，那我们就来写一下源码。

4.源码

        首先我们先写一个RBTree类，然后在其中创建一个静态的内部类，存放着父节点，根节点，左节点，右节点，颜色和key，value。生成一个他们的get，set方法，改造一下无参方法（这些方法就不粘贴在下面了）。

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

        然后，我们定义一下颜色，RED和BLACK。

    private  static final boolean RED=true;
    private  static final boolean BLACK=false;

       然后把上面的参数写一些方法，例如，根的引用，获取当前节点的父节点，判断当前节点是否为红色，黑色等。

    /**
     * 树根的引用
     * */
    private RBNode root;

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

    /**
     *节点是否为红色
     * @param node
     * */
    private boolean isRed(RBNode node){
        if(node!=null){
            return node.color==RED;
        }
        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;
        }
    }

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

        将中序遍历方法写上，（上面写过了）。

        将左旋右旋方法写上。

        最后写的就是插入方法，（我将完整代码放在下面，插入方法就在里面，有详细的注释）。

完整代码：

package RBTree;

import javax.print.DocFlavor;
import javax.xml.soap.Node;

public class RBTree<k extends Comparable<k>,v> {
    private  static final boolean RED=true;
    private  static final boolean BLACK=false;

    /**
     * 树根的引用
     * */
    private RBNode root;

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

    /**
     *节点是否为红色
     * @param node
     * */
    private boolean isRed(RBNode node){
        if(node!=null){
            return node.color==RED;
        }
        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;
        }
    }

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

    /**
     * 中序打印的方法
     * */
    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);
        }
    }

    /**
     * 左旋
     *    * 左旋示意图：左旋X节点
     *       P           p
     *       |           |
     *       x           y
     *      / \    -->  / \
     *     lx  y       x   ry
     *        / \     / \
     *       ly ry   lx  ly
     *
     *
     *
     * 1.将y的左子节点变为x的右子节点：将x的右子节点指定为x的左子节点,将y的左子节点的父节点指定为x，
     * 2.更新X的父节点的位置：将y的父节点更新为x的父节点，将x的父节点指定为y
     * 3.将x的父节点更新为Y,将y的左子节点更新为x
     * */
    private  void leftRotate(RBNode x){
        RBNode y=x.right;
        //将x的右子节点指定为x的左子节点,将y的左子节点的父节点指定为x，
        x.right=y.left;
        if (y.left!=null) {
            y.left.parent=x;
        }
        //将y的父节点更新为x的父节点，将x的父节点指定为y
        if(x.parent!=null){
           x.parent=y.parent;
            if (x==x.parent.left) {
                x.parent.left=y;
            }else{
                x.parent.right=y;
            }
        }else{//y现在为根节点
            this.root=y;
            this.root.parent=null;
        }
        //将x的父节点更新为Y,将y的左子节点更新为x
        x.parent=y;
        y.left=x;
    }

    /**
     * 右旋
     * 右旋示意图：右旋X节点
     *      P               P
     *      |               |
     *      y               x
     *     / \    -->      / \
     *    x  ry           lx  y
     *   / \                 / \
     *  lx ly               ly ry
     *
     *
     *
     * ————————————————
     * 1.将y的左子节点指向x的右子节点，更新x的右子节点的父节点为y
     * 2.当y的父节点不为空时，更新x的父节点为y的父节点，更新y的父节点指定子节点为x
     * 3.更新x的父节点，更新y的父节点为x，x的右子节点为y
     * */
    private void rightRotate(RBNode y){
        RBNode x=y.left;
        //将y的左子节点指向x的右子节点，更新x的右子节点的父节点为y
        y.left=x.right;
        if (x.right!=null) {
            x.right.parent=y;
        }
        //当y的父节点不为空时，更新x的父节点为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;

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

    /**
     * 公开的插入
     *
     * */
    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 ){
        //从根部查找
        RBNode parent=null;
        RBNode x=this.root;

        while(x!=null){
            parent=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){
            int cmp=node.key.compareTo(parent.key);
            if(cmp>0){
                parent.right=node;
            }else{
                parent.left=node;
            }
        }else{
            this.root=node;
        }

        //调用修复颜色
        insertFixUp(node);
    }

    /**
     * 修复红黑树的方法
     * 1.红黑树为空树，将root节点染为黑色
     * 2.插入节点的key已经存在，不处理
     * 3.插入节点父节点为黑色，不用处理
     * 4.插入节点为红色：
     *        4.1叔叔节点存在并且为红色：（将爸爸和叔叔染为黑色，将爷爷染为红色）(111染色处理)，以爷爷节点为当前节点，向上处理。
     *        4.2叔叔节点不存在，或者为黑色，父亲节点为爷爷节点的左子树（lift）
     *              4.2.1：插入节点为父节点的左子节点（LL双红）：先111染色处理，将爷爷右旋
     *              4.2.2：插入节点为父节点的右子节点（LR双红）：将父节点左旋，先111染色处理，将爷爷右旋
     *        4.3叔叔节点不存在，或者为黑色，父亲节点为爷爷节点的右子树（right）
     *              4.3.1：插入节点为父节点的右子节点（RR双红）：先111染色处理，将爷爷左旋
     *              4.3.2：插入节点为父节点的左子节点（RL双红）：将父节点右旋，先111染色处理，将爷爷左旋
     * */
    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
                    if(node==parent.left){
                        setBlack(parent);
                        setRed(gparent);
                        rightRotate(gparent);
                        return;
                    }
                    //4.2.2
                    if(node==parent.right){
                        leftRotate(parent);
                        insertFixUp(parent);
                        return;
                    }
                }
            }else{
                uncle=gparent.left;
                if(uncle!=null && isRed(uncle)){
                    setBlack(parent);
                    setBlack(uncle);
                    setRed(gparent);
                    //递归
                    insertFixUp(gparent);
                    return;
                }
                //4.3
                if(uncle==null || isBlack(uncle)){
                    //4.3.1
                    if(node==parent.right){
                        setBlack(parent);
                        setRed(gparent);
                        leftRotate(gparent);
                        return;
                    }//4.3.2
                    if (node==parent.left){
                        rightRotate(parent);
                        insertFixUp(parent);
                        return;
                    }
                }
            }
        }
    }

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

             然后，我在网上复制粘贴了一个打印方法，建一个TReeOperation类：

package RBTree;
//打印红黑树树形结构

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

最后写一个测试就结束了：

package RBTree;

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

            TreeOperation.show(rbt.getRoot());
        }
    }
}

        后续我会补上红黑树的删除。

不会Java的MING
关注
  • 5
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
java手撕红黑树，左旋、右旋、变色、及红黑树的设计概念
DancingInTheDark的博客
11-19 508
理念：只要你把事情分的足够简单，系统就不会出错。 一、总览：首先我们来看一下一颗简单的树是什么结构。 二、节点：很明显，一颗树是由一个个简单的节点组成的，所以要想搞清红黑树，首先熟悉最简单的节点。 为了简化便于理解，每个节点的值用int格式。 红黑树节点的组成：值、左孩子、右孩子、父节点、颜色。用java代码表示如下： class RBNode{ int value; ...
java手写红黑树_手写红黑树的简单实现
weixin_33910191的博客
02-27 298
基于《算法》一书的红黑树的插入和删除。看过不同的教材，也有不同的实现方式，但是最终的结果也大致相同，感觉这个比较容易理解，就采用这种的方式来进行简单实现。定义树节点的实体类型private static final boolean RED = true;private static final boolean BLACK = false;/*** 红黑树的节点结构* 保存的值，左节点，右节点以及颜...
手撕红黑树Java_亲自动手绘图——红黑树，我不信还手撕不清楚
weixin_39567943的博客
02-28 124
前言红黑树是自平衡的二叉查找树，在许多地方都有实际应用比如JAVA的HashMap，在链表长度大于8就会转化为红黑树；在linux经典的epoll中也使用了红黑树来保存文件描述符的插入删除操作。++如果频繁地对数据进行插入删除，还要保证效率，使用红黑树是比较好的选择。++红黑树在实际表现上，还是一颗二叉树。在许多性质上和二叉树一样，所以要从二叉树查找开始讲起。二叉查找树二叉查找树是最简单的实现，规...
手写Java红黑树
金霖海的博客
12-13 979
文章目录红黑树1.红黑树基本的特征介绍2.红黑树变换颜色的规则要求3.红黑树左右旋转基本的规则4.纯手写红黑树左旋转和变色5.红黑树查询最大值 红黑树 1.红黑树基本的特征介绍 基本特征： 每个节点不是红色就是黑色 不允许两红相连 根节点都是黑色 每个红色节点的两个子节点都是黑色 默认情况下添加的节点为红色节点 备注：如果产生了红色相连如何解决：变色或者旋转。 红黑树平衡规则： 1.改变节点颜色 2.左旋转 3.右旋转 2.红黑树变换颜色的规则要求 变色或者旋转都是插入节点后修复平衡的实现。 变色：当前
手撕红黑树（Red-Black Tree）
林慢慢的博客
07-06 2701
红黑树 （C++实现）
手撕红黑树
GG_Bruse的博客
11-22 3269
相较于AVL树，红黑树在实际中运用更加广泛
天天说手撕红黑树？你真的能撕的下来吗？（详细解释+代码注释）
CYK_byte的博客
12-22 965
/新增结点，默认必须是红色}}//根节点}}注意：每次新增结点必须是红色的，因为如果某一个分支上增加一个黑色结点，根据红黑树的特点，那么其他每一个分支上也必须都增加一个黑色结点，但实际上我需要增加一个结点，而为了满足红黑树特点多增加的这些结点是没有意义的；如果添加一个红色节点，我们只需要通过调整颜色，即可满足要求；
红黑树(二)之Java实现
Manofletters的博客
02-15 556
红黑树的原理以及Java代码实现红黑树
面试手撕代码整理
09-29
自己整理的在面试时可能出现的手撕代码题目，例如求一个数的平方根，反转链表，辗转相除法求最大公约数等，希望能提供一些帮助
手撕代码_C语言手撕_C++_手撕代码c++_
10-01
c++笔试和面试常见的手撕代码题，用两个队列实现堆栈
校招面试手撕代码.zip
11-14
校招面试手撕代码例题，CodingInterviewChinese，C++编程包含68个例题，掌握这些通过校招面试不是问题
【酒酒】数字IC手撕代码总结.docx
04-07
【酒酒】数字IC手撕代码总结，1. 用任意语言写1:100的质数（7.17） 2 2. 奇数分频（三分频）（7.18） 3 3. 偶数分频（二分频）（7.19） 5 4. 画出可以检测10110串的状态转移图，要求每检测到一次该序列，输出两个...
机器学习实战-手撕决策树
05-18
决策树模型在鸢尾花数据集上的实现，包括完整代码和可视化以及讲解，准确率很高，亲测可用！
【java】树和哈夫曼树类型的实现和应用
nruuu的博客
06-29 130
树，哈夫曼树类型的实现和应用 摘要 本md文件主要用于该java项目的代码解释和说明，该项目包含的内容有： 树类和结点类的构造，树的前中后序遍历。 哈夫曼树类和哈夫曼结点的构造，哈夫曼树的前中后序遍历。 打印树。 主要包含的类： class 解释 TreeNode 结点类 tree 树类 HFNode 哈夫曼结点类继承自TreeNode类 HuffmanTree 哈夫曼树类继承自树类 Treerun 包含main函数在内，主要用于申请对象，然后调用其他的类来实现程序运行
从零开始手撸红黑树(二)
杏仁技术站
07-02 337
作者 | 曹金霖杏仁Java工程师，正在锻炼自制力的朴素程序猿。上节回顾上一章我们介绍了二叉树，二叉搜索树相关的一些知识。当一个二叉搜索树是一个满二叉树，或者是完美二叉树的时候可以计算一...
从源码开始手撸红黑树（构建与插入）
weixin_44439085的博客
01-03 616
红黑树 红黑树（Red Black Tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，是一个有限节点组成的一个具有层次关系的集合，数据就存在这些节点中。 树 首先我们先来了解一下树（Tree），root是根节点，在分支处有一个节点，指向多个方向，如果某节点下方没有任何分叉的话，就是叶子节点，从某个节点出发，到叶子节点位置，最长简单路径上边的条数，成为该节点的高度，从根节点...
android高斯模糊填充imageview背景
cf8833的博客
05-21 531
说明：最近碰到一个需求，安卓app显示在线的url图片，然后imageview没占满的部分，使用该图片的模糊背景填充。
Spring Bean Map之舞
m0_51176516的博客
05-23 466
在Spring框架中，Bean的生命周期管理是其核心功能之一。当Spring容器启动时，它会根据配置信息（如XML配置文件、注解等）来创建和管理Bean实例。这些Bean实例默认会被放置在一个Map数据结构中，以便容器能够快速地根据Bean的名称（或ID）来查找和访问它们。 在Spring的源码中，Bean实例的存储和管理主要依赖于DefaultSingletonBeanRegistry类。这个类内部使用了一个名为singletonObjects的Map来存储单例Bea...
java学习和项目总结
最新发布
2301_79390585的博客
05-24 397
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
华为手撕代码java
01-04
华为手撕代码java是指在面试或技术交流过程中，面试官会给出几道具体的java编程问题，要求面试者用手撕代码的方式进行解答。这种方式的面试考察了面试者对java语言的熟练程度和编程能力，也考察了其对算法和数据结构...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不会Java的MING

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值