【数据结构初学笔记13】第四章二叉树MOOC练习题

已于 2022-11-03 21:39:22 修改
阅读量124 收藏
点赞数
文章标签： 数据结构 算法
于 2022-11-01 13:27:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50662459/article/details/127631884
版权

课后作业：

  1. 是否同一棵二叉搜索树 小白专场将详细介绍C语言实现方法，属于基本训练，一定要做；

  2. Root of AVL Tree  2013年浙江大学计算机学院免试研究生上机考试真题，是关于AVL树的基本训练，一定要做；

  3. Complete Binary Search Tree 2013年秋季PAT甲级真题，略有难度，量力而行。第7周将给出讲解。

  4. 二叉搜索树的操作集 用C语言的同学，可以在这里把老师讲过的各种操作都试用一下。

1.是否同一颗二叉搜索树

//注意，标志位在置位时，尽量将其设置为置1语句，不容易出错。
#include <stdio.h>
#include <stdlib.h>
#define ElementType int
typedef struct BSTNode *Position;
typedef Position BSTree; /* 二叉搜索树类型 */
struct BSTNode
{
    ElementType Data; /* 结点数据 */
    BSTree Left;      /* 指向左子树 */
    BSTree Right;     /* 指向右子树 */
    int flag;         //结点被访问过的标志
};

BSTree MakeTree(int N);                 //根据输入建立一个二叉搜索树T，并返回首结点地址
BSTree Insert(BSTree T, ElementType v); //向二叉搜索树中插入一个结点v；
int Judge(BSTree T, int N);             //判断输入序列与二叉搜索树T是否匹配，匹配返回1
int check(BSTree T, ElementType X);     //在树T中搜索结点元素X，若所经过结点的flag标志为1，则继续向子树元素检查；若flag为0，且结点与x相等，则返回1
void ResetT(BSTree T);                  //重置树T中的标志数据flag
void FreeTree(BSTree T);                //释放掉树T的空间

int main(void)
{
    int N, L; // N是二叉树结点数，L是后面需要判断的序列个数
    BSTree T;
    scanf("%d", &N);
    while (N)
    {
        scanf("%d", &L);
        T = MakeTree(N);
        for (int i = 0; i < L; i++)
        {
            if (Judge(T, N))
                printf("Yes\n");
            else
                printf("No\n");
            ResetT(T); //清楚T中标记falg
        }
        FreeTree(T);
        scanf("%d", &N); //输入下一个判别序列的结点数N
    }
    return 0;
}
BSTree MakeTree(int N)
{ //建立第一颗树
    BSTree T = (BSTree)malloc(sizeof(struct BSTNode));
    T->flag = 0;
    T->Left = NULL;
    T->Right = NULL;
    int v, i;
    scanf("%d", &v);
    T->Data = v;
    for (i = 1; i < N; i++)
    {
        scanf("%d", &v);
        T = Insert(T, v);
    }
    return T;
}
BSTree Insert(BSTree T, ElementType v)
{ //向二叉搜索树中插入一个结点v；
    if (!T)
    {
        T = (BSTree)malloc(sizeof(struct BSTNode));
        T->Data = v;
        T->flag = 0;
        T->Left = NULL;
        T->Right = NULL;
    }
    else
    {
        if (v > T->Data)
            T->Right = Insert(T->Right, v);
        else
            T->Left = Insert(T->Left, v);
    }
    return T;
}
int Judge(BSTree T, int N) //判断是否匹配，匹配返回1
{
    int v, flag = 0; // flag为不匹配标志位
    scanf("%d", &v);
    if (v != T->Data)
        flag = 1;
    else
        T->flag = 1;
    for (int i = 1; i < N; i++)
    {
        scanf("%d", &v);
        if ((!flag) && (!check(T, v))) //存在不匹配的情况
            flag = 1;
    }
    if (flag)
        return 0;
    else
        return 1;
}
int check(BSTree T, ElementType X)
//在树T中搜索结点元素X，若所经过结点的flag标志为1，则继续向子树元素检查；若flag为0，且结点与x相等，则返回1
{
    if (T->flag) //结点元素被访问过
    {
        if (X > T->Data)
            return check(T->Right, X);
        else if (X < T->Data)
            return check(T->Left, X);
        else
            return 0;
    }
    else //结点元素没有被访问过
    {
        if (X == T->Data)
        {
            T->flag = 1;
            return 1;
        }
        else
            return 0;
    }
}
void ResetT(BSTree T)
{
    if (T->Left)
        ResetT(T->Left);
    if (T->Right)
        ResetT(T->Right);
    T->flag = 0;
}
void FreeTree(BSTree T)
{
    if (T->Left)
        FreeTree(T->Left);
    if (T->Right)
        FreeTree(T->Right);
    free(T);
}
//测试输入：
// 4 2
// 3 1 4 2
// 3 4 1 2
// 3 2 4 1
// 2 1
// 2 1
// 1 2
// 0
//测试输出
// Yes
// No
// No

