红黑树具体实现

已于 2023-03-24 15:45:30 修改
阅读量58 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 数据结构
于 2023-03-21 19:34:07 首次发布
原文链接：https://blog.csdn.net/weixin_52622200/article/details/118523301
版权

红黑树

红黑树

可以在 O(logn) 时间内做查找，插入和删除操作。
红黑树的性质：

  • 每个结点要么是红的，要么是黑的；
  • 根结点是黑色的；
  • 如果一个结点是红色的，则它的两个孩子都是黑色的；
  • 对于任意一个结点，其到叶子结点的每条路径上都包含相同数目的黑色结点

具体实现与代码

和 AVL 树通过约束左右子树高度不同，红黑树是通过它的四条性质来实现 “平衡状态”，在插入结点或者删除结点时，可能会造成某个结点违反了上述的某条性质，那么红黑树的做法就是通过 “重新着色” 和 “旋转” 两种方式使之重新符合性质。

左旋

在这里插入图片描述

void RBTree::ratate_left(Node * x)
{
    Node * y = x->right;
	//1
    x->right = y->left;
    if (y->left)
        y->left->parent = x;
	//2
    y->parent = x->parent;
    if (x == root())
        root() = y;
    else if (x == x->parent->left)
        x->parent->left = y;
    else
        x->parent->right = y;
	
	//3
    y->left = x;
    x->parent = y;
}

右旋
在这里插入图片描述

void RBTree::rotate_right(Node * x)
{
    Node * y = x->left;
	//1
    x->left = y->right;
    if (y->right)
        y->right->parent = x;
    
    //2
    y->parent = x->parent;
    if (x == root())
        root() = y;
    else if (x == x->parent->right)
        x->parent->right = y;
    else
        x->parent->left = y;
	//3
    y->right = x;
    x->parent = y;
}

插入操作

首先，我们把新插入的结点着色为红色。将插入的结点着色为红色，不会违背 “性质 4”。而少违背一条性质，就意味着我们需要处理的情况越少。

我们来看看插入结点会遇到哪几种情况，分析发现，一共有三种：

  • 被插入结点是根结点，那我们把此结点涂为黑色就行了；
  • 被插入结点的父亲结点是黑色的，那么什么也不需要做，结点被插入后，仍然是红黑树。
  • 被插入结点的父亲结点是红色的，那么此时是违背 “性质 3” 的。

“被插入结点的父亲结点是红色的” 这种情况下，被插入结点是一定存在非空祖父（即父亲的父亲）结点的。那么此时这种情况可以进一步再划分为 6 种情况，因为涉及到镜像操作，父节点是祖父节点的左子树的情况时：我们只需理解其中的 3 种情况即可，为方便叙述，我们把 “被插入结点” 称为 “当前结点”，

  • Case 1 ：当前结点的父亲为红色，叔叔存在且也是红色

在这里插入图片描述
图中，“结点 1” 为 “当前结点”。那么我们的处理策略就是：

将 “父亲结点” 改为黑色；
将 “叔叔结点” 改为黑色；
将 “祖父结点” 改为红色；
将 “祖父结点” 设为 “当前结点”，继续进行操作。

  • Case 2：当前结点的父亲为红色，叔叔不存在或为黑色，且当前结点是其父亲的右孩子
    在这里插入图片描述
    图中，“结点 2” 为 “当前结点”。那么我们的处理策略就是：

将 “父亲结点” 设为 “当前结点”；
以 “新的当前结点” 为支点进行左旋。
转为case3

  • Case 3：当前结点的父亲为红色，叔叔不存在或为黑色，且当前结点是其父亲的左孩子

在这里插入图片描述
图中，“结点 1” 为 “当前结点”。那么我们的处理策略就是：

  • 将 “父亲结点” 改为黑色；
  • 将 “祖父结点” 改为红色；
  • 以 “祖父结点” 为支点进行右旋。

删除操作

为方便叙述，我们把 “被删结点” 称为 “原先结点”，用来替换 “被删结点” 的结点称为 “当前结点”。

  1. 没有左右子树的情况
    在这里插入图片描述

  2. 有左子树或者右子树

在这里插入图片描述
3. 有左子树且有右子树

在这里插入图片描述

