【数据结构进阶】红黑树【TreeMap TreeSet底层就是红黑树】

news2025/4/8 9:34:50

红黑树【TreeMap TreeSet底层就是红黑树】

概念

红黑树是一种二叉搜索树,但在每个结点上增加一个存储位表示结点的颜色,可能是Red或者Black。通过对任何一条从根到叶子结点着色方式的限制,红黑树确保没有一条路径会比其他路径长出两倍,因而是 接近平衡的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nDPYQQ9K-1671756615998)(C:\Users\17512\AppData\Roaming\Typora\typora-user-images\1671330013337.png)]

红黑树的性质

  1. 最长路径最多是最短路径的2倍。
  2. 每个结点不是红色就是黑色。
  3. 根结点是黑色的。
  4. 如果一个结点是红色的,则它的两个孩子结点是黑色的。【没有2个连续的红色结点】不能有两个连续的红色结点
  5. 对于每个结点,从该结点到其后代叶结点的简单路径上,均包含相同数目的黑色结点。每条路径上,都有相同个数的黑色结点
  6. 每个叶子结点都是黑色的。【此处的叶子节点指的是 空结点】
  • 2,3,4,5,6 => 1

最短路径: 就是当前路径全部都是黑色 结点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W06eocR4-1671756615999)(C:\Users\17512\AppData\Roaming\Typora\typora-user-images\1671332563267.png)]

假设 一棵红黑树 当中有 X 个黑色的结点。这棵树总共有N个结点。那么N的范围是多少?

【x 2x】 最短路径的时间复杂度:
l o g 2 n log 2 n log2n
最短路径的长度:
l o g n logn logn
最长路径的长度:
2 l o g n 2logn 2logn

红黑树结点的定义

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;

新增的结点不能是黑色的,如果是黑色的,就需要保证每条路径上的黑色结点必须是相同的。势必会有以下问题:

  • 你需要继续新增结点

红黑树的插入

红黑树是在二叉搜索树的基础上加上其平衡限制条件,因此红黑树的插入可分为两步:

  1. 按照二叉搜索的树规则插入新节点

  2. 检测新节点插入后,红黑树的性质是否造到破坏

因为新节点的默认颜色是红色,因此:如果其双亲节点的颜色是黑色,没有违反红黑树任何性质,则不需要

调整;但当新插入节点的双亲节点颜色为红色时,就违反了性质三不能有连在一起的红色节点,此时需要对

红黑树分情况来讨论:

约定:cur为当前节点,p为父节点,g为祖父节点,u为叔叔节点

  • 情况一: cur为红,p为红,g为黑,u存在且为红

    • 解决方法:将p,u改为黑,g改为红,然后把g当成cur,继续向上调整。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nSNogo0G-1671756616000)(C:\Users\17512\AppData\Roaming\Typora\typora-user-images\1671754258083.png)]
  • 情况二:cur为红,p为红,g为黑,u不存在/u为黑

    • 解决方法:p为g的左孩子,cur为p的左孩子,则进行右单旋转;相反,p为g的右孩子,cur为p的右孩子,则进行左单旋转
  • 情况三:cur为红,p为红,g为黑,u不存在/u为黑

    • 解决方法:p为g的左孩子,cur为p的右孩子,则针对p做左单旋转;相反,p为g的右孩子,cur为p的左孩子,则针对p做右单旋转