2.Root of AVL Tree

//输入一个序列，按照平衡二叉树原则进行插入，并找到它的根节点
//思路：每次插入一个结点，更新每个结点的平衡因子，找到“发现者”，并判断需要进行哪种处理。
#include <stdio.h>
#include <stdlib.h>
#define ElementType int
typedef struct AVLNode *Position;
typedef Position AVLTree; /* AVL树类型 */
struct AVLNode
{
    ElementType Data; /* 结点数据 */
    AVLTree Left;     /* 指向左子树 */
    AVLTree Right;    /* 指向右子树 */
    int Height;       /* 树高 */
};
int Max(int a, int b);
AVLTree SingleLeftRotation(AVLTree A);
AVLTree SingleRightRotation(AVLTree A);
AVLTree DoubleLeftRightRotation(AVLTree A);
AVLTree DoubleRightLeftRotation(AVLTree A);
AVLTree Insert(AVLTree T, ElementType X);
int GetHeight(AVLTree BT);
int main(void)
{
    int N, v; // N为输入结点个数，v表示每次输入数据。
    scanf("%d", &N);
    AVLTree T=NULL;
    for (int i = 0; i < N; i++)
    {
        scanf("%d", &v);
        T=Insert(T, v);
    }
    printf("%d\n", T->Data);
    return 0;
}

int Max(int a, int b)
{
    return a > b ? a : b;
}

AVLTree SingleLeftRotation(AVLTree A)
{ /* 注意：A必须有一个左子结点B */
    /* 将A与B做左单旋，更新A与B的高度，返回新的根结点B */

    AVLTree B = A->Left;
    A->Left = B->Right;
    B->Right = A;
    A->Height = Max(GetHeight(A->Left), GetHeight(A->Right)) + 1;
    B->Height = Max(GetHeight(B->Left), A->Height) + 1;

    return B;
}
//右单旋，自己补充
AVLTree SingleRightRotation(AVLTree A)
{ /* 注意：A必须有一个右子结点B */
    /* 将A与B做右单旋，更新A与B的高度，返回新的根结点B */

    AVLTree B = A->Right;
    A->Right = B->Left;
    B->Left = A;
    A->Height = Max(GetHeight(A->Left), GetHeight(A->Right)) + 1;
    B->Height = Max(GetHeight(B->Left), A->Height) + 1;

    return B;
}

AVLTree DoubleLeftRightRotation(AVLTree A)
{ /* 注意：A必须有一个左子结点B，且B必须有一个右子结点C */
    /* 将A、B与C做两次单旋，返回新的根结点C */

    /* 将B与C做右单旋，C被返回 */
    A->Left = SingleRightRotation(A->Left);
    /* 将A与C做左单旋，C被返回 */
    return SingleLeftRotation(A);
}
//右-左双旋，自己补充
AVLTree DoubleRightLeftRotation(AVLTree A)
{ /* 注意：A必须有一个右子结点B，且B必须有一个左子结点C */
    /* 将A、B与C做两次单旋，返回新的根结点C */

    /* 将B与C做左单旋，C被返回 */
    A->Right = SingleLeftRotation(A->Right);
    /* 将A与C做左单旋，C被返回 */
    return SingleRightRotation(A);
}

