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

news2024/11/19 7:43:19

目录

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

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

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/106934.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

数据护航 安全立方—海泰方圆数据安全治理立体式框架

数据护航 安全立方—海泰方圆数据安全治理立体式框架

发展数据安全是必然趋势 2022年6月，中央全面深化改革委员会第二十六次会议强调，“数据基础制度建设事关国家发展和安全大局，要维护国家数据安全，保护个人信息和商业秘密，促进数据高效流通使用、赋能实体经济&#xff0…
阅读更多...
【JVM】jvm虚拟机中的堆

【JVM】jvm虚拟机中的堆

jvm虚拟机中的堆一、JVM体系结构二、Java堆简介2.1 堆的特点2.2 堆空间细分2.3 堆空间的分代思想2.4 堆的默认大小三、JVM堆内存常用参数四、垃圾回收算法（GC，Garbage Collection）4.1 标记-清除（Mark-Sweep）4.2 复制&a…
阅读更多...
【代码审计-1】PHP无框架项目SQL注入

【代码审计-1】PHP无框架项目SQL注入

代码审计 教学计划：审计项目漏洞Demo->审计思路->完整源码框架->验证并利用漏洞 教学内容：PHP，JAVA网站应用，引入框架类开发源码，相关审计工具及插件使用 必备知识点：环境安装搭建使用&#xff0c…
阅读更多...
python是什么鬼？为什么学会他就能月入过万，它真的这么牛吗？

python是什么鬼？为什么学会他就能月入过万，它真的这么牛吗？

为什么那么多人选择学习python？ Python在人工智能、大数据、自动化运维、全栈开发等方面具有独特的优势。随着Python继续占据编程语言主流的趋势，全国各城市的招聘岗位和薪酬将大幅增加。此外，随着人工智能在中国的投资和规划，对…
阅读更多...
使用docker compose一键部署多个服务

使用docker compose一键部署多个服务

docker compose 是 docker 官方的开源项目，用来实现对 docker 容器集群的快速编排 下载安装 官网下载地址：点这里 我用的是云服务器，所以就直接用yum安装了，直接执行这两条命令，等安装结束后查看版本，看到…
阅读更多...
SpringCloud系列（六）Feign 客户端的配置及使用

SpringCloud系列（六）Feign 客户端的配置及使用

❓Feign 是什么? 🙊Feign 是一个声明式的 http 客户端, 其主要的作用就是帮助我们实现 http 的请求发送, 正如官网所说, Feign使编写Java http客户端更容易; ❓❓为什么要用 Feign? 🙊🙊如在未学习 Feign 之前, 我们利用的是 RestTemplate …
阅读更多...
2022年宜春市职业院校技能大赛中职组“网络搭建与应用”赛项任务书

2022年宜春市职业院校技能大赛中职组“网络搭建与应用”赛项任务书

2022年宜春市职业院校技能大赛中职组“网络搭建与应用”赛项任务书 （总分1000分） 赛题说明 一、竞赛内容分布 “网络搭建与应用”竞赛共分二个部分，其中： 第一部分：网络搭建及安全部署项目 第二部分：服务器…
阅读更多...
【实时数仓】DWS层访客主题计算（续）、商品主题计算

【实时数仓】DWS层访客主题计算（续）、商品主题计算

文章目录一 DWS层-访客主题计算1 写入OLAP数据库&#xff08;1&#xff09;增加ClickhouseUtila JdbcSink.<T>sink( )的四个参数说明b ClickhouseUtil中获取JdbcSink函数的实现c 构造者设计模式d 赋值给问号占位符并创建TransientSink注解e 在GmallConfig中配置ClickHous…
阅读更多...
SWRM(2022)

SWRM(2022)

论文题目&#xff08;Title&#xff09;&#xff1a;Sentiment Word Aware Multimodal Refinement for Multimodal Sentiment Analysis with ASR Errors 研究问题&#xff08;Question&#xff09;&#xff1a;具有语音识别错误的多模态情感分析的情感词感知多模态细化 研究动…
阅读更多...
位 字节 字符

位 字节 字符

位 字节 字符 比特位(bit)→【百度百科】 字节(Byte)→【百度百科】 字符 →【百度百科】 位(bit,简写为b)&#xff1a;&#xff1a; 1、计算机 最小的存储单位&#xff1b; 2、比特位上的值只能存 0 或 1&#xff1b; 3、数据传输大多是以 位 为单位。 字节(Byte,简写为B)&…
阅读更多...
SQL | 你必须知道的一些 SELECT 查询

SQL | 你必须知道的一些 SELECT 查询

