树与二叉树的转换丨代码详解

已于 2024-05-18 10:55:56 修改
阅读量511 收藏 8
点赞数 5
分类专栏： 数据结构 文章标签： 数据结构
于 2024-04-27 11:42:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74315738/article/details/138244642
版权

前言：本文代码及解析以【双亲表示法的树】与【孩子兄弟表示法的二叉树】之间的转换为例。

  • 双亲表示法——树的每个结点储存结点的值以及它指向的父节点；
  • 孩子兄弟表示法——二叉树结点存储本身的值以及两个子节点，其中左孩子是该结点的首个孩子，右孩子是兄弟。如下图中，2的左孩子是5，右兄弟是3。
接下来将以这张图为例来完成代码的实现。
接下来我们将以这张图中的树和二叉树转换为例来完成代码的实现。

一、树与二叉树结构的定义

①树的定义

typedef struct TreeNode
{
    int data;
    struct TreeNode* parent;
} TreeNode;
typedef struct Tree
{
    TreeNode tns[MAX_SIZE];
    int r, n;
} Tree;

②二叉树的定义

typedef struct BiTreeNode
{
    int data;
    struct BiTreeNode* leftChild;
    struct BiTreeNode* rightBrother;
} BiTreeNode;
typedef struct BiTree
{
    BiTreeNode btns[MAX_SIZE];
    int r, n;
} BiTree;

二者的定义类似，其中MAX_SIZE限制了结点的最大数量，r代表根的位置，n代表结点的实际数量

二、程序的整体框架

 主函数：

int main()
{
    //1、传入parent数组
    int parent[10] = { -1, 0, 0, 0, 1, 1, 3, 6, 6, 6 };

    //2、创建树并打印
    Tree tree = createTree(parent);
    printf("\n树：\n");
    printTree(tree);

    //3、将树转换为二叉树并打印
    BiTree tree1 = treeToBiTree(tree);
    printf("\n转换为二叉树：\n");
    printBiTree(tree1);

    //4、将二叉树转换回树并打印
    Tree tree2 = biTreeToTree(tree1);
    printf("\n转换回树：\n");
    printTree(tree2);

    return 0;
}

自定义函数及功能：

Tree createTree(int parent[]);//用parent数组创建树
void printTree(Tree tree);//打印树
void findChild(BiTreeNode* root, Tree tree);//树转二叉树的辅助函数
BiTree treeToBiTree(Tree tree);//将树转换为二叉树
void printBiTree(BiTree bitree);//打印二叉树
void addChild(TreeNode* parent, BiTreeNode* child, Tree* tree);//二叉树转树的辅助函数
Tree biTreeToTree(BiTree bitree);//将二叉树转换为树

三、parent数组创建树

Tree createTree(int parent[])
{
    tree.r = 0;
    tree.n = 0;
    while (tree.n < 10)
    {
        tree.tns[tree.n].data = tree.n + 1;
        tree.tns[tree.n].parent = NULL;

        if (parent[tree.n] != -1)
        {
            tree.tns[tree.n].parent = &tree.tns[parent[tree.n]];
        }
        tree.n++;
    }
    return tree;
}

 parent[i]即第i个结点对应的双亲结点的位置

三、树转换为二叉树

BiTree treeToBiTree(Tree tree)
{
    bitree.r = 0;
    bitree.n = tree.n;
    for (int i = 0; i < bitree.n; i++)
    {
        bitree.btns[i].data = tree.tns[i].data;
        bitree.btns[i].leftChild = NULL;
        bitree.btns[i].rightBrother = NULL;
    }
    BiTreeNode* root = &bitree.btns[0];
    findChild(root, tree);
    return bitree;
}

 将树转换为二叉树的函数：将树的节点数据复制到二叉树的节点中，并将左子节点和右兄弟节点初始化为NULL。接着找到根节点并调用findChild函数来构建二叉树的结构。最后返回转换后的二叉树bitree。