/*************************************/
/* 对称的右单旋与右-左双旋请自己实现 */
/*************************************/

AVLTree Insert(AVLTree T, ElementType X)
{ /* 将X插入AVL树T中，并且返回调整后的AVL树 */
    if (!T)
    { /* 若插入空树，则新建包含一个结点的树 */
        T = (AVLTree)malloc(sizeof(struct AVLNode));
        T->Data = X;
        T->Height = 0;
        T->Right = NULL;
        T->Left = NULL;
    } /* if (插入空树) 结束 */

    else if (X < T->Data)
    {
        /* 插入T的左子树 */
        T->Left = Insert(T->Left, X);
        /* 如果需要左旋 */
        if (GetHeight(T->Left) - GetHeight(T->Right) == 2)
            if (X < T->Left->Data)
                T = SingleLeftRotation(T); /* 左单旋 */
            else
                T = DoubleLeftRightRotation(T); /* 左-右双旋 */
    }                                           /* else if (插入左子树) 结束 */

    else if (X > T->Data)
    {
        /* 插入T的右子树 */
        T->Right = Insert(T->Right, X);
        /* 如果需要右旋 */
        if (GetHeight(T->Left) - GetHeight(T->Right) == -2)
            if (X > T->Right->Data)
                T = SingleRightRotation(T); /* 右单旋 */
            else
                T = DoubleRightLeftRotation(T); /* 右-左双旋 */
    }                                           /* else if (插入右子树) 结束 */

    /* else X == T->Data，无须插入 */

    /* 别忘了更新树高 */
    T->Height = Max(GetHeight(T->Left), GetHeight(T->Right)) + 1;

    return T;
}
// 求二叉树的高度。
int GetHeight(AVLTree BT)
{
    int HL, HR, MaxH;
    if (BT)
    {
        HL = GetHeight(BT->Left);   /*求左子树的深度*/
        HR = GetHeight(BT->Right);  /*求右子树的深度*/
        MaxH = (HL > HR) ? HL : HR; /*取左右子树较大的深度*/
        return (MaxH + 1);          /*返回树的深度*/
    }
    else
        return 0; /* 空树深度为0 */
}
//输入
// 7
// 88 70 61 96 120 90 65
//输出
// 88

3.Complete Binary Search Tree

//没写出来，等后面听完讲解再补充。
//2022.11.03补充
/*题意：给定一个整数序列，建立成为一个完全二叉搜索树CBST，并按照层序遍历的方法进行打印*/
/*思路：1.因为是完全二叉树形式，并且进行层序遍历，可以采用数组存储*/
/*2.将输入序列按照大小顺序排序，在CBST中，左子树结点值一定都小于根结点值，右子树结点值一定都大于根结点值*/
/*3.找到根结点的位置：根据元素个数n，计算层数和左子树节点个数，从而确定根结点位置，利用递归的方法得到完整的CBST*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define ElementType int
#define MaxSize 10000
int A[MaxSize]; /*保存输入的数据*/
int T[MaxSize]; /*保存完全二叉搜索树数据*/