我们来看看删除一个结点会遇到哪几种情况，分析发现，一共有四种：

  • “原先结点” 为黑色，“当前结点” 为红色，那么我们把 “原先结点” 删掉后，拿 “当前结点” 去替换它并修改颜色为黑色即可；.
  • “原先结点” 为黑色，“当前结点” 为黑色，这种情况比较复杂，待会再说；
  • “原先结点” 为红色，“当前结点” 为红色，那么我们把 “原先结点” 删掉后，直接拿 “当前结点” 去替换它即可；
  • “原先结点” 为红色，“当前结点” 为黑色，那么我们把 “原先结点” 删掉后，再拿 “当前结点” 去替换它。我们发现，此时 “原先结点” 位置是满足红黑树性质的，但是由于 “当前结点” 被拿走，“当前结点” 位置可能就会违背红黑树性质。分析发现，此时的 “当前结点” 不就是上面 “情况 1” 和 “情况 2” 中所讲的 “原先结点”！那么当前的这种情况直接就变成了 “情况 1” 或 “情况 2”。

最后，我们看下上述的 “情况 2”。这种情况可以进一步再划分为 8 种情况，因为涉及到镜像操作，所以我们只需理解其中一边镜像的 4 种情况即可（注意，下面的图片上，“原先结点” 已被删除，故未画出，我们只画出了 “当前结点”）：

  • Case 1：当前结点是黑色，兄弟结点是红色

在这里插入图片描述

图中，“结点 1” 为 “当前结点”。观察上图，因 “原先结点” 已被删除，故原来每条路径上应该是 3 个黑色结点（右侧路径未画完全），此时左侧少了一个，那么我们的处理策略就是：

  • 将 “兄弟结点” 改为黑色；
  • 将 “父亲结点” 改为红色；
  • 以 “父亲结点” 为支点进行左旋；
  • 左旋后，重新设置 “兄弟结点”。

我们发现最左侧路径依旧是 2 个黑色结点，说明当前状态并不满足红黑树性质。其实，这是进入了下面的 Case 2，Case 3，和 Case 4 阶段了，请继续往下看。

Case 2：当前结点是黑色，兄弟结点是黑色，两个孩子为空或是黑色

在这里插入图片描述

图中，“结点 1” 为 “当前结点”。观察上图，因 “原先结点” 已被删除，故原来每条路径上应该是 2 个黑色结点，此时左侧少了一个，那么我们的处理策略就是：

  • 将 “兄弟结点” 改为红色；
  • 将 “父亲结点” 设置为新的 “当前结点”，继续进行操作。

但是我们发现只要把 “结点 2” 着色为黑色不就行了么，这也就是erase_rebalance代码最后出现if(x) x->color = black;的缘由之一（x指向的是 “当前结点”）。

Case 3：当前结点是黑色，兄弟结点是黑色，兄弟结点的左孩子是红色，右孩子是为空或是黑色

在这里插入图片描述

图中，“结点 1” 为 “当前结点”。观察上图，因 “原先结点” 已被删除，故原来每条路径上应该是 2 个黑色结点，此时左侧少了一个，那么我们的处理策略就是：

  • 将 “兄弟结点” 的左孩子改为黑色；
  • 将 “兄弟结点” 改为红色；
  • 以 “兄弟结点” 为支点进行右旋；
  • 右旋后，重新设置 “当前结点” 的 “兄弟结点”。
    处理完后，我们发现图中最左路径只有 1 个黑色结点，说明当前状态不满足红黑树性质。其实这是进入了 Case 4。

Case 4：当前结点是黑色，兄弟结点是黑色，兄弟结点的右孩子是红色，左孩子为空或红黑皆可
在这里插入图片描述

图中，“结点 1” 为 “当前结点”。观察上图，因 “原先结点” 已被删除，故原来每条路径上应该是 2 个黑色结点，此时左侧少了一个，那么我们的处理策略就是：

  • 将 “父亲结点” 的颜色赋给 “兄弟结点”；
  • 将 “父亲结点” 改为黑色；
  • 将 “兄弟结点” 的右孩子改为黑色；
  • 以 “父亲结点” 为支点进行左旋；

总体代码

/**
*
* author 刘毅（Limer）
* date   2017-08-20
* mode   C++
*/
#include <iostream>
#include <algorithm>
using namespace std;

enum { red = 0, black = 1 };

struct Node
{
    int key;
    bool color;
    Node * parent;
    Node * left;
    Node * right;
    Node(int key = 0)
    {
        this->key = key;
        this->color = red;
        this->parent = this->left = this->right = nullptr;
    }
};

