树03_AVL树

最新推荐文章于 2024-03-28 12:21:05 发布
最新推荐文章于 2024-03-28 12:21:05 发布
阅读量168 收藏
点赞数
分类专栏： 数据结构 文章标签： avl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43589563/article/details/119652645
版权

AVL树

概念

苏联科学家发明的
节点的平衡因子
节点左右子树的高度差

AVL树特点
每个节点的平衡因子<1
增删改查的时间复杂度都是O(logN)
在这里插入图片描述
二叉树\二叉搜索树\AVL树继承结构
在这里插入图片描述
AVL树和红黑树都是二叉搜索树

AVL树添加操作

由于节点的添加是随机的,没法干预,只能再节点添加或者删除操作做完之后,对此节点进行调整,从而维持树的平衡.
(1)在添加节点之后增加了 afterAdd() 用于调整平衡；
(2)在删除节点之后增加了 afterRemove() 用于调整平衡；

1.添加导致失衡分析

在这里插入图片描述
(1)添加节点，不会导致直接父节点失衡

父节点有两种情况：叶子结点或者度为1,二者添加子节点都不会失衡。

(2)祖先节点可能会失衡

1.当祖先节点的左右子树的高度差为0，添加不会导致失衡。
2.当祖先节点的左右子树高度差为1，添加可能会导致失衡，并且会造成连锁反应。

(3)非祖先节点都不会失衡

2.修复平衡的操作

LL – 右旋转（单旋）
RR – 左旋转（单旋）
LR – 先左旋，再右旋（双旋）
RL – 先右旋，再左旋（双旋）

经过旋转后仍然是二叉平衡树

有些教程里面：
• 把右旋转叫做 zig，旋转之后的状态叫做 zigged
• 把左旋转叫做 zag，旋转之后的状态叫做 zagged

(1) LL- 右旋转

前提:

添加节点的父节点:n
n的父节点p
p的父节点g

在这里插入图片描述
右旋转的情况:

n = p.left
p = g.left
n节点下添加了新的节点,导致g节点失衡

处理方法：右旋转

	让p的右子树变为g的左子树
	g变为p的右子节点

右旋：变成当前节点左子节点的右子节点
右旋的特点：对g进行右旋转，我们假设g的父节点为G，那么旋转后会发现G的子节点为p，并且G子树由添加后失衡变为回复平衡；回复平衡后的G子树的高度和添加节点前的高度是一样的，因此整个二叉树恢复了平衡。
在这里插入图片描述

(2) RR – 左旋转（单旋）

在这里插入图片描述
RR情况：

	n = p.right
	p = g.right

失衡节点：g
处理方式：g节点左旋
左旋特点：g变成右子节点的左子节点

(3)LR

在这里插入图片描述

LR处理方式： 
		先对p进行左旋 ，变成LL
		在对g进行右旋

LR特点：n变为子节点

(4)LR

在这里插入图片描述

添加后修复总结

  • 修复操作核心：不改变BST性质
  • 修复操作特点：对于添加新节点后的失衡节点g来说，修复平衡后g的高度是不变的！
	由于修复后，g高度不变，因此g的祖先节点在g恢复平衡之后就恢复平衡了
	那么我们只需要修复g点即可！

3.afterAdd

修复平衡的操作是在一个新的节点添加进去完成后，开始进行修复；
因此需要在add()方法中 元素成功添加进去之后添加一个afterAdd()进行修复

1.二叉搜索树代码调整：

1.在二叉搜索树中添加一个afterAdd()方法，但是自身不实现这个方法
2.继承的AVL树中实现afterAdd()方法即可
如此一来，AVL树能实现平衡而不影响二叉搜索树

（1）添加方法：

  //todo 提供一个add后的操作，普通BST中不做任何实现
    protected void afterAdd(Node<E> node){}