int compare(const void *a, const void *b);    /*对数字排序需要用到的程序*/
void solve(int ALeft, int ARight, int TRoot); /*输入树左右边界序号，及根结点序号，找出根结点元素，并递归*/
int GetLeftLength(int n);                     /*计算完全二叉树（结点数n）的左子树结点数目*/
int main(void)
{
    int N, i, TRoot;
    scanf("%d", &N);
    for (i = 0; i < N; i++)
        scanf("%d", &A[i]);
    qsort(A, N, sizeof(int), compare);
    solve(0, N - 1, 0);
    /*打印层序遍历结果*/
    for (i = 0; i < N - 1; i++)
    {
        printf("%d ", T[i]);
    }
    printf("%d", T[i]);
    return 0;
}
int compare(const void *a, const void *b)
{ /*对数字排序需要用到的程序*/
    return *(int *)a - *(int *)b;
}
void solve(int ALeft, int ARight, int TRoot)
{ /*输入树左右边界序号，及根结点序号，找出根结点元素，并递归；初始调用为 solve(0, N-1, 0) */

    int n, L, LeftTRoot, RightTRoot;
    n = ARight - ALeft + 1; /*当前序列长度*/
    if (n == 0)
        return;
    L = GetLeftLength(n); /*计算完全二叉树（结点数n）的左子树结点数目*/
    T[TRoot] = A[ALeft + L];
    LeftTRoot = 2 * TRoot + 1;
    RightTRoot = LeftTRoot + 1;
    solve(ALeft, ALeft + L - 1, LeftTRoot);
    solve(ALeft + L + 1, ARight, RightTRoot);
}
int GetLeftLength(int n)
{ /*计算完全二叉树（结点数n）的左子树结点数目*/
    int i, count = 0;
    for (i = 0; count < n;)
    {
        i++;
        count = count + pow(2, i - 1);
    }
    if (count == n)               /*树高为i,满二叉树*/
        return pow(2, i - 1) - 1; /*左子树结点个数2^(i-1)-1*/
    else if (count > n)           /*树高为i，完全二叉树*/
    {
        int item;                                      /*最后一层属于左子树的结点数*/
        if ((n - (pow(2, i - 1) - 1)) > pow(2, i - 2)) /*最后一层结点多于一半*/
            item = pow(2, i - 2);
        else
            item = n - (pow(2, i - 1) - 1);
        return item + pow(2, i - 2) - 1; /*左满二叉子树层数为i-2*/
    }
}
/*input test*/
// 10
// 1 2 3 4 5 6 7 8 9 0
/*output*/
// 6 3 8 1 5 7 9 0 2 4

        注意：排序函数qsort的用法；

4.二叉搜索树的操作集

//二叉搜索树5种常用操作的实现
// 01插入元素
BinTree Insert(BinTree BST,ElementType X)
{
    if (!BST) //如果结点为空，则申请空间存放要插入的元素X
    {
        BST = (BinTree)malloc(sizeof(struct TNode));
        BST->Data = X;
        BST->Left = NULL;
        BST->Right = NULL;
    }
    //开始插入元素，X插入左子树，X插入右子树，X已经存在
    else if (X < BST->Data)
        BST->Left = Insert(BST->Left, X);
    else if (X > BST->Data)
        BST->Right = Insert(BST->Right, X);
    return BST;
}
// 02二叉搜索树删除元素：情况1删除叶结点，直接删除，修改父结点指针；情况2删除只有一个孩子的结点，将其父结点指向该结点的孩子结点；
//情况3删除有两个孩子的结点，搜索其左子树的最大元素或右子树的最小元素，替代要删除的结点元素，并在左子树中删除该元素。
BinTree Delete(BinTree BST,ElementType X)
{
    BinTree temp;
    if (!BST)
        printf("Not Found\n");
    else if (X < BST->Data)
        BST->Left=Delete(BST->Left, X); //左子树递归删除
    else if (X > BST->Data)
        BST->Right=Delete(BST->Right, X); //右子树递归删除
    //找到要删除的结点元素
    else if (BST->Left && BST->Right) //情况3左右子树都存在
    {
        temp = FindMin(BST->Right); //找到右子树中的最小元素
        BST->Data = temp->Data;
        BST->Right = Delete(BST->Right, temp->Data); //在右子树中删除该结点元素
    }
    else
    {
        temp = BST;
        if (!BST->Left) //情况2没有左子树（只有右子树或没有子树）
        {
            // BST->Data = BST->Right->Data;
            // BST->Left = BST->Right->Left;
            // BST->Right = BST->Right->Right;
            //不能这样用，BST指针存储当前要删除的结点的地址，而父结点保存的是当前结点的指针地址变量，即BST；
            // 故可以直接更改BST指针所保存的内容，来实现更改删除该结点。
            BST = BST->Right;
        }
        else if (!BST->Right) //情况2只有左子树
        {
            BST = BST->Left;
        }
        free(temp);
    }
    return BST;
}
// 03查找操作Find(递归实现)
Position Find(BinTree BST,ElementType X)
{
    if (!BST)
        return NULL;
    if (X > BST->Data)
        return Find(BST->Right,X); //在右子树中继续查找
    else if (X < BST->Data)
        return Find(BST->Left,X); //在左子树中继续查找
    else
        return BST; //查找成功，返回结点的找到结点的地址
}
// 04递归查找最小元素
Position FindMax(BinTree BST)
{
    if (!BST)
        return NULL; //空树，返回NULL
    else if (!BST->Right)
        return BST;
    else
        return FindMax(BST->Right);
}
// 05递归查找最小元素
Position FindMin(BinTree BST)
{
    if (!BST)
        return NULL; //空树，返回NULL
    else if (!BST->Left)
        return BST;
    else
        return FindMin(BST->Left);
}