class RBTree
{
private:
    Node * header;
private:
    void ratate_left(Node * x);
    void rotate_right(Node * x);
    void destroy(Node * node);
    Node *& root();
    void insert_rebalance(Node * x);
    void erase_rebalance(Node * z);
    void in_order(Node * node);
public:
    RBTree();
    ~RBTree();
    Node * insert(int key);
    Node * find(int key);
    void erase(int key);
    void print();
};

void RBTree::ratate_left(Node * x)
{
    Node * y = x->right;

    x->right = y->left;
    if (y->left)
        y->left->parent = x;
    y->parent = x->parent;

    if (x == root())
        root() = y;
    else if (x == x->parent->left)
        x->parent->left = y;
    else
        x->parent->right = y;

    y->left = x;
    x->parent = y;
}

void RBTree::rotate_right(Node * x)
{
    Node * y = x->left;

    x->left = y->right;
    if (y->right)
        y->right->parent = x;
    y->parent = x->parent;

    if (x == root())
        root() = y;
    else if (x == x->parent->right)
        x->parent->right = y;
    else
        x->parent->left = y;

    y->right = x;
    x->parent = y;
}

void RBTree::destroy(Node * node)
{
    if (node == nullptr)
        return;
    destroy(node->left);
    destroy(node->right);
    delete node;
}

Node *& RBTree::root()
{
    return header->left;
}

void RBTree::insert_rebalance(Node * x)
{
    x->color = red;

    while (x != root() && x->parent->color == red)
    {
        if (x->parent == x->parent->parent->left)
        {
            Node * y = x->parent->parent->right;

            if (y && y->color == red)           // Case 1
            {
                x->parent->color = black;
                y->color = black;
                x->parent->parent->color = red;
                x = x->parent->parent;
            }
            else
            {
                if (x == x->parent->right)      // Case 2
                {
                    x = x->parent;
                    ratate_left(x);
                }

                x->parent->color = black;       // Case 3
                x->parent->parent->color = red;
                rotate_right(x->parent->parent);
            }
        }
        else  // same as above, just left <-> right
        {
            Node * y = x->parent->parent->left;

            if (y && y->color == red)
            {
                x->parent->color = black;
                y->color = black;
                x->parent->parent->color = red;
                x = x->parent->parent;
            }
            else
            {
                if (x == x->parent->left)
                {
                    x = x->parent;
                    rotate_right(x);
                }

                x->parent->color = black;
                x->parent->parent->color = red;
                ratate_left(x->parent->parent);
            }
        }
    }

    root()->color = black;  // Do not forget!
}

void RBTree::erase_rebalance(Node * z)
{
    Node * y = z;
    Node * x = nullptr;
    Node * x_parent = nullptr;

    if (y->left == nullptr)
        x = y->right;
    else if (y->right == nullptr)
        x = y->left;
    else
    {
        y = y->right;
        while (y->left)
            y = y->left;
        x = y->right;
    }  

    if (y != z)  // if y is z's successor
    {
        z->left->parent = y;
        y->left = z->left;
        if (y != z->right)
        {
            x_parent = y->parent;
            if (x)
                x->parent = y->parent;
            y->parent->left = x;
            y->right = z->right;
            z->right->parent = y;
        }
        else
            x_parent = y;

        if (root() == z)
            root() = y;
        else if (z->parent->left == z)
            z->parent->left = y;
        else
            z->parent->right = y;
        y->parent = z->parent;
        swap(y->color, z->color);
        y = z;
    }
    else
    {
        x_parent = y->parent;
        if (x)
            x->parent = y->parent;
        if (root() == z)
            root() = x;
        else if (z->parent->left == z)
            z->parent->left = x;
        else
            z->parent->right = x;
    }
    // now, y is pointing to what you will erase!
    //      x is the child of y, and note that x might be nullptr.



    // Now, the actual reblance is coming!
    // .....
    if (y->color == black)
    {
        while (x != root() && (x == nullptr || x->color == black))
        {
            if (x == x_parent->left)
            {
                Node * w = x_parent->right;
                if (w->color == red)                                      // Case 1
                {
                    w->color = black;
                    x_parent->color = red;
                    ratate_left(x_parent);
                    w = x_parent->right;
                }

                if ((w->left == nullptr || w->left->color == black) &&    // Case 2
                    (w->right == nullptr || w->right->color == black))
                {
                    w->color = red;
                    x = x_parent;
                    x_parent = x_parent->parent;
                }
                else
                {
                    if (w->right == nullptr || w->right->color == black)  //Case 3
                    {
                        if (w->left)
                            w->left->color = black;
                        w->color = red;
                        rotate_right(w);
                        w = x_parent->right;
                    }

                    w->color = x_parent->color;                           // Case 4
                    x_parent->color = black;
                    if (w->right)
                        w->right->color = black;
                    ratate_left(x_parent);
                    break;
                }
            }
            else  // same as above, just left <-> right
            {
                Node * w = x_parent->left;
                if (w->color == red)
                {
                    w->color = black;
                    x_parent->color = red;
                    rotate_right(x_parent);
                    w = x_parent->left;
                }

                if ((w->right == nullptr || w->right->color == black) &&
                    (w->left == nullptr || w->left->color == black))
                {
                    w->color = red;
                    x = x_parent;
                    x_parent = x_parent->parent;
                }
                else
                {
                    if (w->left == nullptr || w->left->color == black)
                    {
                        if (w->right)
                            w->right->color = black;
                        w->color = red;
                        ratate_left(w);
                        w = x_parent->left;
                    }

                    w->color = x_parent->color;
                    x_parent->color = black;
                    if (w->left)
                        w->left->color = black;
                    rotate_right(x_parent);
                    break;
                }
            }
        }

        if (x)
            x->color = black;
    }
}