void findChild(BiTreeNode* root, Tree tree)
{
    BiTreeNode* currentChild = NULL;
    for (int i = 0; i < tree.n; i++)
    {
        if (tree.tns[i].parent && tree.tns[i].parent->data == root->data)
        {
            BiTreeNode* newChild = &bitree.btns[i];
            if (currentChild == NULL)
            {
                root->leftChild = newChild;
            }
            else
            {
                currentChild->rightBrother = newChild;
            }
            currentChild = newChild;
            findChild(currentChild, tree);
        }
    }
}

如果一个结点的parent结点的值等于root结点的值，就将该结点currentChild作为root的左孩子；

i增加再进入循环时，root已经有左孩子，于是将第二个孩子接在左孩子的右兄弟上，将第二个孩子作为currentChild，以此类推；

同时利用递归找到所有结点的孩子。

四、二叉树转换回树

Tree biTreeToTree(BiTree bitree)
{
    tree2.r = 0;
    tree2.n = 0;
    addChild(NULL, &bitree.btns[0], &tree2);
    return tree;
}

首先对第二棵树进行初始化；

然后通过递归函数addChild实现每个结点与其双亲结点的连接。 

void addChild(TreeNode* parent, BiTreeNode* child, Tree* tree2)
{
    tree2->tns[tree2->n].data = child->data;
    tree2->tns[tree2->n].parent = parent;
    tree2->n++;

    if (child->leftChild != NULL)
    {
        addChild(&tree2->tns[tree2->n - 1], child->leftChild, tree2);
    }

    if (child->rightBrother != NULL)
    {
        addChild(parent, child->rightBrother, tree2);
    }
}

以左图的二叉树为例，首先将1的双亲赋值为NULL，1有左孩子，则进入递归；
第二次进入函数后，将2的双亲赋为1，2有左孩子5，则道理同上；
同时2有右孩子3，此时注意是把3的双亲赋为1，也就是2的双亲。

五、树与二叉树的打印

5.1、信息的打印

打印树格式：

XX ->parent XX

void printTree(Tree tree)
{
    for (int i = 0; i < tree.n; i++)
    {
        if (tree.tns[i].parent != NULL)
        {
            printf("%d ->parent-> %d\n", tree.tns[i].data, tree.tns[i].parent->data);
        }
        else
        {
            printf("%d ->parent-> NULL\n", tree.tns[i].data);
        }
    }
}

打印二叉树格式：

XX：leftChild ->XX rightBrother ->XX

void printBiTree(BiTree bitree)
{
    for (int i = 0; i < bitree.n; i++)
    {
        printf("%2d:  ", bitree.btns[i].data);
        if (bitree.btns[i].leftChild != NULL)
        {
            printf("leftChild->%4d ", bitree.btns[i].leftChild->data);
        }
        else
        {
            printf("leftChild->NULL ");
        }
        if (bitree.btns[i].rightBrother != NULL)
        {
            printf("rightBrother->%4d ", bitree.btns[i].rightBrother->data);
        }
        else
        {
            printf("rightBrother->NULL ");
        }
        printf("\n");
    }
}

5.2、二叉树的遍历方法

递归/非递归（堆栈）/层次（队列）遍历方法合集丨代码详解icon-default.png?t=N7T8https://blog.csdn.net/qq_74315738/article/details/139021345

六、总结

综上，完整代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 20

//定义树结构
typedef struct TreeNode
{
    int data;
    struct TreeNode* parent;
} TreeNode;
typedef struct Tree
{
    TreeNode tns[MAX_SIZE];
    int r, n;
} Tree;
Tree tree;
Tree tree2;

//定义二叉树结构
typedef struct BiTreeNode
{
    int data;
    struct BiTreeNode* leftChild;
    struct BiTreeNode* rightBrother;
} BiTreeNode;
typedef struct BiTree
{
    BiTreeNode btns[MAX_SIZE];
    int r, n;
} BiTree;
BiTree bitree;

Tree createTree(int parent[]);//用parent数组创建树
void printTree(Tree tree);//打印树
void findChild(BiTreeNode* root, Tree tree);//树转二叉树的辅助函数
BiTree treeToBiTree(Tree tree);//将树转换为二叉树
void printBiTree(BiTree bitree);//打印二叉树
void addChild(TreeNode* parent, BiTreeNode* child, Tree* tree);//二叉树转树的辅助函数
Tree biTreeToTree(BiTree bitree);//将二叉树转换为树