结束

课程来源：浙江大学数据结构慕课MOOC

饭卡反卷积
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构篇——二叉排序（查找，搜索）树
CZC1999的博客
11-02 434
引入 基本性质： 二叉排序树(又叫二叉搜索、查找树) 是一种特殊的二叉树，定义如下： 若左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若右子树不空，则右子树上所有结点的值均大于它的根结点的值； 左、右子树也分别为二叉排序树。 不允许有键值相同结点。【如果真的出现了，那么放在左子树，右子树是无所谓的】 二分查找与二叉排序树 ​ 二分查找也称为折半查找，要求原线性表有序，它...
二叉搜索树的插入与删除
lizhenhao
11-20 311
插入： BSTree Insert(BSTree BST, ElementType X){BSTree Insert(BSTree BST, ElementType X){ if(!BST){//如果是一颗空的二叉树，就新建一个二叉搜索树并返回 BST = (BSTree)malloc(sizeof(struct TNode)); BST-&amp;gt;Data = X; BST-&amp;gt;Left =...
有序二叉树c语言,二叉搜索树(BST)的实现（C语言）（原创）
weixin_36142226的博客
05-22 389
叉搜索树(Binary Search Tree)的一般形式如下图所示，每个节点中的元素大于它的左子树中的所有元素，小于它的右子树中的所有元素。对该图中的二叉树进行中序遍历得到一个从小到大排列的有序序列。本文给出了上述二叉树的一个C语言实现，包括二叉树的节点添加，删除，查找等等。源码分为三个文件，使用VC 6.0编译，其中bstree.h是二叉搜索树的数据结构和函数声明，bstree.c是二叉搜索树...
二叉搜索树的相关操作（增删查改）---递归实现
better12038的博客
12-27 179
//BSTree_R.h //递归实现 #pragma once #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;windows.h&gt; typedef struct BSTreeNode { int key; struct BSTreeNode *left; struct BSTreeNode *ri...
04-树4 是否同一棵二叉搜索树
明朗晨光的专栏
08-15 1169
题目 给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的各种插入序列，你需要判断它们是否能生成一样的二叉搜索树。 输入格式: 输入包含若干组测试数据。每组数据的第1行给出两个正整数N(≤10)和L，分别是每个序列插入元素的个数...
【数据结构初学笔记11】第三章二叉树MOOC练习题
m0_50662459的博客
10-29 359
浙江大学慕课MOOC数据结构学习笔记第三章PTA练习题
【数据结构初学笔记10】第三章二叉树同构判断
m0_50662459的博客
10-25 416
浙江大学陈越数据结构MOOC慕课初学笔记10第三章二叉树同构判断
数据结构与算法书籍、视频、项目、网站、刷题技巧推荐（2021 年持续更新）...
程序员吴师兄的博客
04-12 4027
今天整理出一些算法相关学习资源，包括书籍、算法刷题网站、项目资源、视频课程、面试要领这5个方面。首先介绍一下技术书阅读方法论。一.速读一遍（最好在1~2天内完成）人的大脑记忆力有限，在一天内快速看完一本书会在大脑里留下深刻印象，对于之后复习以及总结都会有特别好的作用。 对于每一章的知识，先阅读标题，弄懂大概讲的是什么主题，再去快速看一遍，不懂也没有关系，但是一定要在不懂的地方做个记号，什么记号无所...
数据结构作业：第6章二叉树作业.docx
12-16
数据结构作业：第六章二叉树作业 本资源摘要信息主要关注数据结构的二叉树章节，涵盖了二叉树的基本概念、性质、操作和应用。该资源提供了多种题型，包括判断正误、填空、选择题、阅读分析题和算法设计题，旨在考察...
数据结构作业：第6章二叉树作业答案.docx
12-13
"数据结构作业：第6章二叉树作业答案.docx" 本文档提供了第6章二叉树作业答案，涵盖了二叉树的基本概念、性质和应用。通过对二叉树的定义、特性和操作的详细解释，读者可以深入了解二叉树的结构和应用。 一、判断...
数据结构第6章二叉树练习题.doc
12-29
数据结构第六章二叉树练习题 本资源是一个关于数据结构的练习题，专门针对二叉树的知识点。该资源包含了多个问题，涵盖了二叉树的定义、性质、遍历方法、存储结构等方面的知识点。 1. 二叉树的定义：二叉树是一种...
初学数据结构时候做的练习题集合笔记
04-02
这篇初学者的练习题集合笔记主要关注了两种基本数据结构：数组和链表，并对它们的优缺点进行了比较。同时，笔记也提到了平衡二叉树作为提高查找效率的一种高级数据结构。 数组是一种线性数据结构，其中元素存储在...
计算机软件基础：14第四章数据结构二叉树.doc
12-01
计算机软件基础：第四章数据结构二叉树 本章主要介绍了二叉树的定义、括号表示、Backus描述形式、存储形式和数组存储二叉树的扩充标准形式。 一、二叉树的定义 在一棵二次树中，若规定后件是有序的，即对于任何一...
数据结构篇：旋转操作在AVL树中的实现过程
weixin_41489908的博客
06-15 467
本文详细介绍了AVL树中的旋转操作及其实现过程，包括右旋、左旋、左右旋和右左旋。通过多个代码案例，我们展示了这些旋转操作的应用和效果。在实际开发中，AVL树通过旋转操作保持平衡，从而保证二叉搜索树的高效性能。希望这些示例和注意事项能帮助你更好地理解和应用AVL树中的旋转操作。
数据结构——堆
最新发布
2301_80772499的博客
06-17 1219
在了解堆之前我们要先知道什么是物理结构，什么是实际结构。物理结构就是实际要用到那种内存储存形式，是像数组这样连续的，还是像链表这样分散的。实际结构举个例子，二叉树实际结构就是一颗类似树的结构，链表就是类似链状的结构，是我们想象出来直观的。像顺序表它的物理结构和实际结构都是数组，链表的物理结构和实际结构也是相似的，二叉树也是同理。但是今天要讲的堆，它的物理结构是数组，但是实际结构却是完全二叉树。是一个比较抽象的数据结构。
【数据结构】遍历二叉树（递归思想）--＞赋源码
Cayyyy的博客
06-15 2851
遍历二叉树
力扣416 分割等和子集 Java版本
m0_47066863的博客
06-14 460
然后就可以考虑用0-1背包的思路来解决这个问题，这里元素的值就是当前元素的价值和重量，背包的容量就是子集元素和的一半，最终需要确定这个背包里是否能够正好装进价值为子集和一半的时候。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。找出两个子集，让这两个子集的和相等可以转化思路为：找到一个子集，这个子集的和是子集中所有元素和的一半。解释：数组可以分割成 [1, 5, 5] 和 [11]。输入：nums = [1,5,11,5]输入：nums = [1,2,3,5]
力扣136. 只出现一次的数字
LNsupermali的博客
06-15 494
力扣136. 只出现一次的数字
数据结构 二叉树笔记
12-24
二叉树是一种常见的数据结构，它由节点和边组成。每个节点最多有两个子树，分别称为左子树和右子树。二叉树具有以下性质： 1. 在二叉树的第i层上，最多有2^(i-1)个节点（i>0）。 2. 深度为k的二叉树最多有2^k-1个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值