数据是许多大小企业的核心部分。例如&#xff0c;Facebook 存储每个用户的个人资料信息&#xff0c;数据库系统内的数据包括他们的朋友和帖子。SQL&#xff08;Structured Query Language 的缩写&#xff09;是一种编程语言&#xff0c;使开发人员和数据库管理员能够使用那些数…
阅读更多...
云、数、智“三江并流”，亚马逊云科技将把数字化航船带向何方?

云、数、智“三江并流”，亚马逊云科技将把数字化航船带向何方?

科技云报道原创。 数流和智流融合不仅仅是趋势&#xff0c;而是正在发生的事情。 从国家层面“十四五”规划为数字化转型高度定调&#xff0c;到各行业内外部刚需推进&#xff0c;数字化转型是千行百业必然发展趋势。 如果说过去两年是数字化转型的试验阶段&#xff0c;进行…
阅读更多...
打开远程会议模式新篇章，华为云会议让沟通更高效！

打开远程会议模式新篇章，华为云会议让沟通更高效！

当下&#xff0c;“降本增效”似乎已成诸多公司的战略选择&#xff0c;不少企业希望能够借助借数字化的转型&#xff0c;对办公方式以及远程会议模式进行升级。在这一市场需求的推动下&#xff0c;不少云服务厂商都针对办公推出了全新的会议模式&#xff0c;比如我们熟悉的华为…
阅读更多...
ArcGIS基础：拓扑工具编辑面要素的公共边

ArcGIS基础：拓扑工具编辑面要素的公共边

需求&#xff1a;在普通的面要素数据中&#xff0c;存在很多相邻面要素&#xff0c;其一大特点就是存在公共边和公共顶点&#xff0c;如下所示&#xff1a; 如果对其中的一个公共边或者公共顶点进行编辑&#xff0c;必须保证相邻的面要素在数据的编辑前后保持拓扑关系不变。 …
阅读更多...
搭建基于 Python+Flask+MySQL 的学生培养计划管理系统（附源码）

搭建基于 Python+Flask+MySQL 的学生培养计划管理系统（附源码）

大家好&#xff0c;今天给大家分析一款 PythonFlaskMySQL 实现的学生培养计划管理系统&#xff0c;项目包括课程推荐、课程评分、交流论坛和模拟退选课模块。 文章目录项目功能项目目录项目环境使用方法源码项目展示项目功能 学生培养计划可视化&#xff0c;学生能够直观地了解…
阅读更多...
转行前端一年大概是什么水平

转行前端一年大概是什么水平

水平“仅供参考” 你很可能是通过搜索找到这篇文章的。 刚入行那会儿&#xff0c;整个小团队就我一只前端。我没有参考坐标系&#xff0c;不知道自己水平是什么程度&#xff0c;不知道大家是什么水平&#xff0c;更不知道就业市场对一年工作经验的要求是怎样的。那种感觉&…
阅读更多...
推荐8个提高工作效率的IntelliJ插件

推荐8个提高工作效率的IntelliJ插件

前言 欢迎关注个人公众号——JAVA旭阳 IntelliJ目前已经成为市面上最受欢迎的Java开发工具&#xff0c;这得益于里面非常丰富的插件机制。本文我将分享在日常开发中我经常使用的5个插件&#xff0c;它们可以帮助您提高工作效率。 1. GenerateAllSetter 作为开发人员&#xff…
阅读更多...
美国物理学会Physics网站公布“年度亮点”工作，AlphaFold和潘建伟团队成果等入选

美国物理学会Physics网站公布“年度亮点”工作，AlphaFold和潘建伟团队成果等入选

凭借詹姆斯韦伯太空望远镜拍摄的令人惊叹的图像、激光聚变的突破、升级后的大型强子对撞机的启动以及小行星防御系统的首次测试&#xff0c;2022 年提供了大量的宏伟成果。 在生物、量子和凝聚态物理学方面也有重要的小规模努力&#xff0c;以及在多样性、公平性和包容性方面的…
阅读更多...
图片颜色处理

图片颜色处理

目录背景任务需求思考过程背景 背景叙述的是我为什么要做颜色处理以及整个思考过程&#xff0c;有些流水账&#xff0c;可不看。 任务需求 拍照&#xff0c;获取图片中固定一块区域的颜色&#xff0c;判断是不是红色。 思考过程 知道这个任务的时候&#xff0c;首先对图像…
阅读更多...
深入理解Self-attention

深入理解Self-attention

概述 输入的特点 是一个向量序列序列的长度是可变的例如&#xff1a;对于音频数据&#xff0c;STFT之后&#xff0c;得到每个帧的特征&#xff0c;这些帧在时间维度上构成序列 输出类型有三种 对序列中的每一个向量&#xff0c;都有一个对应的输出&#xff0c;比如说要对一段…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023