int main()
{
    //1、传入parent数组
    int parent[10] = { -1, 0, 0, 0, 1, 1, 3, 6, 6, 6 };

    //2、创建树并打印
    Tree tree = createTree(parent);
    printf("\n树：\n");
    printTree(tree);

    //3、将树转换为二叉树并打印
    BiTree tree1 = treeToBiTree(tree);
    printf("\n转换为二叉树：\n");
    printBiTree(tree1);

    //4、将二叉树转换回树并打印
    Tree tree2 = biTreeToTree(tree1);
    printf("\n转换回树：\n");
    printTree(tree2);

    return 0;
}

Tree createTree(int parent[])
{
    tree.r = 0;
    tree.n = 0;
    while (tree.n < 10)
    {
        tree.tns[tree.n].data = tree.n + 1;
        tree.tns[tree.n].parent = NULL;

        if (parent[tree.n] != -1)
        {
            tree.tns[tree.n].parent = &tree.tns[parent[tree.n]];
        }
        tree.n++;
    }
    return tree;
}

void printTree(Tree tree)
{
    for (int i = 0; i < tree.n; i++)
    {
        if (tree.tns[i].parent != NULL)
        {
            printf("%d ->parent-> %d\n", tree.tns[i].data, tree.tns[i].parent->data);
        }
        else
        {
            printf("%d ->parent-> NULL\n", tree.tns[i].data);
        }
    }
}

void findChild(BiTreeNode* root, Tree tree)
{
    BiTreeNode* currentChild = NULL;
    for (int i = 0; i < tree.n; i++)
    {
        if (tree.tns[i].parent && tree.tns[i].parent->data == root->data)
        {
            BiTreeNode* newChild = &bitree.btns[i];
            if (currentChild == NULL)
            {
                root->leftChild = newChild;
            }
            else
            {
                currentChild->rightBrother = newChild;
            }
            currentChild = newChild;
            findChild(currentChild, tree);
        }
    }
}

BiTree treeToBiTree(Tree tree)
{
    bitree.r = 0;
    bitree.n = tree.n;
    for (int i = 0; i < bitree.n; i++)
    {
        bitree.btns[i].data = tree.tns[i].data;
        bitree.btns[i].leftChild = NULL;
        bitree.btns[i].rightBrother = NULL;
    }
    BiTreeNode* root = &bitree.btns[0];
    findChild(root, tree);
    return bitree;
}

void printBiTree(BiTree bitree)
{
    for (int i = 0; i < bitree.n; i++)
    {
        printf("%2d:  ", bitree.btns[i].data);
        if (bitree.btns[i].leftChild != NULL)
        {
            printf("leftChild->%4d ", bitree.btns[i].leftChild->data);
        }
        else
        {
            printf("leftChild->NULL ");
        }
        if (bitree.btns[i].rightBrother != NULL)
        {
            printf("rightBrother->%4d ", bitree.btns[i].rightBrother->data);
        }
        else
        {
            printf("rightBrother->NULL ");
        }
        printf("\n");
    }
}

void addChild(TreeNode* parent, BiTreeNode* child, Tree* tree2)
{
    tree2->tns[tree2->n].data = child->data;
    tree2->tns[tree2->n].parent = parent;
    tree2->n++;

    if (child->leftChild != NULL)
    {
        addChild(&tree2->tns[tree2->n - 1], child->leftChild, tree2);
    }

    if (child->rightBrother != NULL)
    {
        addChild(parent, child->rightBrother, tree2);
    }
}

Tree biTreeToTree(BiTree bitree)
{
    tree2.r = 0;
    tree2.n = 0;
    addChild(NULL, &bitree.btns[0], &tree2);
    return tree;
}

运行结果：

树：
1 ->parent-> NULL
2 ->parent-> 1
3 ->parent-> 1
4 ->parent-> 1
5 ->parent-> 2
6 ->parent-> 2
7 ->parent-> 4
8 ->parent-> 7
9 ->parent-> 7
10 ->parent-> 7