public boolean insert(int val) {
        rbTreeNode node = new rbTreeNode(val);
        if (root == null) {
            root = node;
            return true;
        }
        rbTreeNode parent = null;
        rbTreeNode cur = root;
        while (cur != null) {
            if (cur.val < val) {
                parent = cur;
                cur = cur.right;
            } else if (cur.val == val) {
                return false;
            } else {
                parent = cur;
                cur = cur.left;
            }
        }
        //cur == null
        if (parent.val < val) {
            parent.right = node;
        } else {
            parent.left = node;
        }

        node.parent = parent;
        cur = node;
        //红黑树来说:需要调整颜色
        while (parent!=null && parent.color ==COLOR.RED){
            rbTreeNode grandFather = parent.parent; //这个引用不可能为空
            //cur为红,p为红,g为黑,u存在且为红
            if (parent ==  grandFather.left){
                rbTreeNode  uncle = grandFather.right;
                if (uncle!=null && uncle.color == COLOR.RED){
                    //将p,u改为黑,g改为红,然后把g当成cur,继续向上调整。
                    parent.color= COLOR.BLACK;
                    uncle.color = COLOR.BLACK;
                    grandFather.color =COLOR.RED;
                }else{//uncle不存在 || uncle是黑色
                    //cur为红,p为红,g为黑,u不存在/u为黑
                    //情况三:
                    if(cur == parent.right) {
                        rotateLeft(parent);
                        rbTreeNode tmp = parent;
                        parent = cur;
                        cur = tmp;
                    }//情况三  变成了情况二

                    //情况二
                    rotateRight(grandFather);
                    grandFather.color = COLOR.RED;
                    parent.color = COLOR.BLACK;
                }
            }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);
                        rbTreeNode tmp = parent;
                        parent = cur;
                        cur = tmp;
                    }//情况三  变成了情况二
                    //情况二
                    rotateLeft(grandFather);
                    grandFather.color = COLOR.RED;
                    parent.color = COLOR.BLACK;
                }

            }
        }
        root.color = COLOR.BLACK;
        return true;
    }
    /**
     * 左单旋
     * @param parent
     */
    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;
        }

        rbTreeNode pParent = parent.parent;
        parent.parent = subR;

        if(root == parent) {
            root = subR;
            root.parent = null;
        }else {
            if(pParent.left == parent) {
                pParent.left = subR;
            }else {
                pParent.right = subR;
            }
            subR.parent = pParent;
        }
    }

    /**
     * 右单旋
     * @param parent
     */
    private void rotateRight(rbTreeNode parent) {

        rbTreeNode subL = parent.left;
        rbTreeNode subLR = subL.right;

        parent.left = subLR;
        subL.right = parent;
        //没有subLR
        if(subLR != null) {
            subLR.parent = parent;
        }
        //必须先记录
        rbTreeNode pParent = parent.parent;
        parent.parent = subL;
        //检查 当前是不是就是根节点
        if(parent == root) {
            root = subL;
            root.parent = null;
        }else {
            //不是根节点,判断这棵子树是左子树还是右子树
            if(pParent.left == parent) {
                pParent.left = subL;
            }else {
                pParent.right = subL;
            }
            subL.parent = pParent;
        }
    }

红黑树的验证

public void inorder(rbTreeNode root) {
        if(root == null) {
            return;
        }
        inorder(root.left);
        System.out.print(root.val+" ");
        inorder(root.right);
    }
/**
     * 判断当前树 是不是红黑树
     *  得满足 红黑树的性质
     * @return
     */
    public boolean isRBTree() {
        if(root == null) {
            //如果一棵树是空树,那么这棵树就是红黑树
            return true;
        }

        if(root.color != COLOR.BLACK) {
            System.out.println("违反了性质:根节点必须是黑色的!");
        }

        //存储当前红黑树当中 最左边路径的黑色的节点个数
        int blackNum = 0;
        rbTreeNode cur = root;
        while (cur != null) {
            if(cur.color == COLOR.BLACK) {
                blackNum++;
            }
            cur = cur.left;
        }
        //检查是否存在两个连续的红色节点  && 每条路径上黑色的节点的个数是一致的
        return checkRedColor(root) && checkBlackNum(root,0,blackNum);
    }

    /**
     *
     * @param root
     * @param pathBlackNum 每次递归的时候,计算黑色节点的个数  0
     * @param blackNum 事先计算好的某条路径上的黑色节点的个数   2
     * @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.right,pathBlackNum,blackNum);
    }

    /**
     * 检查是否存在两个连续的红色节点
     * @param root
     * @return
     */
    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);
    }

红黑树的删除

http://www.cnblogs.com/fornever/archive/2011/12/02/2270692.html

AVL树和红黑树的比较

红黑树和AVL树都是高效的平衡二叉树,增删改查的时间复杂度都是 O(log2N),红黑树不追求绝对平衡,其只需保 证最长路径不超过最短路径的2倍,相对而言,降低了插入和旋转的次数,所以在经常进行增删的结构中性能比AVL树更优,而且红黑树实现比较简单,所以实际运用中红黑树更多

红黑树的应用

  1. java集合框架中的:TreeMap**、TreeSet底层使用的就是红黑树**

  2. C++ STL库 – map/set、mutil_map/mutil_set

  3. linux内核:进程调度中使用红黑树管理进程控制块,epoll在内核中实现时使用红黑树管理事件块

  4. 其他一些库:比如nginx中用红黑树管理timer等