（2）修改add()方法： 尾部插入afterAdd()

   public void add(E element){
        elementNotNullCheck(element);
        if(root == null){
            //root = new Node(element,null);
            root = createNode(element,null);
            size++;
            afterAdd(root);
            return;
        }
        //1.新节点插到哪个节点下面？
        //2.新节点插到该节点的左边还是右边？
        Node<E> node = root;
        Node<E> parent = null;
        int cmp = 0;
        while(node!=null){
            parent = node;
            cmp = Compare(node.element,element);
            if(cmp > 0){
                node = node.left;
            }else if(cmp < 0){
                node = node.right;
            }else{
                return;
            }
        }
        //Node<E> newNode = new Node(element,parent);
        Node<E> newNode = createNode(element,parent);
        if(cmp>0){
            parent.left = newNode;
        }else{
            parent.right = newNode;
        }
        size++;
        afterAdd(newNode);
    }

2.AVL树实现afterAdd(Node)

    @Override
    protected void afterAdd(Node<E> node) {
        
    }

1.明确失衡节点是谁，怎么修复

按照前面分析，失衡节点只会是node的祖先节点
只要修复了高度最低的失衡祖先节点，那么整个二叉树就平衡了

伪代码：

    protected void afterAdd(Node<E> node) {
        while((node = node.parent ) != null){
//            if(node 是平衡的){
//
//            }else{
//
//            }
        }
        //出来了，node = null
    }
2.1 判断平衡

根据节点的平衡因子来判断是否平衡；
平衡因子和节点的左右子树的高度有关系；
-> 因此可以对node类进行修改，在node中维护一个height属性
->但是只有在AVL树中需要height属性，普通BST不需要height属性
解决方法
在AVL树中自己维护一个Node类，继承BST中的Node

private static class AVLNode<E> extends Node<E>{
    private int height = 1; // 叶子节点的高度为1

    AVLNode(){}

    AVLNode(E element,Node<E> parent){
        this.element = element;
        this.parent = parent;
    }

问题2
在AVL树中维护了自己的AVLNode之后，但是add()方法是继承自BST的，那么就需要对创建Node进行一个封装，返回父类Node类型

	protected Node<E> createNode(E element,Node<E> parent){
        return new Node(element,parent);
    }

在AVLTree中，就要override此方法，返回AVLNode对象

    @Override
    protected Node<E> createNode(E element, Node<E> parent) {
        return new AVLNode<E>(element,parent);
    }

如此，在add()方法中，创建新的node的时候，就各自维护自己的node

AVLNode中添加有关平衡因子的方法
(1)由于left和right属性是从Node类继承过来的，因此这里需要进行强转才能使用height属性

//获取节点的平衡因子
    public int balanceFacotr(){
        int leftHeight = left==null? 0 : ((AVLNode<E>)left).height;
        int rightHeight = right==null? 0 : ((AVLNode<E>)right).height;
        return leftHeight - rightHeight;
    }

在AVLTree中添加判断节点是否平衡的方法:

 private boolean isBalanced(Node<E> node){
        return Math.abs(((AVLNode<E>)node).balanceFacotr()) <= 1;
    }
2.2更新高度

在AVLNode中添加更新高度的方法：


    //更新节点的高度
    public void updateHeight(){
        int leftHeight =  left==null? 0 : ((AVLNode<E>)left).height;
        int rightHeight = right==null? 0 : ((AVLNode<E>)right).height;
        height = Math.max(leftHeight,rightHeight) + 1;
    }

在AVLTree中：

   private void updateHeight(Node<E> node){
        ((AVLNode<E>)node).updateHeight();
    }

问题1：一个节点什么时候会被更新高度：

（1）只有添加的新节点node的祖先节点会更新高度；
（2）失衡节点g以及g的祖先节点不需要更新高度

因此如果要更新AVL树中节点的高度，需要从新节点遍历到g点，此间的每个节点需要更新高度

在伪代码中：

    protected void afterAdd(Node<E> node) {
        while((node = node.parent ) != null){
//            if(isBalanced(node)){
//
//            }else{
//
//            }
        }
        //出来了，node = null
    }

在获取平衡因子balanceFacotr()的时候是依赖左右子节点的高度的
我们需要沿着新节点的parent，挨个用isBalanced(node)判断祖先节点是否是平衡的，如果是平衡的，那就更新高度；如果不是平衡的，说明遇到g点了，此时就要做恢复平衡操作，并且g点往后不需要再更新高度了（参考：添加后修复总结的说明）

protected void afterAdd(Node<E> node) {
        //沿着parent一直往上找到第一个失衡的父节点
       while((node=node.parent)!= null){
           //新节点的父节点肯定是平衡的，因此从这往上一直更新到
           //失衡祖宗节点的高度
           if(isBalanced(node)){
               updateHeight(node);
           }else{
               //这是第一个不平衡的节点
                rebalance(node);
                break;//只需要恢复第一个不平衡节点即可
           }
       }
    }
2.3恢复平衡

恢复平衡的时候，我们必须要知道是哪种场景；
以LL为例，我们会发现p是g的较高子节点；同理，n是p的较高子节点；
也就是说：