void RBTree::in_order(Node * node)
{
    if (node == nullptr)
        return;

    in_order(node->left);
    cout << "( " << node->key << ", " << node->color << " )" << endl;
    in_order(node->right);
}

RBTree::RBTree()
{
    header = new Node(0);
}

RBTree::~RBTree()
{
    destroy(root());
    delete header;
    header = nullptr;
}

Node * RBTree::insert(int key)
{
    Node * cur = root();
    Node * pre = header;
    while (cur)
    {
        pre = cur;
        if (key < cur->key)
            cur = cur->left;
        else if (key > cur->key)
            cur = cur->right;
        else
            return nullptr;
    }

    cur = new Node(key);
    cur->parent = pre;
    if (pre == header || key < pre->key)
        pre->left = cur;
    else
        pre->right = cur;

    insert_rebalance(cur);
    return cur;
}

Node * RBTree::find(int key)
{
    Node * z = root();
    while (z)
    {
        if (key < z->key)
            z = z->left;
        else if (key > z->key)
            z = z->right;
        else
            return z;
    }
    return z;
}

void RBTree::erase(int key)
{
    Node * z = find(key);
    if (z)
    {
        erase_rebalance(z);
        delete z;
    }
}

void RBTree::print()
{
    in_order(root());
    cout << endl;
}

int main()
{
    RBTree rb_tree;

    // test "insert"
    rb_tree.insert(7);
    rb_tree.insert(2);
    rb_tree.insert(1); rb_tree.insert(1);
    rb_tree.insert(5);
    rb_tree.insert(3);
    rb_tree.insert(6);
    rb_tree.insert(4);
    rb_tree.insert(9);
    rb_tree.insert(8);
    rb_tree.insert(11); rb_tree.insert(11);
    rb_tree.insert(10);
    rb_tree.insert(12);
    rb_tree.print();

    // test "find"
    Node * p = nullptr;
    cout << ((p = rb_tree.find(2)) ? p->key : -1) << endl;
    cout << ((p = rb_tree.find(100)) ? p->key : -1) << endl << endl;

    // test "erase"
    rb_tree.erase(1);
    rb_tree.print();
    rb_tree.erase(9);
    rb_tree.print();
    rb_tree.erase(11);
    rb_tree.print();

    return 0;
}

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