完整代码

package RBtree;


/**
 * @author SunYuHang
 * @date 2022-12-17 21:34
 * @ClassName : rbTree  //类名
 */

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;
            return true;
        }
        rbTreeNode parent = null;
        rbTreeNode cur = root;
        while (cur != null) {
            if (cur.val < val) {
                parent = cur;
                cur = cur.right;
            } else if (cur.val == val) {
                return false;
            } else {
                parent = cur;
                cur = cur.left;
            }
        }
        //cur == null
        if (parent.val < val) {
            parent.right = node;
        } else {
            parent.left = node;
        }

        node.parent = parent;
        cur = node;
        //红黑树来说:需要调整颜色
        while (parent!=null && parent.color ==COLOR.RED){
            rbTreeNode grandFather = parent.parent; //这个引用不可能为空
            //cur为红,p为红,g为黑,u存在且为红
            if (parent ==  grandFather.left){
                rbTreeNode  uncle = grandFather.right;
                if (uncle!=null && uncle.color == COLOR.RED){
                    //将p,u改为黑,g改为红,然后把g当成cur,继续向上调整。
                    parent.color= COLOR.BLACK;
                    uncle.color = COLOR.BLACK;
                    grandFather.color =COLOR.RED;
                }else{//uncle不存在 || uncle是黑色
                    //cur为红,p为红,g为黑,u不存在/u为黑
                    //情况三:
                    if(cur == parent.right) {
                        rotateLeft(parent);
                        rbTreeNode tmp = parent;
                        parent = cur;
                        cur = tmp;
                    }//情况三  变成了情况二

                    //情况二
                    rotateRight(grandFather);
                    grandFather.color = COLOR.RED;
                    parent.color = COLOR.BLACK;
                }
            }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);
                        rbTreeNode tmp = parent;
                        parent = cur;
                        cur = tmp;
                    }//情况三  变成了情况二
                    //情况二
                    rotateLeft(grandFather);
                    grandFather.color = COLOR.RED;
                    parent.color = COLOR.BLACK;
                }

            }
        }
        root.color = COLOR.BLACK;
        return true;
    }
    /**
     * 左单旋
     * @param parent
     */
    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;
        }

        rbTreeNode pParent = parent.parent;
        parent.parent = subR;

        if(root == parent) {
            root = subR;
            root.parent = null;
        }else {
            if(pParent.left == parent) {
                pParent.left = subR;
            }else {
                pParent.right = subR;
            }
            subR.parent = pParent;
        }
    }

    /**
     * 右单旋
     * @param parent
     */
    private void rotateRight(rbTreeNode parent) {

        rbTreeNode subL = parent.left;
        rbTreeNode subLR = subL.right;

        parent.left = subLR;
        subL.right = parent;
        //没有subLR
        if(subLR != null) {
            subLR.parent = parent;
        }
        //必须先记录
        rbTreeNode pParent = parent.parent;
        parent.parent = subL;
        //检查 当前是不是就是根节点
        if(parent == root) {
            root = subL;
            root.parent = null;
        }else {
            //不是根节点,判断这棵子树是左子树还是右子树
            if(pParent.left == parent) {
                pParent.left = subL;
            }else {
                pParent.right = subL;
            }
            subL.parent = pParent;
        }
    }

    /**
     * 判断当前树 是不是红黑树
     *  得满足 红黑树的性质
     * @return
     */
    public boolean isRBTree() {
        if(root == null) {
            //如果一棵树是空树,那么这棵树就是红黑树
            return true;
        }

        if(root.color != COLOR.BLACK) {
            System.out.println("违反了性质:根节点必须是黑色的!");
        }

        //存储当前红黑树当中 最左边路径的黑色的节点个数
        int blackNum = 0;
        rbTreeNode cur = root;
        while (cur != null) {
            if(cur.color == COLOR.BLACK) {
                blackNum++;
            }
            cur = cur.left;
        }
        //检查是否存在两个连续的红色节点  && 每条路径上黑色的节点的个数是一致的
        return checkRedColor(root) && checkBlackNum(root,0,blackNum);
    }

    /**
     *
     * @param root
     * @param pathBlackNum 每次递归的时候,计算黑色节点的个数  0
     * @param blackNum 事先计算好的某条路径上的黑色节点的个数   2
     * @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.right,pathBlackNum,blackNum);
    }

    /**
     * 检查是否存在两个连续的红色节点
     * @param root
     * @return
     */
    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 inorder(rbTreeNode root) {
        if(root == null) {
            return;
        }
        inorder(root.left);
        System.out.print(root.val+" ");
        inorder(root.right);
    }
    

}