	1.获取g的较高子节点p，判断g和p的关系
	2.获取p的较高子节点n，判断n和p的关系

在这里插入图片描述
在BinaryTree的Node中添加两个辅助方法：

 public boolean isLeftChild(){ // 判断自己是不是左子树
            return parent!=null && this==parent.left;
        }

        public boolean isRightChild(){ // 判断自己是不是右子树
            return parent!=null && this==parent.right;
        }

在AVLNode中：

  //返回较高的子节点，如果一样高，返回同方向的子节点
    public Node<E> tallerChild(){
        int leftHeight = left==null? 0 : ((AVLNode<E>)left).height;
        int rightHeight = right==null? 0 : ((AVLNode<E>)right).height;
        Node<E> ReNode = leftHeight > rightHeight? left : right;
        if(leftHeight == rightHeight){//返回相同方向的
            if(this.isLeftChild()){
                ReNode = left;
            }else{
                ReNode = right;
            }
        }
        return ReNode;
    }
}

balance方法：

//给Node恢复平衡  node是高度最低的失衡节点g
    private void rebalance(Node<E> node){
        //必须得获取n\p\g的关系，才能知道是四种失衡情况的哪一种
        //p是g左右子树中高度最高的节点
        //n是p左右子树中高度最高的节点
        Node<E> parent = ((AVLNode<E>)node).tallerChild();
        Node<E> n =  ((AVLNode<E>)parent).tallerChild();
        if(parent.isLeftChild()){
            if(n.isLeftChild()){
                //LL
                rotateRight(node);
            }else{
                //LR
                rotateLeft(parent);
                rotateRight(node);
            }
        }else{
            if(n.isLeftChild()){
                //RL
                rotateRight(parent);
                rotateLeft(node);
            }else{
                //RR
                rotateLeft(node);
            }
        }

    }

旋转操作：


    //左旋转
    protected void rotateLeft(Node<E> node) {
        Node<E> parent = node.right;
        Node<E> child =  parent.left;

        
        parent.left = node;
        node.right = child;
        
		//更新父子关系
        afterRotate(node,parent,child);
        
        //旋转之后，要更新grand和parent的高度
        updateHeight(node);
		updateHeight(p);
    }


    protected void rotateRight(Node<E> node){
        Node<E> parent = node.left;
        Node<E> child =  parent.right;

        parent.right = node;
        node.left = child;
		
		//更新父子关系
        afterRotate(node,parent,child);

		//旋转之后，要更新grand和parent的高度
        updateHeight(node);
        updateHeight(p);
    }

    protected void afterRotate(Node<E> grand,Node<E> parent,Node<E> child){
        //todo 1.更新parent的 父子关系
        parent.parent = grand.parent;
        if(grand.isLeftChild()){
            grand.parent.left = parent;
        }else if(grand.isRightChild()){
            grand.parent.right = parent;
        }else{
            root = parent;
        }
        //todo 2.更新child的父子关系
        if(child != null){
            child.parent = grand;
        }
        //todo 3.更新grand的父子关系
        grand.parent = parent;
    }
2.4恢复平衡的统一操作

在这里插入图片描述
g>f>e>d>c>b>a
四种情况，最终旋转完毕的结果都是一样的，d成为根节点
a和b的关系以及f和g的关系始终不变，因此a和g可以不处理。

