天天说手撕红黑树？你真的能撕的下来吗？（详细解释+代码注释）

已于 2023-04-22 20:08:14 修改
阅读量1k 收藏 2
点赞数 1
分类专栏： 高阶DS 文章标签： 红黑树
于 2022-12-22 06:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CYK_byte/article/details/128389939
版权

目录

一、你还记得什么是红黑树吗？

二、AVL树与红黑树的比较

三、模拟实现红黑树

3.1、红黑树的定义

3.2、插入结点

3.2.1、情况一

 3.2.2、情况二

3.2.3、情况三

四、红黑树的验证

4.1、检查中序遍历是否有序

3.2、检查是否出现两个连续的红色结点

4.3、检查每条路径的黑色结点数目是否相同

4.4、验证红黑树是否满足要求（综合）

五、完整红黑树代码

一、你还记得什么是红黑树吗？

        红黑树是一种二叉搜索树，但在每个结点上又增加一个存储位表示颜色，可以是黑或红；由于最长路径不超过最短路径的两倍，因此，红黑树不像AVL树是绝对平衡的，而是相对平衡的；

 

 性质：

1、每个结点颜色，非黑即红；

2、根节点是黑色的；

3、若一个结点时红色的，则他的两个孩子结点是黑色的；（没有两个连续的红色结点）

4、对于每一个结点，从该结点到所有后代叶节点的简单路径上，黑色结点的数目是相同的；

5、每个叶子结点都是黑色的NIL（空结点）；

为什么有这5点性质，就能保证红黑树，最长路径不超过最短路径的两倍？一张图让你明白，如下：

那么假设，一颗红黑树中有N个黑色结点，那么这颗树的结点数量的范围就是N~2N个，路径长度在logN ~ log2N之间；

二、AVL树与红黑树的比较

        AVL树和红黑树都是高效的平衡二叉树，增删改查的时间复杂度都是O(log2 N)，AVL树是绝对的平衡，而红黑树不是绝对的平衡，他只保证最长路径不超过最短路径的2倍，所以对比起来，降低了插入和删除的次数；

        应用场景：如果是经常需要进行增删改查，更推荐使用红黑树（实际场合运用的最多的也是红黑树）；如果不经常进行增删改查，而是追求极致的查询效率，推荐使用AVL树；

三、模拟实现红黑树

3.1、红黑树的定义

        这里的定义和AVL树的定义差不多，唯一有区别的地方是红黑树多了一个颜色的定义，颜色的定义我们可以通过枚举类来实现，如下代码：

public class RBTree {
    static class RBTreeNode {
        public RBTreeNode left;
        public RBTreeNode right;
        public RBTreeNode parent;
        public int val;
        public COLOR color;

        public RBTreeNode(int val) {
            this.val = val;
            //新增结点，默认必须是红色
            this.color = COLOR.RED;
        }
    }
    public RBTreeNode root;//根节点
}
public enum COLOR {
    RED, BLACK
}

注意：

        每次新增结点必须是红色的，因为如果某一个分支上增加一个黑色结点，根据红黑树的特点，那么其他每一个分支上也必须都增加一个黑色结点，但实际上我需要增加一个结点，而为了满足红黑树特点多增加的这些结点是没有意义的；如果添加一个红色节点，我们只需要通过调整颜色，即可满足要求；不太理解的话可以看看下面这张图：

若新增结点是黑色的，需要继续添加一些无意义的结点满足红黑树要求，如下：

 若新增结点是红色的，只需要修改颜色即可，如下：

3.2、插入结点

        红黑树的插入结点和二叉搜索树的插入结点的方式是一样的，那么还有的代码对于AVL树来说就是需要调节平衡因子和旋转；对于红黑树来说就需要考虑颜色了，因为若新增结点是红色的，而他的父亲结点也是红色的，此时就违反了红黑树的性质，因此需要对颜色进行调整，具体调整方式，分为以下三种情况：

首先，这里约定：cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点；

3.2.1、情况一

cur为红，p为红，g为黑，u存在且为红，如下：

但是这样就够了吗？

肯定是不够的，因为这里没有考虑 g 的父亲结点是什么颜色的，如果他的父亲结点是黑色，那么若只是单纯的将 p 和 u 修改成黑色，是有可能出问题的，如下：