package RBtree;

public enum COLOR {
    RED,BLACK
}

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

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

相关文章

【数据库内核分析系列】:数据库索引的创建过程

文章目录普通表索引DefineIndeIndex_create函数index_build分区表索引数据库索引可以提高数据的访问速度&#xff0c;openGauss支持唯一索引、多字段索引、部分索引和表达式索引。行存表&#xff08;ASTORE存储引擎&#xff09;支持的索引类型&#xff1a;btree&#xff08;行存…

绿盟SecXOps安全智能分析技术白皮书 模型更新

模型更新 定义内涵 本节的模型更新是指在模型训练完成并正式上线后&#xff0c;由运维人员采集并提供新的数据对 原有模型进行再训练、更新参数的过程。 技术背景 随着时间的推移&#xff0c;由于周期性事件、突变等状况的发生&#xff0c;当下的数据集和之前用于训练 模型…

通用预约小程序,可广泛应用于医疗、政务、教育、培训、体育、金融、生活服务等行业领域,基于腾讯小程序云开发,无须服务器和域名

项目介绍 采用小程序腾讯云技术构建的高效自有业务预约平台解决方案&#xff0c;无需域名和服务器即可搭建。 机构/商户/企业/个体可以利用本软件快速搭建出自有业务预约平台&#xff0c; 小程序在微信里打开&#xff0c;无需下载安装APP以及复杂的注册&#xff0c;即可轻松通…

真香啊,这招可以轻松抓取某音短视频数据(附 Python 代码)

众所周知&#xff0c;某音短视频是没有提供下载链接的&#xff0c;视频号也没下载链接&#xff0c;但我就想下载下来&#xff0c;还有视频下面的评论我也想拿到&#xff0c;那要肿么办呢&#xff1f;其实播放链接和评论是可以拿到的&#xff0c;我来细细道来 文章目录抓包技术提…

C++——STL之list详解

C——STL之list详解&#x1f3d0;什么是list&#x1f3d0;list的使用&#x1f3c0;splice&#x1f3c0;unique&#x1f3c0;remove&#x1f3c0;sort&#x1f3d0;list的实现&#x1f3c0;迭代器类&#xff08;体会c的优势&#xff09;⚽迭代器的构造⚽迭代器的模板参数&#x…

Java项目:springboot+vue电影院会员管理系统

作者主页&#xff1a;源码空间站2022 简介&#xff1a;Java领域优质创作者、Java项目、学习资料、技术互助 文末获取源码 项目介绍 本项目代码架构设计简单&#xff0c;注释齐全&#xff0c;结构清晰&#xff0c;适合同为java初学者参考。 cinema项目是一套电影院会员管理系统…

第十五章 规则学习

15.1 基本概念 机器学习中的规则通常是指语义明确、能描述数据分布所隐含的客观规律或邻域概念、可写成“若…,则…”形式的逻辑规则。规则学习是从训练数据中学习出一组能用于对未见示例进行判别的规则。 与神经网络、支持向量机这样的黑箱模型相比&#xff0c;规则学习具有…

NewStarCTF公开赛week3密码学前两道题的wp

目录一、keyExchange1.原题2.考察知识点与解题思路Diffie-Hellman密钥交换3.解题脚本二、Prof. Shamirs Secret1.原题2.考察知识点与解题思路Shamir 门限方案3.解题脚本一、keyExchange 1.原题 题目给出的是题目给出的是加密过程和输出&#xff1a; from secret import flag…

【LeetCode每日一题:2011. 执行操作后的变量值~~~模拟】

题目描述 存在一种仅支持 4 种操作和 1 个变量 X 的编程语言&#xff1a; X 和 X 使变量 X 的值 加 1 –X 和 X-- 使变量 X 的值 减 1 最初&#xff0c;X 的值是 0 给你一个字符串数组 operations &#xff0c;这是由操作组成的一个列表&#xff0c;返回执行所有操作后&…

Merge-On-Write 的处理流程

