计算机基础---＞数据结构（6）【AVL树（平衡二叉树）】

最新推荐文章于 2024-07-19 23:15:41 发布
最新推荐文章于 2024-07-19 23:15:41 发布
阅读量421 收藏
点赞数
分类专栏： 计算机基础 # 数据结构 文章标签： 数据结构 AVL树 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56781779/article/details/131533949
版权

文章目录

AVL（平衡二叉树）树

平衡二叉树是一种特殊的二叉搜索树，他的左子树与右子树的高度差不超过1。并且左右两个子树都是一颗平衡二叉树。保持平衡的特性使得平衡二叉树的查询、插入和删除操作在平均和最坏情况下的时间复杂度都是O(logn)，其中n是树中节点的数量。 相比于普通的二叉搜索树，平衡二叉树更加适合处理动态变化的数据集。 常见的平衡二叉树有AVL树、红黑树以及B树等。这些树结构通过在插入或删除节点时进行特定的平衡操作来保持树的平衡。

性质

  • 它的左右子树都是AVL树
  • 左右子树高度差不超过1
  • 完全二叉树是AVL树，如果一棵树是AVL树，那么其高度可保持在O(log2n)，搜索时间复杂度为O(log2n)

AVL树的操作（Java）

首先创建节点用来保存树中的节点的数据，其次和二叉搜索树不同的是，AVL树需要平衡因子来控制二叉树的平衡。

节点的创建

    private class Node {
        int val;
        Node left;
        Node right;
        int height;

        public Node(int val) {
            this.val = val;
            this.left = this.right = null;
            this.height = 1;
        }
    }

AVL树的插入

插入操作和二叉搜索树是相同的，但是在插入结束时会判断AVL树是否平衡。

    // 向树中添加节点
    public void add(int val) {
        if (contains(val)) {
            return;
        }
        this.root = add(this.root, val);
        this.size++;
    }

    // 向AVL树中添加节点
    private Node add(Node node, int val) {
        // 递归到底的情况
        if (node == null) {
            return new Node(val);
        }
        if (node.val > val) {
            node.left = add(node.left, val);
        } else {
            node.right = add(node.right, val);
        }
        // 更新节点高度
        node.height = Math.max(getNodeHeight(node.left), getNodeHeight(node.right)) + 1;

        // 维护平衡
        int balance = getBalance(node);
        if (balance > 1 && getBalance(node.left) >= 0) {
            // 右旋
            return rightRotate(node);
        } else if (balance > 1 && getBalance(node.left) <= 0) {
            // 左旋右旋
            node.left = leftRotate(node.left);
            return rightRotate(node);
        } else if (balance < -1 && getBalance(node.right) >= 0) {
            // 右旋左旋
            node.right = rightRotate(node.right);
            return leftRotate(node);
        } else if (balance < -1 && getBalance(node.right) <= 0) {
            // 左旋
            return leftRotate(node);
        }
        return node;
    }

1.判断平衡

一个二叉树是否是平衡的，根绝二叉树的性质可以知道，当其左右子树节点的高度差的绝对值不超过1时，这个二叉树就是平衡二叉树，当其高度差绝对值超过1时，那么就是不平衡的二叉树，就需要对二叉树进行平衡调整。

 // 获取当前节点的平衡因子（左右子树高度差）
    private int getBalance(Node node) {
        if (node == null) {
            return 0;
        }
        return getNodeHeight(node.left) - getNodeHeight(node.right);
    }

2.保持树的平衡

当判断出一棵树不平衡时，需要进行平衡调整。

二叉树一般出现不平衡的时候有四种状态：

1. 左旋
在这里插入图片描述