总结一下 ：

        对于以上出现的所有情况，将p 和 u 设置成黑色后，可以直接将结点 g 颜色修改成红色；那如果g就是根节点呢？解决办法就是当所有情况处理完后，无论根节点是什么颜色，都手动将他置为黑色；

如果 g 上面的结点是红色的，那么就继续向上调整，此时 g 结点就相当于是cur结点，p 和 u 依次此向上类推即可，如下图：

那么情况一的代码就有啦，如下：

        while (parent != null && parent.color == COLOR.RED) {//parent为红色，就是两个红色结点连在一起了
            RBTreeNode grandFather = parent.parent;//这个引用一定不为空，因为此时parent一定是红色！
            if(parent == grandFather.left) {
                RBTreeNode uncle = grandFather.right;
                if(uncle != null && uncle.color == COLOR.RED) {
                    parent.color = COLOR.BLACK;
                    uncle.color = COLOR.BLACK;
                    grandFather.color = COLOR.RED;
                    //继续向上调整
                    cur = grandFather;
                    parent = cur.parent;
                } else {
                    //uncle不存在 或者 uncle是黑色的
                }
            } else {

            }
        }

 3.2.2、情况二

cur为红，p为红，g为黑，u不存在/u为黑，处理方式如下：

而这里的右单旋具体讲解在讲解AVL树那一张就写过啦，没看过的小伙伴可以去看一看这篇：http://t.csdn.cn/MNFBp

 代码如下：

public class RBTree {
    static class RBTreeNode {
        public RBTreeNode left;
        public RBTreeNode right;
        public RBTreeNode parent;
        public int val;
        public COLOR color;

        public RBTreeNode(int val) {
            this.val = val;
            //新增结点，默认必须是红色
            this.color = COLOR.RED;
        }
    }
    public RBTreeNode root;//根节点

    public boolean insert(int val) {
        RBTreeNode node = new RBTreeNode(val);
        if(root == null) {
            root = node;
            root.color = COLOR.BLACK;//注意第一次插入根节点一定是黑色
            return true;
        }
        RBTreeNode parent = null;
        RBTreeNode cur = root;
        while(cur != null) {
            if(cur.val > val) {
                //向左寻找
                parent = cur;
                cur = cur.left;
            } else if(cur.val == val) {
                //相等就说明插入失败
                return false;
            } else {
                //向右寻找
                parent = cur;
                cur = cur.right;
            }
        }
        //cur == null
        if(parent.val > val) {
            parent.left = node;
        } else {
            parent.right = node;
        }
        node.parent = parent;
        cur = node;

        //红黑树需要调整颜色
        while (parent != null && parent.color == COLOR.RED) {//parent为红色，就是两个红色结点连在一起了
            RBTreeNode grandFather = parent.parent;//这个引用一定不为空，因为此时parent一定是红色！
            if(parent == grandFather.left) {
                RBTreeNode uncle = grandFather.right;
                if(uncle != null && uncle.color == COLOR.RED) {
                    parent.color = COLOR.BLACK;
                    uncle.color = COLOR.BLACK;
                    grandFather.color = COLOR.RED;
                    //继续向上调整
                    cur = grandFather;
                    parent = cur.parent;
                } else {
                    //uncle不存在 或者 uncle是黑色的
                    //这里只需要先右旋，然后修改颜色即可
                    rotateRight(parent);
                    parent.color = COLOR.BLACK;
                    grandFather.color = COLOR.RED;
                }
            } else {

            }
        }
    }

    //右单旋
    private void rotateRight(RBTreeNode parent) {
        RBTreeNode subL = parent.left;
        RBTreeNode subLR = subL.right;
        parent.left = subLR;
        subL.right = parent;
        if(subLR != null) {
            subLR.parent = parent;
        }
        //必须先记录parent的父亲
        RBTreeNode pParent = parent.parent;
        parent.parent = subL;
        //检查parent是否是根节点
        if(parent == root) {
            root = subL;
            root = null;
        } else {
            //不是根节点，判断parent是左子树还是右子树
            if(pParent.left == parent) {
                pParent.left = subL;
            } else {
                pParent.right = subL;
            }
            subL.parent = pParent;
        }
    }

3.2.3、情况三

cur为红，p为红，g为黑，u不存在/u为黑，如下：