简单来讲&#xff0c;Merge-On-Write 的处理流程是&#xff1a; 对于每一条 Key&#xff0c;查找它在 Base 数据中的位置&#xff08;rowsetid segmentid 行号&#xff09; 如果 Key 存在&#xff0c;则将该行数据标记删除。标记删除的信息记录在 Delete Bitmap 中&#xff…

【C++】多态(万字详解) —— 条件 | 虚函数重写 | 抽象类 | 多态的原理

&#x1f308;欢迎来到C专栏~~多态 (꒪ꇴ꒪(꒪ꇴ꒪ )&#x1f423;,我是Scort目前状态&#xff1a;大三非科班啃C中&#x1f30d;博客主页&#xff1a;张小姐的猫~江湖背景快上车&#x1f698;&#xff0c;握好方向盘跟我有一起打天下嘞&#xff01;送给自己的一句鸡汤&#x1…

Logoist - 适用于设计师以及初次使用者,快速制作精美 logo

Logoist - 适用于设计师以及初次使用者的快速制作精美 logo 工具 从简单的标识到设计开发。它只需要一点时间来创建令人印象深刻的图像和矢量图形与Logoist。 我们的一体化应用程序为您提供了您需要的一切&#xff0c;将您的创意付诸实践或寻找新的灵感!它适合专业设计师和插画…

阿里云将加速与伙伴合作 促进Web3.0生态发展

12 月 15 日&#xff0c;在Web3.0 Cloud Day Singapore 2022 活动上&#xff0c;阿里云新加坡、南亚和泰国总经理 Dr Derek Wang 表示&#xff0c;阿里云将加速和伙伴的合作以促进创新。“我们正在与我们的合作伙伴合作以实现创新。我们仍然处于 Web 3.0 的早期阶段。我们仍然需…

【蓝桥杯选拔赛真题53】Scratch破解保险柜 少儿编程scratch图形化编程 蓝桥杯选拔赛真题讲解

目录 scratch破解保险柜 一、题目要求 编程实现 二、案例分析 1、角色分析

大数据处理之ClickHouse概述及架构参考(未完)

一、概述 中移某业务拨测系统基于业务数据拨测指标及日志的分析需要&#xff0c;随着Clickhouse在OLAP领域的快速崛起&#xff0c;以及一些特性考虑&#xff0c;比如&#xff1a; 数据量会很大&#xff0c;最好需要分布式&#xff1b; 支持实时写入&#xff0c;支持快速计算&a…

数据库管理-第四十九期 Exadata的存储节点管理(20221223)

数据库管理 2022-12-23第四十九期 Exadata的存储节点管理1 咋个查看数据是否被缓存到闪存卡了没2 EM13.5的Exadata监控3 存储降级总结第四十九期 Exadata的存储节点管理 本周二&#xff0c;抗原终于阴性了&#xff0c;星期三开始就回到现场开始办公。上周既然说了Exadata关于存…

[C++: 引用】

To shine,not be illuminated. 目录 1 引用概念 2 引用特性 3 常引用 4 使用场景 4.1 引用做参数 4.2 做返回值 5 传值、传引用效率比较 6 引用和指针的区别 7 总结 1 引用概念 引用不是新定义一个变量&#xff0c;而是给已存在变量取了一个别名&#xff0c;编译器不会为…

Java+Swing+mysql会员卡管理系统

JavaSwingmysql会员卡管理系统一、系统介绍二、功能展示1.主页页面2.会员信息查询3.会员信息删除三、系统实现1.members.java四、其它1.其他系统实现一、系统介绍 使用 Java 技术开发一个会员卡管理系统&#xff0c;具体实现功能如下&#xff1a; 1. 程序启动显示主界面&#…

Vue:从组件开始学习

文章目录Vue组件生命周期根据官网文档&#xff0c;我们可以快速使用vue3创建自己的应用代码&#xff1a;npm init vuelatest&#xff0c;然后根据自己的需要来选择对应的配置&#xff1a; 默认使用vite来配置项目的。 在main.ts入口文件中&#xff0c;我们可以看到&#xff0…

非零基础自学Golang 第17章 HTTP编程(上) 17.5 知识拓展

非零基础自学Golang 文章目录非零基础自学Golang第17章 HTTP编程(上)17.5 知识拓展17.5.1 curl工具详解第17章 HTTP编程(上) 17.5 知识拓展 17.5.1 curl工具详解 【1】curl 简介 curl是一个利用URL语法在命令行下工作的文件传输工具&#xff0c;于1997年首次发行。它支持文…