转换为二叉树：
 1:  leftChild->   2 rightBrother->NULL
 2:  leftChild->   5 rightBrother->   3
 3:  leftChild->NULL rightBrother->   4
 4:  leftChild->   7 rightBrother->NULL
 5:  leftChild->NULL rightBrother->   6
 6:  leftChild->NULL rightBrother->NULL
 7:  leftChild->   8 rightBrother->NULL
 8:  leftChild->NULL rightBrother->   9
 9:  leftChild->NULL rightBrother->  10
10:  leftChild->NULL rightBrother->NULL

转换回树：
1 ->parent-> NULL
2 ->parent-> 1
3 ->parent-> 1
4 ->parent-> 1
5 ->parent-> 2
6 ->parent-> 2
7 ->parent-> 4
8 ->parent-> 7
9 ->parent-> 7
10 ->parent-> 7

D:\Cfiles\DSweek8\Debug\DSweek8.exe (进程 18280)已退出，代码为 0。
按任意键关闭此窗口. . .

熊猫_luoul
关注
  • 5
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树转换为二叉树
mqj010321的博客
05-03 1312
利用左孩子右兄弟的思想，将第一个孩子置为二叉树的左孩子，将节点的右兄弟置为右孩子。 #include<iostream> #include<string> #include<new> using namespace std; #define MAXSIZE 100 typedef struct TreeNode{//左孩子右兄弟类型的二叉树结构体 char data; struct TreeNode *child,*bro; }*CSTree,CSNode; v
5.7树、森林与二叉树的转换
weixin_44897707的博客
11-15 3734
树、森林与二叉树的转换 1.树转换成二叉树 树转换成二叉树的步骤如下： 加线。所有兄弟之间加一条连线。 去线。对树的每个结点，只保留它与第一个孩子的连线，删除它与其他孩子的连线 层次调整。以树的根节点为轴心，将整棵树顺时针旋转一定的角度，结点的左孩子是原来结点的第一个孩子，右孩子是结点原来的兄弟。 例：把下面的树转换成二叉树 2.森林转换为二叉树 森林是由若干棵树组成，可以理解为，森林中的每一棵树都是兄弟，可以按照兄弟的处理方法来操作。将森林转换成二叉树的步骤如下： 把每棵树转换成二叉树。 第一棵
icoding数据结构——树转二叉树（详细注释）
PLUS_WAVE的博客
04-30 537
使用队列，编写transfrom函数，将普通树转换成对应的二叉树。
树转二叉树(C语言实现, 递归)
Caliber_的博客
05-07 1528
本方法需要队列实现 设定 树的结点定义 将树节点定义为具有数据域和子结点域的结构体 typedef struct prototype_treeNode { Datatype data; struct prototype_treeNode* children[N]; } TreeNode, *Tree; 且子结点域中无子结点的位置用NULL空指针填充 二叉树结点的定义 二叉树使用二叉链表表示 typedef struct prototype_biNode { Datatype data; struc
数据结构练习题之树和图（附答案与解析）
小白不白
12-16 3960
（1）把一棵树转换为二叉树后，这棵二叉树的形态是（ ）。 A．唯一的Ｂ．有多种 C．有多种，但根结点都没有左孩子 Ｄ．有多种，但根结点都没有右孩子 答案：A 解释：因为二叉树有左孩子、右孩子之分，故一棵树转换为二叉树后，这棵二叉树的形态是唯一的。 （2）由3个结点可以构造出多少种不同的二叉树？（） A．2 B．3 C．4 D．5 ...
树与二叉树的转换
01-08
简单的实现了树与二叉树的转换功能！很实用
树与二叉树详细整理.ppt
01-11
"树与二叉树详细整理" 树是一种非线性数据结构，主要用于描述带有层次关系的数据集。树的形式化定义是：树是由一个或多个结点组成的有限集合，其中有一个特定的称为根的结点；其余结点可分为m(m≥0)个互不相交的...
树、二叉树和森林的转换
最新发布
01-22
树、二叉树和森林的转换
树与二叉树 源代码
05-03
树与二叉树源代码，实现了广义表（树的括号表示法）与森林的相互转换，森林与二叉树的相互转换，二叉树与遍历序列（先序/中序）的相互转换以及森林的先根遍历和后根遍历。
算法基础11 —— 树入门(二叉树的遍历以及构造 + 普通树转换成二叉树 + 例题 + 二叉树的一些操作)
smallrain6的博客
02-07 2839
字符二叉树的遍历 对于以上二叉树 先序遍历为(根左右) : ABCDEFG 中序遍历为(左根右) : CBEDAFG 后序遍历为(左右根) : CEDBGFA 层序遍历：(从左往右、从上往下) ABFCDGE 以先序次序输入以上二叉树： ABC##DE###F#G## 代码实现遍历操作： #include <iostream> #include <queue> using namespace std; typedef struct node { char data;
树与二叉树转换，森林与二叉树的转换，哈夫曼编码例题详解
呵呵哒!的博客
11-07 6335
二叉树的前序序列和后序序列正好相反，则该二叉树一定是（B） A.空或只有一个结点 B.高度等于其结点数 C.任一结点无左孩子 D.任一结点无右孩子 2.任何一棵二叉树的叶子结点在前序、中序、后序遍历序列中的相对次序（A） A.肯定不发生改变 B.肯定发生改变 C.不能确定 D.有时发生变化 答案解析 [解析] 如果用符号D表示访问根结点，用L表示遍历左子树，用 R表示遍历右子树，那么前序、中序、后序遍历可分别表示为：DLR、 LDR、LRD。由此可见，在三种遍历序列中L和R的相...
【数据结构】树（三） —— 树、森林与二叉树 的相互转换（C语言版）
haoweixl的博客
05-20 1万+
树，森林 与 二叉树的转换 树转换为二叉树 加线，所有兄弟结点之间连接一条线。 去线，对树中的每个结点，只保留它与第一个孩子结点的连线，删除与其他孩子结点之间的连线。 层次调整，以树的根结点为轴心，将整个树调节一下（第一个孩子是结点的左孩子，兄弟转过来的孩子是结点的右孩子） 注：树的孩子兄弟表示法 构成转换为 二叉树； 结点的左右孩子分别为第一个孩子和此结点的右兄弟。 （1）由于二叉树和树都可以用二叉链表作为存储结构，则以二叉链表作为媒介可导出树与二叉树之间的一个对应关系。 （2）一般树转换成二叉树后，
树、森林与二叉树的相互转换
薛定谔的猫的博客
07-26 2万+
文章目录树转换为二叉树 树转换为二叉树  二叉树和树都可以用二叉链表作为存储结构，因此二叉链表可以导出树与二叉树的一个对应关系，即给定一棵树，可以找到唯一的一棵二叉树与之对应。其中树的二叉链表存储详情可参照树的存储结构及详细完整代码。  树转换成二叉树的规则：  <1>每个结点的左指针指向它的第一个孩子结点；  <2>每个结点的右指针指向它在树中的相邻兄弟结点。  可表示为"左孩子右兄弟"。 ...
数据结构编程笔记十五：第六章 树和二叉树 树和二叉树的转换算法实现
u014576141的博客
08-24 8223
上次已经介绍了递归算法以及二叉树的基本操作，最重要的就是二叉树的遍历算法。这次主要是介绍树的孩子兄弟表示法以及树和二叉树的转换。还是老规矩：程序在码云上可以下载。 地址：https://git.oschina.net/601345138/DataStructureCLanguage.git如果你对树的基本概念还不清楚请看这个PPT，里面有一些动态演示可以帮助你更好的理解它的各种操作： htt
如何将一棵树转化成二叉树
天天向上
02-21 4万+
要点： 从这棵树的根结点开始，从上到下，看每一个结点，把你正在看的结点的孩子放在左子树，兄弟放在又子树。 口诀： 1. 将 节点的孩子 放在左子树； 2. 将 节点的兄弟 放在右子树。 关于这个问题，最好的办法就是记住一道例题了，因为语言不是很好描述，也不容易看懂描述。 例题： 或者有另一种理解方法： 步骤： 1.在所有兄弟结点之间加一连线 2.对每个结点，除了保留与其长子...
把二叉树转换成树（代码实现）
追梦少年ML的博客
04-22 6410
前言： 相信大家都知道二叉树如何转化成树，但是让你用代码实现，却发现自己无从下手。下面我将用代码实现。 代码： #include<iostream> #include<vector> using namespace std; struct TreeNode{//二叉树的结构 int val; TreeNode* left; TreeNode* right; Tre...
树、森林与二叉树的转换
热门推荐
CSDN
12-30 14万+
树、森林与二叉树的转换 1、树转换为二叉树 由于二叉树是有序的，为了避免混淆，对于无序树，我们约定树中的每个结点的孩子结点按从左到右的顺序进行编号。 将树转换成二叉树的步骤是： （1）加线。就是在所有兄弟结点之间加一条连线； （2）抹线。就是对树中的每个结点，只保留他与第一个孩子结点之间的连线，删除它与其它孩子结点之间的连线； （3）旋转。就是以树的根结点为轴心，将整棵树顺时针旋转一定...
请编写一个程序，实现将树转化成二叉树。（华为）
wangyangkobe的专栏
03-07 9127
#include "stdafx.h" #include #include using namespace std; //树的节点 struct TreeNode { char element; int childNumbers;//孩子结点的个数 struct TreeNode* child[3];//孩子的数组 TreeNode(){} TreeNode(char ele, int numbers) { element = ele; childNumb
c语言实现树与二叉树的转换代码
06-01
以下是将一颗普通树转换为二叉树的C语言代码： ```c #include <stdio.h> #include <stdlib.h> typedef struct TreeNode { int data; struct TreeNode *firstChild; struct TreeNode *nextSibling; } TreeNode; typedef struct BinaryTreeNode { int data; struct BinaryTreeNode *left; struct BinaryTreeNode *right; } BinaryTreeNode; BinaryTreeNode* convert(TreeNode *root) { if (root == NULL) { return NULL; } BinaryTreeNode *binaryRoot = (BinaryTreeNode *)malloc(sizeof(BinaryTreeNode)); binaryRoot->data = root->data; binaryRoot->left = NULL; binaryRoot->right = NULL; if (root->firstChild != NULL) { binaryRoot->left = convert(root->firstChild); } if (root->nextSibling != NULL) { binaryRoot->right = convert(root->nextSibling); } return binaryRoot; } int main() { // 构造一颗普通树 TreeNode *root = (TreeNode *)malloc(sizeof(TreeNode)); root->data = 1; root->firstChild = (TreeNode *)malloc(sizeof(TreeNode)); root->firstChild->data = 2; root->firstChild->firstChild = (TreeNode *)malloc(sizeof(TreeNode)); root->firstChild->firstChild->data = 4; root->firstChild->firstChild->firstChild = NULL; root->firstChild->firstChild->nextSibling = NULL; root->firstChild->nextSibling = (TreeNode *)malloc(sizeof(TreeNode)); root->firstChild->nextSibling->data = 5; root->firstChild->nextSibling->firstChild = NULL; root->firstChild->nextSibling->nextSibling = NULL; root->nextSibling = (TreeNode *)malloc(sizeof(TreeNode)); root->nextSibling->data = 3; root->nextSibling->firstChild = NULL; root->nextSibling->nextSibling = NULL; // 将普通树转换为二叉树 BinaryTreeNode *binaryRoot = convert(root); return 0; } ``` 其中，`TreeNode` 表示普通树的节点，包含一个数据域和两个指针域，分别指向第一个孩子和兄弟节点；`BinaryTreeNode` 表示二叉树的节点，包含一个数据域和两个指针域，分别指向左子树和右子树。 `convert` 函数接受一个普通树的根节点作为参数，返回一个二叉树的根节点。在函数内部，我们先创建一个二叉树的根节点，将普通树的根节点的数据域赋值给二叉树的根节点的数据域。然后，如果普通树的根节点有第一个孩子，我们递归调用 `convert` 函数得到其左子树，并将其赋值给二叉树的根节点的左子树指针；如果普通树的根节点有兄弟节点，我们递归调用 `convert` 函数得到其右子树，并将其赋值给二叉树的根节点的右子树指针。最后，返回二叉树的根节点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值