         仔细观察，这不就是 情况二修改完颜色后的样子吗？唯一的差别只是cur和p的指向相互调换了， 所以，这里只需要旋转后调整一下指向即可~

如下代码：

        //红黑树需要调整颜色
        while (parent != null && parent.color == COLOR.RED) {//parent为红色，就是两个红色结点连在一起了
            RBTreeNode grandFather = parent.parent;//这个引用一定不为空，因为此时parent一定是红色！
            if(parent == grandFather.left) {
                RBTreeNode uncle = grandFather.right;
                if(uncle != null && uncle.color == COLOR.RED) {
                    parent.color = COLOR.BLACK;
                    uncle.color = COLOR.BLACK;
                    grandFather.color = COLOR.RED;
                    //继续向上调整
                    cur = grandFather;
                    parent = cur.parent;
                } else {
                    //uncle不存在 或者 uncle是黑色的
                    //情况三：(这里只需要把情况三处理成情况二)
                    if(cur == parent.right) {
                        rotateLeft(parent);
                        //这里只需要交换一下cur和parent
                        RBTreeNode tmp = parent;
                        parent = cur;
                        cur = tmp;
                    }//走完这里，情况三就变成了情况二

                    //情况二：
                    //这里只需要先右旋，然后修改颜色即可
                    rotateRight(parent);
                    parent.color = COLOR.BLACK;
                    grandFather.color = COLOR.RED;
                }
            } else {

            }
        }

        以上所讲，都是处理grandFarther.left，接下来就需要处理最后一个else的情况grandFarcher.right，实际上和grandFarther.left几乎一样，需要处理的地方就是原本是右旋和左旋需要颠倒一下，以及parent的指向；

如下代码：

public class RBTree {
    static class RBTreeNode {
        public RBTreeNode left;
        public RBTreeNode right;
        public RBTreeNode parent;
        public int val;
        public COLOR color;

        public RBTreeNode(int val) {
            this.val = val;
            //新增结点，默认必须是红色
            this.color = COLOR.RED;
        }
    }
    public RBTreeNode root;//根节点

    public boolean insert(int val) {
        RBTreeNode node = new RBTreeNode(val);
        if(root == null) {
            root = node;
            root.color = COLOR.BLACK;//注意第一次插入根节点一定是黑色
            return true;
        }
        RBTreeNode parent = null;
        RBTreeNode cur = root;
        while(cur != null) {
            if(cur.val > val) {
                //向左寻找
                parent = cur;
                cur = cur.left;
            } else if(cur.val == val) {
                //相等就说明插入失败
                return false;
            } else {
                //向右寻找
                parent = cur;
                cur = cur.right;
            }
        }
        //cur == null
        if(parent.val > val) {
            parent.left = node;
        } else {
            parent.right = node;
        }
        node.parent = parent;
        cur = node;

        //红黑树需要调整颜色
        while (parent != null && parent.color == COLOR.RED) {//parent为红色，就是两个红色结点连在一起了
            RBTreeNode grandFather = parent.parent;//这个引用一定不为空，因为此时parent一定是红色！
            if(parent == grandFather.left) {
                RBTreeNode uncle = grandFather.right;
                if(uncle != null && uncle.color == COLOR.RED) {
                    parent.color = COLOR.BLACK;
                    uncle.color = COLOR.BLACK;
                    grandFather.color = COLOR.RED;
                    //继续向上调整
                    cur = grandFather;
                    parent = cur.parent;
                } else {
                    //uncle不存在 或者 uncle是黑色的
                    //情况三：(这里只需要把情况三处理成情况二)
                    if(cur == parent.right) {
                        rotateLeft(parent);
                        //这里只需要交换一下cur和parent
                        RBTreeNode tmp = parent;
                        parent = cur;
                        cur = tmp;
                    }//走完这里，情况三就变成了情况二

                    //情况二：
                    //这里只需要先右旋，然后修改颜色即可
                    rotateRight(parent);
                    parent.color = COLOR.BLACK;
                    grandFather.color = COLOR.RED;
                }
            } else {
                //parent == grandFather.right
                RBTreeNode uncle = grandFather.left;
                if(uncle != null && uncle.color == COLOR.RED) {
                    parent.color = COLOR.BLACK;
                    uncle.color = COLOR.BLACK;
                    grandFather.color = COLOR.RED;
                    //继续向上调整
                    cur = grandFather;
                    parent = cur.parent;
                } else {
                    //uncle不存在 或者 uncle是黑色的
                    //情况三：(这里只需要把情况三处理成情况二)
                    if(cur == parent.left) {
                        rotateRight(parent);
                        //这里只需要交换一下cur和parent
                        RBTreeNode tmp = parent;
                        parent = cur;
                        cur = tmp;
                    }//走完这里，情况三就变成了情况二

                    //情况二：
                    //这里只需要先右旋，然后修改颜色即可
                    rotateLeft(parent);
                    parent.color = COLOR.BLACK;
                    grandFather.color = COLOR.RED;
                }
            }
        }
        root.color = COLOR.BLACK;
        return true;
    }