根据上图，我们可以直到，当二叉树的右树的高度超过平衡时需要进行左旋，左旋的方式是先将x节点的左子树单独定义出来为t2，然后将y节点连接到x的左子树，将t2连接到y的右子树上，这时就完成了左旋。

    // 左旋转
    private Node leftRotate(Node y) {
        Node x = y.right;
        Node leftX = x.left;
        x.left = y;
        y.right = leftX;
        y.height = 1 + Math.max(getNodeHeight(y.left), getNodeHeight(y.right));
        x.height = 1 + Math.max(getNodeHeight(x.left), getNodeHeight(x.right));
        return x;
    }

2. 右旋
在这里插入图片描述

右旋转和左旋转类似，右旋的方式是先将x节点的右子树单独定义出来为t2，然后将y节点连接到x的右子树，将t2连接到y的左子树上，这时就完成了右旋。

    // 右旋转
    private Node rightRotate(Node y) {
        Node x = y.left;
        Node rightX = x.right;
        x.right = y;
        y.left = rightX;
        y.height = 1 + Math.max(getNodeHeight(y.left), getNodeHeight(y.right));
        x.height = 1 + Math.max(getNodeHeight(x.left), getNodeHeight(x.right));
        return x;
    }

3. 右旋+左旋

在这里插入图片描述

所谓右旋+左旋就是将右旋和左旋进行连接，将这类不平衡的树进行平衡

4. 左旋+右旋

在这里插入图片描述

3.判断是否AVL树

判断是否AVL树就是判断二叉树的各个节点的平衡因子是否都是小于等于1或者大于等于-1。

    // 判断是否为平衡二叉树
    public boolean isBalanceTree() {
        return isBalanceTree(this.root);
    }

    private boolean isBalanceTree(Node node) {
        if (node == null) {
            return true;
        }
        if (Math.abs(getBalance(node)) > 1) {
            return false;
        }
        return isBalanceTree(node.left) && isBalanceTree(node.right);
    }

 	// 获取当前节点的平衡因子（左右子树高度差）
    private int getBalance(Node node) {
        if (node == null) {
            return 0;
        }
        return getNodeHeight(node.left) - getNodeHeight(node.right);
    }

4.删除节点

    // 删除任意节点
    public void remove(int val) {
        boolean isExist = contains(val);
        if (isExist) {
            this.root = remove(this.root, val);
        }
    }

    // 从以node为根的二分搜索树中删除值为val的结点
    private Node remove(Node node, int val) {
        Node resultNode = null;
        if (node.val == val) {
            // 叶子节点
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                this.size--;
                resultNode = rightNode;
            } else if (node.right == null) {
                Node leftNode = node.left;
                node.left = null;
                this.size--;
                resultNode = leftNode;
            } else {
                // 找出删除节点的后继
                Node nextNode = getMinNode(node.right);
                // 从右树中删除最小节点
                nextNode.right = removeMinNode(node.right);
                // 开始连接
                nextNode.left = node.left;
                // 让node失去关联关系
                node.left = node.right = null;
                resultNode = nextNode;
            }
        } else if (node.val > val) {
            node.left = remove(node.left, val);
            resultNode = node;
        } else {
            node.right = remove(node.right, val);
            resultNode = node;
        }

        // 删除的是叶子节点
        if (resultNode == null) {
            return null;
        }

        // 删除之后，可能改变了树的平衡，因此需要进行调整
        resultNode.height = Math.max(getNodeHeight(resultNode.left), getNodeHeight(resultNode.right)) + 1;

        Node result = resultNode;
        if (getBalance(resultNode) > 1 && getBalance(resultNode.left) >= 0) {
            result = rightRotate(resultNode);
        } else if (getBalance(resultNode) < -1 && getBalance(resultNode.right) <= 0) {
            result = leftRotate(resultNode);
        } else if (getBalance(resultNode) > 1 && getBalance(resultNode.left) < 0) {
            resultNode.left = leftRotate(resultNode.left);
            result = rightRotate(resultNode);
        } else if (getBalance(resultNode) < -1 && getBalance(resultNode.right) > 0) {
            resultNode.right = rightRotate(resultNode.right);
            result = leftRotate(resultNode);
        }
        return result;
    }

全部代码