private void rotate(
        Node<E> r, // 子树的根节点
        Node<E> b, Node<E> c,
        Node<E> d,
        Node<E> e, Node<E> f) {
    // 让d成为这颗子树的根结点
    d.parent = r.parent;
    if (r.isLeftChild()) {
        r.parent.left = d;
    } else if (r.isRightChild()) {
        r.parent.right = d;
    } else {
        root = d;
    }
    // b-c
    b.right = c;
    if (c != null) {
        c.parent = b;
    }
    updateHeight(b);

    // e-f
    f.left = e;
    if (e != null) {
        e.parent = f;
    }
    updateHeight(f);

    // b-d-f
    d.left = b;
    d.right = f;
    b.parent = d;
    f.parent = d;
    updateHeight(d);
}

注意：
只有左右子树改变的需要更新高度
更新高度的顺序必须是先更新低的节点

对应的修改rebalance方法：
在这里插入图片描述

4.AVL树删除操作

1.删除节点造成的失衡分析

在这里插入图片描述
在这里插入图片描述

  • 删除节点，导致直接父节点 或 祖先节点 失衡
  • 删除节点只会导致一个节点失衡
分析：
失衡节点在失衡前肯定是平衡的且平衡因子必须为1
因此删除节点后，该失衡节点的平衡因子变成了2
这意味着删除了该失衡节点的较短的一条腿
那么就不会影响失衡节点的高度
既然失衡节点高度不会变，那么失衡节点的祖先节点的高度就不会受到影响；
因此只会导致一个节点失衡；

2.删除导致失衡的恢复方案

1）LL

在这里插入图片描述

  • 恢复平衡的过程中，可能会引发连锁反应
    如图所示，删除的节点是红色的，当红色节点被删除，变成LL的情况，此时需要对g进行右旋转。
    如果绿色节点不存在，旋转之后，该子树的高度-1，这就有可能引发连锁反应。
    极端情况下被删除节点的所有祖先节点都需要进行恢复平衡的操作，共 O(logn) 次调整

说白了，对节点g进行rebalance操作，会导致以g为根节点的子树的高度降低1，这和删除一个节点造成的情况是一样的！

	因此在remove方法中找到被删除节点del之后，对del进行删除
	然后从del节点的parent开始找失衡节点，不管节点是否失衡，都需要更新高度
2）RR

在这里插入图片描述

3）LR

在这里插入图片描述

4）RL

在这里插入图片描述

3.删除代码实现

添加afterRemove(Node node)

由于节点的删除也是随机的，因此只能在删除操作完成之后，添加一个后处理方法，对树进行平衡恢复
1.方法添加位置
在节点被删除后；
这里需要注意：参数node是被删除的节点，对于度为2的节点的删除，删除的是其前驱节点或者后继节点。

    private void remove(Node<E> node){
        if(node == null) return;
        //先处理度为2的节点，因为也是删除度为1的节点
        // 找到要被删除的节点
        Node<E> del = null;
        if(node.left != null && node.right != null){
            del = predesessor(node);//前继节点
            node.element = del.element;
        }else{
            del = node;
        }

        Node<E> child = del.left == null ? del.right:del.left;
        if(child != null){
            child.parent = del.parent;
        }
        if(del.parent == null){
            root = child;
        }else{
            if(del == del.parent.left){
                del.parent.left = child;
            }else{
                del.parent.right = child;
            }
        }

        //节点真正被删除的时候删除
        afterRemove(del);
        size--;
    }

2.具体的实现

protected void afterRemove(Node<E> node) {
    //沿着parent一直往上找到第一个失衡的父节点
    while((node=node.parent)!= null){
        //新节点的父节点肯定是平衡的，因此从这往上一直更新到
        //失衡祖宗节点的高度
        if(isBalanced(node)){
            updateHeight(node);
        }else{
            //这是第一个不平衡的节点
            rebalance(node);
            //break;
        }
    }
}
  • 对比 afterAdd()只需要修复最低的失衡节点，因此在修复后break终止循环；而删除节点可能会引发多个祖父节点失衡，因此afterRemove()只需要去掉break即可。
  • 需要注意的是：在删除节点的过程中，我们并没有修改del节点的parent，因此node=node.parent是一直有效的。
  • 当节点是平衡的 只做高度的更新
  • 当节点是失衡的，做恢复平衡的操作(在afterRotate()中有对失衡节点的高度更新操作)
    所以：删除操作，del节点的所有祖先节点都需要更新高度 增加操作，高度更新只需要到失衡节点即可