    //左单旋
    private void rotateLeft(RBTreeNode parent) {
        RBTreeNode subR = parent.right;
        RBTreeNode subRL = subR.left;
        parent.right = subRL;

        subR.left = parent;

        if(subRL != null) {
            subRL.parent = parent;
        }
        //必须先记录parent的父亲
        RBTreeNode pParent = parent.parent;
        parent.parent = subR;
        //检查parent是否为根节点
        if(parent == root) {
            root = subR;
            root.parent = null;
        } else {
            //不是根节点需要判断parent是左子树还是右子树
            if(pParent.left == parent) {
                pParent.left = subR;
            } else {
                pParent.right = subR;
            }
            subR.parent = pParent;
        }
    }

    //右单旋
    private void rotateRight(RBTreeNode parent) {
        RBTreeNode subL = parent.left;
        RBTreeNode subLR = subL.right;
        parent.left = subLR;
        subL.right = parent;
        if(subLR != null) {
            subLR.parent = parent;
        }
        //必须先记录parent的父亲
        RBTreeNode pParent = parent.parent;
        parent.parent = subL;
        //检查parent是否是根节点
        if(parent == root) {
            root = subL;
            root = null;
        } else {
            //不是根节点，判断parent是左子树还是右子树
            if(pParent.left == parent) {
                pParent.left = subL;
            } else {
                pParent.right = subL;
            }
            subL.parent = pParent;
        }
    }
}

芜湖~这样整个插入就完成了~

四、红黑树的验证

验证是否为红黑树就是要看是否满足红黑树的特性；

4.1、检查中序遍历是否有序

这个就是简单的中序遍历~

代码如下：

    public void dfs(RBTreeNode root) {
        if(root == null) {
            return;
        }
        dfs(root.left);
        System.out.print(root.val + " ");
        dfs(root.right);
    }

3.2、检查是否出现两个连续的红色结点

这里可以反向去检查，也就是说，当你遍历到一个红色结点时，只需要看一下他的父亲结点是否是黑色，若是黑色的就满足要求，若不是，就不是红黑树；

代码如下：