import java.util.*;

public class AVLTree {

    private Node root;
    private int size;

    public AVLTree() {
        this.root = null;
        this.size = 0;
    }

    // 判断是否为空
    public boolean isEmpty() {
        return this.size == 0;
    }

    // 获取树中节点个数
    public int getSize() {
        return this.size;
    }

    // 获取节点高度
    public int getNodeHeight(Node node) {
        if (node == null) {
            return 0;
        }
        return node.height;
    }

    // 获取当前节点的平衡因子（左右子树高度差）
    private int getBalance(Node node) {
        if (node == null) {
            return 0;
        }
        return getNodeHeight(node.left) - getNodeHeight(node.right);
    }

    // 查找最小节点
    public Node getMinNode() {
        if (this.root == null) {
            return null;
        }
        return getMinNode(this.root);
    }

    private Node getMinNode(Node node) {
        if (node.left == null) {
            return node;
        }
        return getMinNode(node.left);
    }

    // 判断是否重复
    public boolean contains(int val) {
        return contains(this.root, val);
    }

    private boolean contains(Node node, int val) {
        if (node == null) {
            return false;
        }
        if (node.val == val) {
            return true;
        } else if (node.val > val) {
            return contains(node.left, val);
        } else {
            return contains(node.right, val);
        }
    }

    // 向树中添加节点
    public void add(int val) {
        if (contains(val)) {
            return;
        }
        this.root = add(this.root, val);
        this.size++;
    }

    // 向AVL树中添加节点
    private Node add(Node node, int val) {
        // 递归到底的情况
        if (node == null) {
            return new Node(val);
        }
        if (node.val > val) {
            node.left = add(node.left, val);
        } else {
            node.right = add(node.right, val);
        }
        // 更新节点高度
        node.height = Math.max(getNodeHeight(node.left), getNodeHeight(node.right)) + 1;

        // 维护平衡
        int balance = getBalance(node);
        if (balance > 1 && getBalance(node.left) >= 0) {
            // 右旋
            return rightRotate(node);
        } else if (balance > 1 && getBalance(node.left) <= 0) {
            // 左旋右旋
            node.left = leftRotate(node.left);
            return rightRotate(node);
        } else if (balance < -1 && getBalance(node.right) >= 0) {
            // 右旋左旋
            node.right = rightRotate(node.right);
            return leftRotate(node);
        } else if (balance < -1 && getBalance(node.right) <= 0) {
            // 左旋
            return leftRotate(node);
        }
        return node;
    }

    // 从二分搜索树中删除最小节点
    public Node removeMinNode() {
        if (this.root == null) {
            return null;
        }
        Node result = getMinNode();
        if (result != null) {
            this.root = removeMinNode(this.root);
            this.size--;
        }
        return result;
    }

    private Node removeMinNode(Node node) {
        if (node.left == null) {
            return node.right;
        }
        node.left = removeMinNode(node.left);
        return node;
    }

    // 删除任意节点
    public void remove(int val) {
        boolean isExist = contains(val);
        if (isExist) {
            this.root = remove(this.root, val);
        }
    }

    // 从以node为根的二分搜索树中删除值为val的结点
    private Node remove(Node node, int val) {
        Node resultNode = null;
        if (node.val == val) {
            // 叶子节点
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                this.size--;
                resultNode = rightNode;
            } else if (node.right == null) {
                Node leftNode = node.left;
                node.left = null;
                this.size--;
                resultNode = leftNode;
            } else {
                // 找出删除节点的后继
                Node nextNode = getMinNode(node.right);
                // 从右树中删除最小节点
                nextNode.right = removeMinNode(node.right);
                // 开始连接
                nextNode.left = node.left;
                // 让node失去关联关系
                node.left = node.right = null;
                resultNode = nextNode;
            }
        } else if (node.val > val) {
            node.left = remove(node.left, val);
            resultNode = node;
        } else {
            node.right = remove(node.right, val);
            resultNode = node;
        }