qq_35303122
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript实现红黑树
DameLillardd的博客
04-15 661
红黑树五大性质 ①结点是红色或者黑色，结点上只有一个color属性 ②根节点是黑色 ③叶子结点都是黑色，且为null ④连接红色结点的两个子结点都是黑色，红色结点的父结点都是黑色，红色子结点都是黑色 ⑤从任意结点出发，到其每个叶子结点的路径中包含相同数据的黑色结点 五条性质是为了保证：从根结点到叶子结点的最长路径不大于最短路径的两倍 由于性质4，红黑树中不会出现两个红色结点相邻的情形。树中最短的可能出现的路径是都是黑色结点的路径，树中最长的可能出现的路径是红色结点和黑色结点交替的路径。再结合性质5，每条路径
红黑树的具体实现，注释详解
06-19
红黑树的实现
对红黑树的认识总结
热门推荐
张彦峰的博客
05-12 170万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
手把手教你实现红黑树
weixin_61857742的博客
11-12 1966
手把手教你实现AVL树、平衡二叉树红黑树是在1972年由发明的。其特点是从根到叶子节点的所有路径中，最长路径不大于最短路径的2倍。可以说红黑树是AVL树的plus版，因此，红黑树查找时间与AVL树相同，都为O(log N)。同时，红黑树没有做到AVL树那种绝对平衡，因此其旋转次数少于AVL树。当数据量大时，其效率要优于AVL树。正因如此，在实际应用中往往采取红黑树而非AVL树。
红黑树的实现（图文详解）
AllenSquirrel
05-24 3906
红黑树的实现 红黑树的定义 红黑树的结构
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
小七的博客
01-18 19万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
C++红黑树
~
03-26 6480
C++红黑树零、前言一、红黑树的概念及性质二、红黑树结点的定义三、红黑树的插入操作1、变色处理2、单旋+变色3、双旋+变色4、插入实现四、红黑树的验证五、红黑树的删除六、红黑树与**AVL**树的比较 零、前言 本章继AVL树后继续讲解学习C++中另一个二叉搜索树–红黑树 一、红黑树的概念及性质 概念： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长
红黑树（C++实现）
2021dragon的博客
12-06 1万+
红黑树（C++实现）
【C++进阶06】红黑树图文详解及C++模拟实现红黑树
2302_76421042的博客
01-12 3444
红黑树详解、模拟实现
红黑树实现代码+详细注释
ltrbless的博客
05-19 1555
简介 因为网上太多红黑树原理的讲解了，不需要再去讲解原理，所以在这就提供一些将原理不错的博客，然后主要是给红黑树代码的实现，用的c++语言模板实现红黑树，并附带详细注释。（目前只实现了红黑树的插入与查询操作，并可视化打印红黑树）。 红黑树插入操作的流程图：（参考：红黑树总结 - lukazan - 博客园 (cnblogs.com)，该博客用图详细解释了红黑树插入操作的事件，然后我用红色对其事件进行了编号，以便于和代码注释相对应） 红黑树的本质其实就是2-3树，在上面推荐的博客中也有提到。 代码
红黑树是怎么实现的，看这篇真的就够了！
Jaemon
06-22 1221
红黑树是怎么实现的，看这篇真的就够了！
红黑树实现源码
07-22
在提供的“红黑树.txt”文件中，可能包含了红黑树的具体源代码实现，可以详细阅读理解其工作原理。 总结来说，红黑树是一种高效且实用的数据结构，它的核心在于通过颜色属性和相应的调整策略来保持树的平衡，从而在...
红黑树代码实现及分析2
02-25
在"红黑树代码实现及分析"这个主题中，你可以找到关于红黑树的具体实现细节，包括如何初始化树、插入和删除节点的步骤，以及如何进行颜色翻转和旋转等操作。通过分析这些代码，你可以更好地理解红黑树的工作原理，并...
C语言实现红黑树的实例代码
12-25
因为看内核的时候感觉红黑树挺有意思的，所以利用周末的时间来实现一下玩玩。红黑树的操作主要是插入和删除，而删除的时候需要考虑的情况更多一些。具体的操作就不在这里罗嗦了，百度文库里面有一个比较有好的文章，...
红黑树的Java实现参考源码
02-18
在提供的链接博客中，博主详细讲解了红黑树的插入、删除和查找过程，并给出了具体的Java代码实现。这是一份很好的学习资料，通过阅读源码，你可以深入理解红黑树的内部机制。 在压缩包文件`src`中，可能包含了实现...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 891
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 203
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 189
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
算法-KMP字符串匹配
xx_xb的博客
07-23 276
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
java 实现红黑树
03-01
红黑树是一种自平衡的二叉搜索树，它在插入和删除节点时通过一系列的...这是一个简单的红黑树的实现步骤，具体的代码实现可以根据需要进行调整和优化。如果你对红黑树的实现有更具体的问题，请告诉我，我会尽力回答。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值