AVL树总结

  • AVL树在二叉搜索树引入了平衡因子的概念；通过维护每个节点的平衡因子<1 从而实现二叉搜索树不会退化成链表；
  • AVL树核心操作是在BST的基础上增加了afterAdd()和afterRemove()两个操作，对增和删操作进行平衡修复

添加操作

失衡：添加导致g点失衡，g点的高度会改变，从而可能会导致g点所有祖先节点都失衡
     失衡节点不会是直接父节点
     
修复：修复后的g点高度和失衡前的g点高度是一样的，因此只要让高度最低的失衡节点恢复平衡，整棵树就恢复平衡
    【仅需 O(1) 次调整】
  • 删除
失衡：删除导致g点失衡，但是g的高度不会改变，从而只会造成一个节点失衡。
	 失衡节点可能是直接父节点或 祖先节点
	 
修复：g点恢复平衡可能会改变g点高度，因此恢复平衡后，可能会导致更高层的祖先节点失衡
    【最多需要 O(logn) 次调整】

平均时间复杂度

  • 搜索：O(logn)
  • 添加：O(logn)，仅需 O(1) 次的旋转操作
  • 删除：O(logn)，最多需要 O(logn) 次的旋转操作
败给你的黑色幽默丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
avl树.rar_AVL树_avl_avltree_c avl
09-14
AVL树的创建与基本操作
【C++入门到精通】C++入门 —— AVL 树（自平衡二叉搜索树）
Yawesh的博客
10-04 520
AVL树是一种自平衡二叉搜索树，可以保证树的任何节点的左子树和右子树的高度差不超过1，从而提供了较好的查找、插入和删除操作的时间复杂度保证。AVL树的核心思想是在每个节点上保存一个平衡因子，表示其左子树高度和右子树高度之差。在进行插入和删除操作时，如果插入或删除后导致树的某个节点的平衡因子的绝对值大于1，就需要进行旋转操作来恢复平衡。AVL树的插入和删除操作的时间复杂度都为O(log n)。AVL树的优点是保证树的平衡性，提供了较好的时间复杂度保证；缺点是在进行插入和删除操作时可能需要花费更多的时间和空间。
平衡树之 AVL 树
qq_42611255的博客
06-03 106
平衡树（Balanced Tree）是一种特殊的二叉搜索树，它通过自动调整节点的插入和删除操作，以保持树的平衡性。在平衡树中，任何节点的左右子树的高度差不超过一个预定义的常数（自平衡）。平衡树的概念是由和Evgenii Landis 两位计算机科学家提出来的，并提供了平衡树的实现–AVL 树， 该树的名称就是由两位作者的姓氏命名的，他们在1962年的论文中公开了这一数据结构。当然，平衡树不止有 AVL 树一种，像后面出现的 2-3 树， 2-3-4 树， 红黑树等都是平衡树的实现。
数据结构——AVL树详解
最新发布
rab1211764820的博客
03-28 1156
AVL树的模拟实现 AVL树的插入、旋转、删除、查找 AVL树的验证 AVL树的平衡因子
AVL树的左旋与右旋
思月行云
03-07 177
笔者认为AVL树的维持平衡的思想理解起来相对来说还是有点难度的，所以这里做一下总结，希望能帮助到读者。首先，AVL树基于二分搜索树，不同的是它要求每一个节点保持平衡。那么在插入新元素的时候就可能会破坏原本的平衡性（当然删除元素也会，删除和添加是逆向操作，如果明白了本章内容，删除操作也是非常简单的，这一部分内容下一章再进行补充），所以就需要我们使用左旋或者右旋进行维护它的平衡。那么不平衡的情况一共是四种，如下图：imageimageimageimage针对不同的情况，做不同的旋转即可。
AVL树的插入与删除
haliluya123a的博客
08-25 672
AVL 树要在插入和删除结点后保持平衡，旋转操作必不可少。关键是理解什么时候应该左旋、右旋和双旋。在Youtube上看到一位老师的视频对这个概念讲解得非常清楚，再结合算法书和网络的博文，记录如下。 1.1 AVL 的旋转 一棵AVL树是其每个节点的左子树和右子树的高度差最多为1的二叉查找树(空树高度定义为-1)。AVL树插入和删除时都可能破坏AVL的特性，可以通过对树进行修正来保证特性，修正方
二叉搜索树 详解，中序遍历伪代码 ，AVL原理讲解【c++详解】（含代码）
BZ_C25LX 的博客
11-13 1152
二叉查找树的基本操作和复杂度分析，AVL树原理讲解
详解AVL树（平衡二叉树）
水澹澹兮生烟
09-20 2万+
插入节点后对树进行旋转调整，分为四种情况。 1.右单旋 当一个平衡二叉树满足具有较高左子树时（如下图A），且要插入的节点插入到了较高左子树的左侧，此时进行右单旋。
数据结构 —— 图解AVL树(平衡二叉树)
热门推荐
猎人在吃肉
07-28 3万+
文章目录1、AVL树(平衡二叉树)的定义1.1、平衡因子2、AVL树的作用：3、AVL树的基本操作3.1、插入—— 左左型的右旋：3.1.1、右旋的具体步骤：3.1.2、右旋的动画演示：3.1.3、右旋示例：3.2、插入——右右型的左旋：3.2.1、左旋的具体步骤：3.2.2、动画演示：3.2.3、左旋举例：3.3、插入——左右型的左右旋 ( 即先左后右)：3.3.1、左右旋的两次旋转步骤：3.3...
AVL树（动图详解）
2021dragon的博客
12-02 1万+
AVL树（C++实现）
AVL.rar_AVL树_avl_avl树源代码
09-14
AVL tree。 AVL树的源代码。以及基本函数
数据结构与算法代码,有图，二叉树，avl树,最短路径
06-16
数据结构与算法代码,有图，二叉树，avl树,最短路径
avl_tree.rar_ avl_tree_AVL树_avl
09-22
avl树的实现： avl树是每个节点的左子树和右子树的高度最多差1的二叉查找树.一棵高度为h的avl树最少节点数由S(h) = S(h-1)+S(h-2)+1得到.avl树要保证任一节点的左右子树的高度之差的绝对值不能超过1(空树的高定义为1...
AVL.rar_AVL树_avl
09-19
avl，数据结构，平衡查找二叉树，支持添加、删除、查找！
AVL_tree.rar_AVL树_avl
09-20
哈尔滨工业大学，计算机科学与技术学院，数据结构，作业五：AVL树相关操作实现
【数据结构】AVL树
weixin_74078718的博客
05-12 2910
AVL树的概念、定义、插入、旋转等内容。
数据结构--AVL树（全）
weixin_48560325的博客
05-01 8250
目录 什么是AVL树？ AVL树的特点及形成原因 二叉搜索树基本概念 二叉搜索的特点 二叉搜索树的优点及缺点 改进的二叉搜索树——AVL树 AVL树的定义 AVL树的特点 结点的平衡因子balance 构建一个AVL树 构建一个AVL树的节点 什么是AVL树？ AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。 AVL树的特点及形成原因 AVL树本质.
AVL树详解
Allence的博客
02-14 1万+
一、简介 AVL树是根据它的发明者G.M. Adelson-Velsky和E.M. Landis命名的。它是最先发明的自平衡二叉查找树，也被称为高度平衡树。 上面的两张图片，左边的是AVL树，它的任何节点的两个子树的高度差别都<=1；而右边的不是AVL树，因为7的两颗子树的高度相差为2(以2为根节点的树的高度是3，而以8为根节点的树的高度是1)。 AVL树的查找、插入和删除在平均和最坏情况下都是O(logn)。 如果在AVL树中插入或删除节点后，使得高度之差大于1。此时，AVL树的平衡状..
AVL树（平衡二叉搜索树）
langk_的博客
09-03 3208
带你手撕AVL树，左单旋，右单旋，左右双旋，右左双旋
判断是否为avl树
05-29
判断一棵二叉树是否为 AVL 树，需要满足以下两个条件： 1. 该二叉树的所有子树都是 AVL 树； 2. 该二叉树的任意两个子树高度差的绝对值不超过 1。 其中，子树的高度指的是该子树的根节点到叶子节点的最长路径长度...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值