        // 删除的是叶子节点
        if (resultNode == null) {
            return null;
        }

        // 删除之后，可能改变了树的平衡，因此需要进行调整
        resultNode.height = Math.max(getNodeHeight(resultNode.left), getNodeHeight(resultNode.right)) + 1;

        Node result = resultNode;
        if (getBalance(resultNode) > 1 && getBalance(resultNode.left) >= 0) {
            result = rightRotate(resultNode);
        } else if (getBalance(resultNode) < -1 && getBalance(resultNode.right) <= 0) {
            result = leftRotate(resultNode);
        } else if (getBalance(resultNode) > 1 && getBalance(resultNode.left) < 0) {
            resultNode.left = leftRotate(resultNode.left);
            result = rightRotate(resultNode);
        } else if (getBalance(resultNode) < -1 && getBalance(resultNode.right) > 0) {
            resultNode.right = rightRotate(resultNode.right);
            result = leftRotate(resultNode);
        }
        return result;
    }

    // 中序遍历
    public List<Integer> middleTravel() {
        List<Integer> list = new ArrayList<>();
        middleTravel(this.root, list);
        return list;
    }

    private void middleTravel(Node node, List<Integer> list) {
        if (node == null) {
            return;
        }
        middleTravel(node.left, list);
        list.add(node.val);
        middleTravel(node.right, list);
    }

    // 层序遍历
    private List<Node> levelTravel() {
        List<Node> list = new ArrayList<>();
        Queue<Node> queue = new LinkedList<>();
        if (this.root == null) {
            return list;
        }
        queue.offer(this.root);
        while (!queue.isEmpty()) {
            Node node = queue.poll();
            list.add(node);
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
        return list;
    }

    // 判断是否是二分搜索树
    public boolean isBinearySearchTree() {
        List<Integer> list = middleTravel();
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i - 1) > list.get(i)) {
                return false;
            }
        }
        return true;
    }

    // 判断是否为平衡二叉树
    public boolean isBalanceTree() {
        return isBalanceTree(this.root);
    }

    private boolean isBalanceTree(Node node) {
        if (node == null) {
            return true;
        }
        if (Math.abs(getBalance(node)) > 1) {
            return false;
        }
        return isBalanceTree(node.left) && isBalanceTree(node.right);
    }

    // 右旋转
    private Node rightRotate(Node y) {
        Node x = y.left;
        Node rightX = x.right;
        x.right = y;
        y.left = rightX;
        y.height = 1 + Math.max(getNodeHeight(y.left), getNodeHeight(y.right));
        x.height = 1 + Math.max(getNodeHeight(x.left), getNodeHeight(x.right));
        return x;
    }

    // 左旋转
    private Node leftRotate(Node y) {
        Node x = y.right;
        Node leftX = x.left;
        x.left = y;
        y.right = leftX;
        y.height = 1 + Math.max(getNodeHeight(y.left), getNodeHeight(y.right));
        x.height = 1 + Math.max(getNodeHeight(x.left), getNodeHeight(x.right));
        return x;
    }

    public String show() {
        // 按层遍历树
        List<Node> list = levelTravel();
        String s = "";
        for (int i = 0; i < list.size(); i++) {
            s += "size = " + list.get(i).val + ", height = " + list.get(i).height + ", balance = " + getBalance(list.get(i)) + ";\n";
        }
        return s;
    }

    @Override
    public String toString() {
        // 按层遍历树
        List<Node> list = levelTravel();
        String s = "["+list.get(0).val;
        for (int i = 1; i < list.size(); i++) {
            s += "," + list.get(i).val;
        }
        s += "]";
        return s;
    }

    private class Node {
        int val;
        Node left;
        Node right;
        int height;

        public Node(int val) {
            this.val = val;
            this.left = this.right = null;
            this.height = 1;
        }
    }

    public static void main(String[] args) {
        AVLTree avlTree = new AVLTree();
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            avlTree.add(i);
            avlTree.add(random.nextInt(100));
        }
        System.out.println(avlTree.toString());
        // 判断是否为平衡二叉树
        System.out.println(avlTree.isBalanceTree());
        avlTree.removeMinNode();
        System.out.println(avlTree.toString());
        avlTree.remove(9);
        System.out.println(avlTree.toString());

    }
}
屈家全
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
平衡树之 AVL 树
qq_42611255的博客
06-03 110
平衡树（Balanced Tree）是一种特殊的二叉搜索树，它通过自动调整节点的插入和删除操作，以保持树的平衡性。在平衡树中，任何节点的左右子树的高度差不超过一个预定义的常数（自平衡）。平衡树的概念是由和Evgenii Landis 两位计算机科学家提出来的，并提供了平衡树的实现–AVL 树， 该树的名称就是由两位作者的姓氏命名的，他们在1962年的论文中公开了这一数据结构。当然，平衡树不止有 AVL 树一种，像后面出现的 2-3 树， 2-3-4 树， 红黑树等都是平衡树的实现。
【数据结构】——平衡二叉树（AVL树）
qq_43412060的博客
02-19 163
上一篇文章我们讲述了二叉排序树，然而当我们遇到特殊情况，如a[10] ={3,2,1,4,5,6,7,10,9,8}的情况时完全符合二叉树的定义，但是对这样高度达到8的二叉树老说是非常不利的，所以我们对此引入了一个新的概念——平衡二叉树~ 一、什么是平衡二叉树 是一种高度平衡的二叉排序树，其中每一个结点的左子树和右子树的高度差至多等于1 。将二叉树上结点的左子树深度减去右子树深度的值称为平衡因子B...
数据结构 —— 图解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树（平衡二叉树）
m0_61433144的博客
08-11 940
规定在插入和删除二叉搜索树的结点时，要保证任意结点的左右子树高度差的绝对值不超过1，我们将这样特殊的二叉搜索树称为AVL树（平衡二叉树）。每一个结点中有记录其左右子树高度差的平衡因子，也即平衡因子的值只可能是-1,0,1。（1如果某结点的左子树高度比右子树高度高一则平衡因子为-1，如果某结点的左子树高度比右子树高度低一则平衡因子为1，如果某结点的左子树高度与右子树高度一样则平衡因子为0）。............
详解AVL树（平衡二叉树）
水澹澹兮生烟
09-20 2万+
插入节点后对树进行旋转调整，分为四种情况。 1.右单旋 当一个平衡二叉树满足具有较高左子树时（如下图A），且要插入的节点插入到了较高左子树的左侧，此时进行右单旋。
AVL树
圣融的博客
01-03 173
AVL树 AVL树就是平衡二叉树，平衡二叉树的每个节点左右子树的高度差不超过1.AVL树每个节点都有高度，节点的高度为左右子树的最高高度加1，节点在新增或删除时递归维护每个节点的高度，每次旋转也都需要维护节点的高度。AVL树是否需要旋转以及旋转方式都跟平衡因子相关，平衡因子为节点左子树的高度减去右子树的高度。 平衡二叉树的查询复杂度为O(Log2n)，当往平衡二叉树添加或删除节点时有可能会破坏平衡...
计算机基础-数据结构与算法.pdf
10-07
数据结构与算法是计算机科学的基础，对于理解和优化程序性能至关重要。在这个领域，我们涉及的知识点广泛，主要包括数据结构如栈、队列、二叉树，以及解决哈希冲突的方法和各种排序算法。 栈是一种特殊线性表，遵循...
二叉树--城市数据库.rar_数据结构 二叉树
09-24
在IT领域，数据结构是计算机科学的基础，它们用于有效地存储和检索信息。在这个特定的案例中，我们关注的是“二叉树”这一重要的数据结构，它在实现城市数据库时发挥着关键作用。二叉树是一种特殊的树形数据结构，每...
软件技术基础-树结构(与“二叉树”有关文档共77张).pptx
11-14
树结构是软件技术基础中的一种重要的数据结构，它广泛应用于计算机科学和信息技术领域。树结构是一种非线性数据结构， 由节点和边组成，每个节点可以有多个子节点，节点之间通过边连接。树结构有很多种，包括二叉树...
数据结构从入门到精通-二叉树的实现和遍历
03-18
二叉树是数据结构中的重要概念，它是每个节点最多有两个子节点的树形结构，通常分为左子节点和右子节点。在计算机科学中，二叉树被广泛应用于搜索、排序、表达式求值等场景。本教程将带你从基础到深入地了解二叉树的...
2015广工数据结构实验--平衡二叉树(包含源码和实验报告
01-07
在IT领域，数据结构是计算机科学的基础之一，它关乎如何高效地存储和处理数据。平衡二叉树（Balanced Binary Tree）是数据结构中的一个重要概念，尤其在算法设计和数据库系统中发挥着关键作用。本实验是针对广东工业...
【原创】/Restarting/ 二叉平衡树 & AVL树 （附普通平衡树 ）
致上
03-20 382
AVL 说在前面 好久没写博客了…… まさか，必须克服掉“必须先写知识点Blog才能写对应知识点Blog”的猫病吗。 我写知识点Blog实在是太慢了…… 二叉查找树 定义 首先， 二叉查找树（Binary Search Tree）是一颗树。 首先， 二叉查找树是一颗二叉树。 首先，BST是满足： 任意一个结点的所有的左儿子的权值都小于它，所有右儿子的权值都大于它。 的这样的一棵树。 还有对其进...
【学校OJ】avl平衡树 普通平衡树
Starlight的博客
03-28 875
题目描述 你需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 1. 插入一个整数x 2. 删除一个整数x(若有多个相同的数，只删除一个) 3. 查询整数x的排名(若有多个相同的数，输出最小的排名)，相同的数依次排名，不并列排名 4. 查询排名为x的数，排名的概念同3 5. 求x的前驱(前驱定义为小于x，且最大的数)，保证x有前驱 6. 求x的后继(后
常见排序算法总结
mydaily_的博客
07-16 766
大概是因为插入排序没预处理，极端情况可能让一个很小很右的数一直比比比比比，比到最开头，浪费比较次数。某种情况比计数排序好，因为数字，如果按照普通十进制理解，则只需准备10个不同数字的桶就好了！整体的quickSort函数swap后，再进行partition，划分三部分后，所以这种不基于比较的算法应用范围很局限，大部分情况下，不如之前的所有比较算法！前提得知道空间范围，比如人的年龄，正数[0-200]，否则内存爆炸！间隔分组，且分组间隔依次减半，每次分组后，每个组内排序都是插入排序。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1879
栈超超超详解
数据结构——栈
weixin_45942515的博客
07-19 158
1、栈的英文为stack2、栈是先入后出（FILO-First In Last Out）的有序列表。3、栈stack是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶 (Top)，另一端固定的一端，称为栈底(Bottom)。4、根据栈的定义可知，最先放入栈中的元素在栈底，最后放入栈中的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
数据结构(5.1)——树的性质
m0_65240792的博客
07-16 230
1%29%5D。
《数据结构》预备
最新发布
U2396573637的博客
07-19 449
位段的声明和结构体是类似的，有两个不同：1.位段的成员必须是int、unsigned int、 signed int，在C99中位段成员也可以选择其它类型。2.位段的成员后边有一个冒号和一个数字。int _b:5;int _c:10;int _d:30;A就是一个位段类型。那位段A所占内存的大小是多少呢？
掌握计算机软件技术：算法与数据结构详解-树与二叉树篇
本资源是关于计算机软件技术基础的一份讲义，重点探讨了算法和数据结构中的树和二叉树。树是一种非线性数据结构，它由一个根节点和若干子树构成，这些子树可以是树也可以为空。树的结构通过层次关系来表示，如深度、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值