    //检查是否出现俩个连续的红色结点
    private boolean checkRedColor(RBTreeNode root) {
        if(root == null) {
            return true;
        }
        if(root.color == COLOR.RED) {
            RBTreeNode parent = root.parent;
            if(parent.color == COLOR.RED) {
                System.out.println("不是红黑树，违反了性质：不可以出现两个连续的红色结点");
                return false;
            }
        }
        return checkRedColor(root.left) && checkRedColor(root.right);

4.3、检查每条路径的黑色结点数目是否相同

可以通过递归遍历每一个结点，创建一个计数器，一旦遍历到黑色结点计数器就加一，若当前结点的左右子树都为空，说明一条路径已经遍历完了，这个适合就可以对比黑色结点数目相同，满足要求；

代码如下：

    /**
     *
     * @param root
     * @param pathBlackNum 递归时每条路径上的黑色结点个数
     * @param BlackNum 以及计算好的黑色结点个数
     * @return
     */
    private boolean checkBlackNum(RBTreeNode root, int pathBlackNum, int BlackNum) {
        if(root == null) {
            return true;
        }
        if(root.color == COLOR.BLACK) {
            pathBlackNum++;
        }
        if(root.left == null && root.right == null) {
            if(pathBlackNum != BlackNum) {
                System.out.println("不是红黑树，违反了性质：每条路径上的黑色结点个数相同");
                return false;
            }
        }
        return checkBlackNum(root.left, pathBlackNum, BlackNum) &&
                checkBlackNum(root.left, pathBlackNum, BlackNum);

    }

4.4、验证红黑树是否满足要求（综合）

这里除了要综合以上的检查方法，同时还要判断根节点的颜色，若根节点的颜色不是黑色，则说明不满足要求；

代码如下：

    //验证红黑树(就是要满足红黑树的性质)
    public boolean isRBTree(RBTreeNode root) {
        if(root == null) {
            return true;
        }
        if (root.color != COLOR.BLACK) {
            System.out.println("不是红黑树，违反了性质：根节点是黑色的");
        }
        int BlackNum = 0;
        RBTreeNode cur = root;
        while(root != null) {
            if(root.color == COLOR.BLACK) {
                BlackNum++;
            }
            root = root.left;
        }
        // 检查是否出现俩个连续的红色结点 && 检查每条路径黑色结点数是否相同
        return checkRedColor(root) && checkBlackNum(root, 0, BlackNum);

五、完整红黑树代码

public class RBTree {
    static class RBTreeNode {
        public RBTreeNode left;
        public RBTreeNode right;
        public RBTreeNode parent;
        public int val;
        public COLOR color;

        public RBTreeNode(int val) {
            this.val = val;
            //新增结点，默认必须是红色
            this.color = COLOR.RED;
        }
    }
    public RBTreeNode root;//根节点

    public boolean insert(int val) {
        RBTreeNode node = new RBTreeNode(val);
        if(root == null) {
            root = node;
            root.color = COLOR.BLACK;//注意第一次插入根节点一定是黑色
            return true;
        }
        RBTreeNode parent = null;
        RBTreeNode cur = root;
        while(cur != null) {
            if(cur.val > val) {
                //向左寻找
                parent = cur;
                cur = cur.left;
            } else if(cur.val == val) {
                //相等就说明插入失败
                return false;
            } else {
                //向右寻找
                parent = cur;
                cur = cur.right;
            }
        }
        //cur == null
        if(parent.val > val) {
            parent.left = node;
        } else {
            parent.right = node;
        }
        node.parent = parent;
        cur = node;

        //红黑树需要调整颜色
        while (parent != null && parent.color == COLOR.RED) {//parent为红色，就是两个红色结点连在一起了
            RBTreeNode grandFather = parent.parent;//这个引用一定不为空，因为此时parent一定是红色！
            if(parent == grandFather.left) {
                RBTreeNode uncle = grandFather.right;
                if(uncle != null && uncle.color == COLOR.RED) {
                    parent.color = COLOR.BLACK;
                    uncle.color = COLOR.BLACK;
                    grandFather.color = COLOR.RED;
                    //继续向上调整
                    cur = grandFather;
                    parent = cur.parent;
                } else {
                    //uncle不存在 或者 uncle是黑色的
                    //情况三：(这里只需要把情况三处理成情况二)
                    if(cur == parent.right) {
                        rotateLeft(parent);
                        //这里只需要交换一下cur和parent
                        RBTreeNode tmp = parent;
                        parent = cur;
                        cur = tmp;
                    }//走完这里，情况三就变成了情况二

                    //情况二：
                    //这里只需要先右旋，然后修改颜色即可
                    rotateRight(parent);
                    parent.color = COLOR.BLACK;
                    grandFather.color = COLOR.RED;
                }
            } else {
                //parent == grandFather.right
                RBTreeNode uncle = grandFather.left;
                if(uncle != null && uncle.color == COLOR.RED) {
                    parent.color = COLOR.BLACK;
                    uncle.color = COLOR.BLACK;
                    grandFather.color = COLOR.RED;
                    //继续向上调整
                    cur = grandFather;
                    parent = cur.parent;
                } else {
                    //uncle不存在 或者 uncle是黑色的
                    //情况三：(这里只需要把情况三处理成情况二)
                    if(cur == parent.left) {
                        rotateRight(parent);
                        //这里只需要交换一下cur和parent
                        RBTreeNode tmp = parent;
                        parent = cur;
                        cur = tmp;
                    }//走完这里，情况三就变成了情况二

                    //情况二：
                    //这里只需要先右旋，然后修改颜色即可
                    rotateLeft(parent);
                    parent.color = COLOR.BLACK;
                    grandFather.color = COLOR.RED;
                }
            }
        }
        root.color = COLOR.BLACK;
        return true;
    }

    //左单旋
    private void rotateLeft(RBTreeNode parent) {
        RBTreeNode subR = parent.right;
        RBTreeNode subRL = subR.left;
        parent.right = subRL;

        subR.left = parent;

        if(subRL != null) {
            subRL.parent = parent;
        }
        //必须先记录parent的父亲
        RBTreeNode pParent = parent.parent;
        parent.parent = subR;
        //检查parent是否为根节点
        if(parent == root) {
            root = subR;
            root.parent = null;
        } else {
            //不是根节点需要判断parent是左子树还是右子树
            if(pParent.left == parent) {
                pParent.left = subR;
            } else {
                pParent.right = subR;
            }
            subR.parent = pParent;
        }
    }

    //右单旋
    private void rotateRight(RBTreeNode parent) {
        RBTreeNode subL = parent.left;
        RBTreeNode subLR = subL.right;
        parent.left = subLR;
        subL.right = parent;
        if(subLR != null) {
            subLR.parent = parent;
        }
        //必须先记录parent的父亲
        RBTreeNode pParent = parent.parent;
        parent.parent = subL;
        //检查parent是否是根节点
        if(parent == root) {
            root = subL;
            root = null;
        } else {
            //不是根节点，判断parent是左子树还是右子树
            if(pParent.left == parent) {
                pParent.left = subL;
            } else {
                pParent.right = subL;
            }
            subL.parent = pParent;
        }
    }

    //验证红黑树(就是要满足红黑树的性质)
    public boolean isRBTree(RBTreeNode root) {
        if(root == null) {
            return true;
        }
        if (root.color != COLOR.BLACK) {
            System.out.println("不是红黑树，违反了性质：根节点是黑色的");
        }
        int BlackNum = 0;
        RBTreeNode cur = root;
        while(root != null) {
            if(root.color == COLOR.BLACK) {
                BlackNum++;
            }
            root = root.left;
        }
        // 检查是否出现俩个连续的红色结点 && 检查每条路径黑色结点数是否相同
        return checkRedColor(root) && checkBlackNum(root, 0, BlackNum);
    }
    /**
     *
     * @param root
     * @param pathBlackNum 递归时每条路径上的黑色结点个数
     * @param BlackNum 以及计算好的黑色结点个数
     * @return
     */
    private boolean checkBlackNum(RBTreeNode root, int pathBlackNum, int BlackNum) {
        if(root == null) {
            return true;
        }
        if(root.color == COLOR.BLACK) {
            pathBlackNum++;
        }
        if(root.left == null && root.right == null) {
            if(pathBlackNum != BlackNum) {
                System.out.println("不是红黑树，违反了性质：每条路径上的黑色结点个数相同");
                return false;
            }
        }
        return checkBlackNum(root.left, pathBlackNum, BlackNum) &&
                checkBlackNum(root.left, pathBlackNum, BlackNum);

    }
    //检查是否出现俩个连续的红色结点
    private boolean checkRedColor(RBTreeNode root) {
        if(root == null) {
            return true;
        }
        if(root.color == COLOR.RED) {
            RBTreeNode parent = root.parent;
            if(parent.color == COLOR.RED) {
                System.out.println("不是红黑树，违反了性质：不可以出现两个连续的红色结点");
                return false;
            }
        }
        return checkRedColor(root.left) && checkRedColor(root.right);
    }
    //检查中序遍历是否有序
    public void dfs(RBTreeNode root) {
        if(root == null) {
            return;
        }
        dfs(root.left);
        System.out.print(root.val + " ");
        dfs(root.right);
    }
}

陈亦康
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
各种各样的手撕便签集合矢量素材(EPS+PNG+PSD)
05-09
在IT行业中，设计素材是创建数字内容不可或缺的一部分，特别是对于网页设计、图形设计以及广告制作等领域。本资源“各种各样的手撕便签...无论你是专业设计师还是业余爱好者，这套素材都能为你的创作带来灵感和便利。
手撕GO语言-详细注释版
12-15
【标题】"手撕GO语言-详细注释版"提供了全面深入学习Go语言的资源，适合初学者和有一定经验的开发者。这份资料包含了大量实例，旨在帮助读者快速掌握Go语言的核心概念和应用。 【描述】"学习GO语言的不二资料"表明...
红黑树定义及其代码实现
公众号：风景邮递Yuan的博客
06-16 745
红黑树是一种自平衡二叉查找树，它在每个节点上增加了一个存储位来表示节点的颜色，可以是红色或黑色。通过对任何一条从根到叶子节点的路径上各个节点的颜色进行约束，红黑树确保没有一条路径会比其他路径长出两倍，因此，红黑树是近似平衡的。5. 对于每个节点，从该节点到其所有后代叶子节点的简单路径上，均包含相同数目的黑色节点。4. 如果一个节点是红色的，则它的两个子节点都是黑色的。3. 每个叶子节点（NIL节点，空节点）是黑色的。1. 每个节点要么是红色，要么是黑色。2. 根节点是黑色的。
红黑树实现代码+详细注释
ltrbless的博客
05-19 1546
简介 因为网上太多红黑树原理的讲解了，不需要再去讲解原理，所以在这就提供一些将原理不错的博客，然后主要是给红黑树代码的实现，用的c++语言模板实现红黑树，并附带详细注释。（目前只实现了红黑树的插入与查询操作，并可视化打印红黑树）。 红黑树插入操作的流程图：（参考：红黑树总结 - lukazan - 博客园 (cnblogs.com)，该博客用图详细解释了红黑树插入操作的事件，然后我用红色对其事件进行了编号，以便于和代码注释相对应） 红黑树的本质其实就是2-3树，在上面推荐的博客中也有提到。 代码
红黑树原理详解及代码实现
CodePanda@GPF的博客
05-23 2630
红黑树原理及代码实践
红黑树内容及代码实现
m0_56821563的博客
07-02 337
本篇博客讲述了数据结构中红黑树的概念，并给出C++的实现。
补档：红黑树代码实现+简略讲解
to_upper的博客
03-02 569
红黑树
手撕代码_C语言手撕_C++_手撕代码c++_
10-01
在IT行业中，编程面试往往包含了“手撕代码”这一环节，即面试者需要现场编写代码来解决特定问题。本资源“手撕代码_C语言手撕_C++_手撕代码c++_”聚焦于C语言和C++的面试题，特别关注如何使用两个队列来实现堆栈的...
基于Numpy手撕bp神经网络和CNN案例（源码+数据+说明文档）.rar
05-15
1、资源内容：基于Numpy手撕bp神经网络和CNN案例（源码+数据+说明文档）.rar 2、适用人群：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业或毕业设计，作为“参考资料”使用。 3、解压说明：本资源...
vivo iQOO 12系统手撕方案
06-21
vivo iQOO 12系统手撕方案
红黑树 图文详解与代码实现
qq_54831038的博客
09-01 990
红黑树被应用于数据结构map/set的封装的底层，也应用于Linux的数据内核，在进程调度CFS，虚拟内存管理，共享内存slab等场景都有广泛应用。数据结构的角度看，（1）用于存储。无论数据是否平衡都可以在O（logN)的复杂度下完成 搜索、插入、删除操作。（2）用于排序。找到最小值和最大值红黑树黑色和红色 也可看成两种状态，红黑区分的状态中，可以根据实际需求添加业务逻辑。......
红黑树代码
weixin_42611310的博客
12-27 140
红黑树是一种自平衡二叉搜索树，它在保证树高度最低的情况下，还能保证每个节点的左子树和右子树的大小相差不会超过1。这使得它在插入、删除和查找操作时效率更高。 红黑树通常使用C++或Java来实现。以下是一段C++代码，用于在红黑树中插入一个新的节点： void insert(int key) { // 创建新节点 Node *z= new Node; z->key = key; ...
红黑树实现（代码：插入、删除、检测、打印树的结构、随机生成数据测试）
RunningBeef的博客
05-10 707
插入结点 使用维基百科红黑树的插入实现 多种情况分类讨论，log级别 代码如下 /* 先找到合适位置插入，之后再根据父节点颜色判断是否进行调整 */ void insert(int key, T value) { Node *insertNode = new Node(key, value); Node *traver = root; while (traver) {
红黑树（含图解和代码参考）
Guqing_f的博客
04-25 2908
红黑树的介绍、插入与删除
【C++】红黑树详解（附迭代器以及插入实现），适合初学者
jhao的博客
07-13 2376
红黑树的简单实现附有迭代器实现，代码都有详细解释，适合于初学者和想要理解STL map/set原理的朋友观看。
数据结构与算法【红黑树】的Java实现+图解
zmbwcx的博客
11-22 746
红黑树也是一种自平衡的二叉搜索树，较之 AVL，插入和删除时旋转次数更少。首先介绍代码实现会用到的概念兄弟节点：具有同一个父结点的一对节点可以互称为兄弟节点叔叔节点：父结点的兄弟节点。
红黑树（附完整C代码）
热门推荐
weewqrer的博客
07-09 2万+
版权声明：原创不易，转载请注明转自weewqrer 红黑树红黑树简介首先红黑树是一棵二叉搜索树，它在每个结点上增加了一个存储位来表示结点的颜色，可以是RED或者BLACK。通过对一条从根节点到NIL叶节点（指空结点或者下面说的哨兵）的简单路径上各个结点在颜色进行约束，红黑树确保没有一条路径会比其他路径长出2倍，因而是近似平衡的。 用途红黑树和AVL树一样都对插入时间、删除时间和查找时间提供了最好可
理解红黑树及代码实现
qq_38412637的博客
01-19 7977
1.红黑树定义 红黑树是一颗 红-黑的平衡二叉树,它具有二叉树的所有特性,是一颗自平衡的排序二叉树.(树中任何节点值都大于左子节点的值，而且都小于右子节点的值),其检索效率高，它是一颗空树或它的左右两个子树高度差的绝对值不超过1，并且左右子树都是平衡二叉树. 最坏的情况下 是一边倒的情况 在这种情况下，如果我们要在树中查找g节点，就需要顺着根节点往下找,时间复杂度约为O(n)常数级。那么红黑...
手撕红黑树代码（Java）
qq_52485934的博客
04-02 185
红黑树详细讲解，详细的源码讲解
手撕yolov8代码
最新发布
06-07
YOLOv8（You Only Look Once version 8）是一种流行的实时物体检测算法，它是YOLO系列的最新版本，以其高效和准确的性能而闻名。手撕YOLOv8代码意味着手动解析和理解其源代码，以便学习其工作原理和实现细节。 YOLOv8的核心是利用卷积神经网络（CNN）来处理图像数据，将输入分割成多个网格，并对每个网格中的区域进行预测。它通常包括以下几个关键步骤： 1. **模型结构**：YOLOv8继承了YOLOv3的基本架构，但引入了更多的改进，如更小的特征图尺寸、扩增的头部设计（包含更多层来提高精度）等。 2. **特征提取**：使用Darknet或ResNet这样的预训练网络提取图像特征。 3. **多尺度检测**：YOLOv8可以在不同大小的特征图上执行预测，增加了对不同尺寸目标的适应性。 4. **Anchor boxes**：YOLO使用预定义的锚框来预测不同大小和比例的目标。 5. **预测阶段**：计算每个网格单元的概率分布和边界框坐标，然后结合非极大抑制（NMS）进行后处理。 6. **损失函数**：使用IoU损失（Intersection over Union）和其他指标来衡量预测结果的准确性。 如果你想要深入了解YOLov8的代码，建议你从GitHub上的官方仓库开始，例如` Ultralytics/yolov8 `，阅读其`__init__.py`中的主要类定义，以及`models.py`中涉及核心功能的部分。在阅读过程中，注意理解每一部分的作用，比如`Detector`类的初始化、前向传播、及其训练和预测过程。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

陈亦康

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

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

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

打赏作者

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

抵扣说明：

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

余额充值