数据结构与算法实验4——集合的应用（排序算法）

最新推荐文章于 2022-11-24 20:33:21 发布
最新推荐文章于 2022-11-24 20:33:21 发布
阅读量782 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 选择排序 插入排序 冒泡排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45947938/article/details/124294364
版权

一、实验目的

1.  掌握常见排序算法的策略、适用条件和程序实现。

2．掌握折半查找算法的思想及程序实现。

3．掌握 BST 的建立、查找、插入、删除算法策略及其程序实现。

4．选择合适的散列函数，实现不同冲突处理方法的散列表建立与查找。

二、实验任务

1. 实现选择排序、插入排序和冒泡排序。

2. 实现快速排序的非递归算法（可借助栈实现）。

3. 实现堆排序算法。

4. 实现折半插入排序。

5. 采用链式存储结构实现：选择排序、插入排序和冒泡排序。

6. 在主函数中设计一个简单菜单，调用上述算法。

1 建立有序表，采用折半查找实现某一已知关键字的查找。

2．随机产生一组关键字，利用插入算法建立 BST，然后删除某一指定关键字的元素。

3．建立散列表：散列函数 H(key)=key%p（p 为自定常数），冲突处理分别采用线性探 测法、拉链法。

三、源代码

源文件

/*
实验4：集合应用
实验名称：排序算法
实验目的：掌握常见排序算法的策略、适用条件和程序实现。
实验内容：
	1. 实现选择排序、插入排序和冒泡排序。
	2. 实现快速排序的非递归算法（可借助栈实现）。
	3. 实现堆排序算法。
	4. 实现折半插入排序。
	5. 采用链式存储结构实现：选择排序、插入排序和冒泡排序。
	6. 在主函数中设计一个简单菜单，调用上述算法。
实验日期：2021/1/5
开发者：每天八杯水
*/
#include"Sort.h"
SortArr* SSortArr();
void ShowSortArr(SortArr*);
SortArr* InsertSort(SortArr*);
SortArr* BinSort(SortArr*);
SortArr* SelectSort(SortArr*);
void HeapAdjust(SortArr* ,int, int);
void HeapSort(SortArr*, int);
SortArr* BubbleSort(SortArr*);

int main()
{
   //设置一组待排序数组
    SortArr* sortArr = SSortArr();//sortArr为该待排序数组的指针
    cout << "你创建的待排序数组为：";
    ShowSortArr(sortArr);//打印出设置的待排序数组

    bool opt = true;  //是否循环的一个标志
    while (opt == true) {
                              //主菜单列表
        cout << "\n\t\t********************************\n";
        cout << "\t\t*      WELCOM TO MY WORLD      *\n";
        cout << "\t\t*   1.    插入排序             *\n";
        cout << "\t\t*   2.    选择排序             *\n";
        cout << "\t\t*   3.    交换排序             *\n";
        cout << "\t\t*   4.    退出程序             *\n";
        cout << "\t\t********************************\n";
        //接收输入选择
        cout << "\t\t请选择：";
        int x;
        cin >> x;
        //判断用户的选择
        switch (x) {
        case 1:
        {//设置插入排序循环，有两个算法：直接插入排序  二分插入排序
            bool  opt1 = true;
            while (opt1==true)
            {
                                    //插入排序列表
                cout << "\n\t\t*****************************\n";
                cout << "\t\t*          插入排序         *\n";
                cout << "\t\t*   1.    直接插入排序      *\n";
                cout << "\t\t*   2.    二分插入排序      *\n";
                cout << "\t\t*   3.    Shell排序         *\n";
                cout << "\t\t*   4.    释放资源          *\n";
                cout << "\t\t*   5.    返回主菜单        *\n";
                cout << "\t\t*****************************\n";

               
                //接收输入选择
                cout << "\t\t请选择：";
                int x;
                cin >> x;
                //判断用户的选择
                switch (x) {
                case 1://直接插入排序
                    cout << "直接插入排序后的顺序:";
                    ShowSortArr(InsertSort(sortArr));//排序并打印排序后的数据
                    opt1 = Out();        //子菜单目录
                    if (opt1 == false)opt = true;//第二层循环退出时，令第一层循环为真继续循环
                    break;

                case 2:
                    cout << "二分插入排序后的顺序:";
                    ShowSortArr(BinSort(sortArr));//排序并打印排序后的数据
                    opt1 = Out();        //子菜单目录
                    if (opt1 == false)opt = true;
                    break;

                case 3:
                    opt1 = Out();        //子菜单目录
                    if (opt1 == false)opt = true;
                    break;

                case 4:
                    opt1 = Out();        //子菜单目录
                    if (opt1 == false)opt = true;
                    break;

                case 5:
                    opt = true;
                    opt1 = false;        //子菜单目录
                    if (opt1 == false)opt = true;
                    break;

                default:
                    cout << "\n\t\t输入非法，请重新选择!\n";
                    break;
                }
            }
        }         
            break;

        case 2:
        {//设置选择排序循环，有两个算法：直接选择排序  堆排序
            bool  opt1 = true;
            while (opt1 == true)
            {
                                    //选择排序列表
                cout << "\n\t\t*****************************\n";
                cout << "\t\t*          选择排序         *\n";
                cout << "\t\t*   1.    直接选择排序      *\n";
                cout << "\t\t*   2.    堆排序            *\n";
                cout << "\t\t*   3.    释放资源          *\n";
                cout << "\t\t*   4.    返回主菜单        *\n";
                cout << "\t\t*****************************\n";
                //接收输入选择
                cout << "\t\t请选择：";
                int x;
                cin >> x;
                //判断用户的选择
                switch (x) {
                case 1:
                    cout << "直接选择排序后的顺序:";
                    ShowSortArr(SelectSort(sortArr));//排序并打印排序后的数据
                    opt1 = Out();        //子菜单目录
                    if (opt1 == false)opt = true;//第二层循环退出时，令第一层循环为真继续循环
                    break;

                case 2:
                    //堆排序
                    cout << "堆排序后的顺序:";
                    HeapSort(sortArr, sortArr->cnt);
                    opt1 = Out();        //子菜单目录
                    if (opt1 == false)opt = true;
                    break;

                case 3:
                    opt1 = Out();        //子菜单目录
                    if (opt1 == false)opt = true;
                    break;

                case 4:
                    opt = true;
                    opt1 = false;        //子菜单目录
                    if (opt1 == false)opt = true;
                    break;

                default:
                    cout << "\n\t\t输入非法，请重新选择!\n";
                    break;
                }
            }
        }               
            break;
        
        case 3:
        {//设置交换排序循环，有两个算法：冒泡排序  快速排序
            bool  opt1 = true;
            while (opt1 == true)
            {
                                  //交换排序列表
                cout << "\n\t\t*****************************\n";
                cout << "\t\t*         交换排序         *\n";
                cout << "\t\t*   1.    冒泡排序          *\n";
                cout << "\t\t*   2.    快速排序          *\n";
                cout << "\t\t*   3.    释放资源          *\n";
                cout << "\t\t*   4.    返回主菜单        *\n";
                cout << "\t\t*****************************\n";
                //接收输入选择
                cout << "\t\t请选择：";
                int x;
                cin >> x;
                //判断用户的选择
                switch (x) {
                case 1:
                    cout << "冒泡排序后的顺序:";
                    ShowSortArr(BubbleSort(sortArr));//排序并打印排序后的数据
                    opt1 = Out();        //子菜单目录
                    if (opt1 == false)opt = true;//第二层循环退出时，令第一层循环为真继续循环
                    break;

                case 2:
                    cout << "快速排序后的顺序:";
                    ShowSortArr(QuickSort(sortArr,0,sortArr->cnt-1));//排序并打印排序后的数据
                    opt1 = Out();        //子菜单目录
                    if (opt1 == false)opt = true;
                    break;

                case 3:
                    opt1 = Out();        //子菜单目录
                    if (opt1 == false)opt = true;
                    break;

                case 4:
                    opt = true;
                    opt1 = false;        //子菜单目录
                    if (opt1 == false)opt = true;
                    break;

                default:
                    cout << "\n\t\t输入非法，请重新选择!\n";
                    break;
                }
            }
        }
        break;
           
            break;

        case 4:
           
            opt = false;        //把标志位为假，就退出了循环
            break;
        default:
            cout << "\n\t\t输入非法，请重新选择!\n";
            break;
        }
    }
    cout << "\n\t\t菜单已退出!\n";
}

头文件

/*
    头文件
*/
#pragma once
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
using namespace std;


/*
    定义小目录-进入算法后如何退出的实现
*/
int Out() {
    cout << "\n";
    cout << "\t\t****************\n";
    cout << "\t\t*算法结束请选择*\n";
    cout << "\t\t* 1.返回子菜单 *\n";
    cout << "\t\t* 2.返回主菜单 *\n";//主菜单界面
    cout << "\t\t****************\n";
    cout << "\t\t选择：";
    char y;
    cin >> y;      //接受输入
    switch (y) {
    case '1':
        return true;
    case '2':
        return false;
    default:
        cout << "\t\t非法输入，已返回主目录!\n";//输入其他数字无效
        return true;
        break;
    }
}


typedef int KeyType;
typedef int InfoType;
typedef struct RECORDTYPE_STRU//数组每一个下标存放的是这个结构体的地址
{
    KeyType key;
    InfoType otherInfo;
}RecordType;
typedef struct SORTARRAY_STRU
{
    int cnt;//排序数组中的元素个数
    RecordType* recordArr;//指向排序数组的指针
}SortArr;

/*
    交换i 和 j 两个元素关键字的位置
*/
void Swap(SortArr* sortArr, int i, int j)
{
    KeyType temp;
    temp = sortArr->recordArr[i].key;//排序数组中第i个元素的关键字赋值给temp，
    sortArr->recordArr[i].key = sortArr->recordArr[j].key;
    sortArr->recordArr[j].key = temp;
}

/*
    待排序数组
*/
SortArr* SSortArr()
{
    SortArr* sortArr;//待排序数据指针地址
    sortArr = (SortArr*)malloc(sizeof(SortArr*));//申请排序数组指针空间
    //随机函数创建一组乱序数据
    cout << "正在随机创建一组乱序数据，请等待......" << endl;
    cout << "请输入该待排序元素个数：";
    int cnt;
    cin >> cnt;
    sortArr->cnt = cnt;
    sortArr->recordArr = (RecordType*)malloc(sizeof(RecordType) * sortArr->cnt);//申请数组的大小空间
    srand((unsigned)time(NULL));//rand函数的不同时间种子
    for (int i = 0; i < cnt; i++)
    {
        sortArr->recordArr[i].key = rand()%100;//除以100表示随机数在0到100的范围
    }
    return sortArr;
}

void ShowSortArr(SortArr* sortArr)
{
    for (int i = 0; i < sortArr->cnt; i++)
    {
        cout << sortArr->recordArr[i].key << "  ";
    }
}

/*
    直接插入排序算法
*/
SortArr* InsertSort(SortArr* sortArr)
{
    int i, j;
    RecordType temp;
    for (i = 1; i < sortArr->cnt; i++)
    {
        j = i - 1;
        temp = sortArr->recordArr[i];
        while (temp.key < sortArr->recordArr[j].key && j>=0)
        {
            sortArr->recordArr[j + 1] = sortArr->recordArr[j];
            j--;
        }
        if (j + 1 != i) {
            sortArr->recordArr[j+1] = temp;
        }
    }
    return sortArr;
}

/*
    二分插入
*/
SortArr* BinSort(SortArr* sortArr)
{
    int i, j;
    int low, mid, high;
    RecordType temp;
    for (i = 1; i < sortArr->cnt; i++)
    {
        temp = sortArr->recordArr[i];
        low = 0;
        high = i - 1; 
        while (low<=high)
        {
            mid = (low + high) / 2;
            if (temp.key < sortArr->recordArr[mid].key)
                high = mid - 1;
            else
                low = mid + 1;
        }
        if (low != 1)
        {
            for (j = i - 1; j > low; j--)
                sortArr->recordArr[j + 1] = sortArr->recordArr[j];
            sortArr->recordArr[low] = temp;
        }
    }
    return sortArr;
}

/*
    直接选择
*/
SortArr* SelectSort(SortArr* sortArr)
{
    int i, j;
    int minPos;
    for (i = 0; i < sortArr->cnt-1; i++)
    {
        minPos = i;
        for (j = i + 1; j < sortArr->cnt; j++)
        {
            if (sortArr->recordArr[j].key < sortArr->recordArr[minPos].key)
                minPos = j;
        }
        if (minPos != i)
            Swap(sortArr, minPos, i);
    }
    return sortArr;
}

/*
    堆排序
*/
void HeapAdjust(SortArr* sortArr, int father, int size)
{
    int lchild;
    int rchild;
    int max;
    while (father<size)
    {
        lchild = father * 2 + 1;//把数组下标当做二叉树形式，如下标为0的结点，左孩子下标是1，右孩子是2。而1的左孩子是3，右孩子是4
        rchild = lchild + 1;
        if (lchild >= size)
        {
            break;//???
        }
        //大根堆要父结点大于左右孩子
        max = lchild;
        if(rchild<size&&sortArr->recordArr[rchild].key>sortArr->recordArr[lchild].key)
        {
            max = rchild;
        } 

        if (sortArr->recordArr[father].key < sortArr->recordArr[max].key)
        {
            Swap(sortArr, father, max);
            father = max;
        }
        else
        {
            break;
        }
    }

}
void HeapSort(SortArr* sortArr, int size)
{
    int i;
    for (i = size / 2 - 1; i >= 0; i--)
    {
        HeapAdjust(sortArr, i, size);
    }
    for (i = size - 1; i >= 1; i--)
    {
        cout<<sortArr->recordArr[0].key<<"  ";
        Swap(sortArr, 0, i);
        HeapAdjust(sortArr, 0, i);
    }
}

/*
    冒泡排序
*/
SortArr* BubbleSort(SortArr* sortArr)
{
    int i, j;
    int hasSwap = 0;
    for (i = 1; i < sortArr->cnt; i++)
    {
        hasSwap = 0;
        for (j = 1; j < sortArr->cnt - i + 1; j++)
        {
            if (sortArr->recordArr[j - 1].key > sortArr->recordArr[j].key)
            {
                Swap(sortArr, j, j - 1);
                hasSwap = 1;
            }
        }
        if (!hasSwap)
            break;
    }
    return sortArr;
}

/*
    快速排序
*/
SortArr* QuickSort(SortArr* sortArr, int left, int right)
{
    int i, j;
    KeyType temp;
    if (left >= right)
        return sortArr;
    i = left;
    j = right;
    temp = sortArr->recordArr[i].key;
    while (i!=j)
    {
        while (sortArr->recordArr[j].key >= temp && j > i)
        {
            j--;
        }
        if(i<j)
        {
            sortArr->recordArr[i].key = sortArr->recordArr[j].key;
            i++;
        }
        else
        {
            break;
        }
        while (sortArr->recordArr[i].key<=temp && j>1)
        {
            i++;
        }
        if (i < j)
        {
            sortArr->recordArr[j].key = sortArr->recordArr[i].key;
            j--;
        }
        else
        {
            break;
        }
    }
    sortArr->recordArr[i].key = temp;
    QuickSort(sortArr, left, i - 1);
    QuickSort(sortArr, i + 1, right);
    return sortArr;
}

四、运行结果

 

每天八杯水D
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之集合框架与应用
lishinho的博客
01-05 453
一，总体框架 哈希表那一章节又提到过具体框架，在这里好好整理一下： 图片来源：https://www.cnblogs.com/skywang12345/p/3308498.html  集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：     接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不...
数据结构&算法——Java.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
数据结构与算法·实验四
qq_40395278的博客
10-03 846
1、编程序判断一个字符序列是否是回文，要求采用链式队列和链式堆栈。 2、编程实现中序表达式转换成后序表达式，并把后序表达式的运行结果打印出来。 #include #include #include #define MaxQueueSize 100 #define MaxStackSize 100 typedef char DataType; typedef char ElemTy
数据结构与算法实验-实验四：栈应用(２)
soul_mingling的博客
04-03 603
栈应用（２） 表达式求值是进行数据处理的最基本操作。请编写程序完成一个简单算术表达式的求值。要求如下： 1.运算符包括：+、-、*、-、^(乘方)、括号 2.运算量为数值常量，根据自己的能力可以对运算量做不同的约束，例如1位整数、多位整数、实数等（会有不同的测试用例）； 输入：一行，即表达式，以“=”结束。例如： 5*(8-3)+6/5= 输出：一行，即表达式的值。结果值为整数时输出为整数，如果...
Java语言程序设计 选实验4 常用集合类使用
arveis的博客
11-24 728
Java语言程序设计 选实验4 常用集合类使用
Java选实验四：常用集合类使用
qq_62215764的博客
03-28 665
一、 实验目的 1.掌握常用的集合类，能够较为熟练的查阅Java提供的常见的类，并进行程序设计。 二、实验内容与要求 (1). 编写Java应用程序，根据用户输入的5个日期（每行一个日期），计算相邻两个日期之间间隔的时数，共4个结果（时数）。注：用户输入的日期格式为“××××年××月××日××时”。在报告中附上程序截图、完整的运行结果截图和简要文字说明。（40分） (2).某车站有检查危险品的机器(machine)，如果发现危险品会发出警告。编程Java应用程序来模拟该机器发现危险品时发出警..
数据结构与算法 Python语言描述 ——裘宗燕版
07-05
数据结构与算法 Python语言描述-裘宗燕 高清带目录 详细讲述线性表 、字符串、栈和队列、二叉树和树、图、字典和集合、排序等
算法和数据结构——左程云.zip
最新发布
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
程序员代码面试指南——IT名企算法和数据结构题目最优解.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
数据结构之-----排序算法
hopegrace的博客
07-26 773
算法的稳定性：如果待排序的两个元素Ri,Rj,其对应的关键字keyi=keyj,且在排序前Ri在Rj的前面，如果排序后Ri还在Rj的前面，则称这种排序算法是稳定的，否则称排序算法是不稳定的。 内部排序和外部排序：内部排序是指在排序期间，元素全部存放在内存中的排序。外部排序是指排序期间元素无法全部同时存放在内存中，必须在排序过程中根据要求不断地在内外存之间移动的排序。 1.插入排序 1）插入排...
java选做实验4常用集合类使用
weixin_62431082的博客
11-18 430
2和相加的方法类似，在相乘的方法的参数里面我传进去了一个Matrix类 matrix1作为相加的矩阵，方法内部首先判断两矩阵能否相乘（同样默认类的matrix和传进来的matrix1的矩阵都是合法的），另外在方法内部重新定义了一个Matrix类matrix2用来接收两矩阵相乘的积，对matrix2赋值后就输出提示信息并且调用matrix2的print方法来输出相加后得到的新矩阵。注：用户输入的时间格式为“××××年××月××日××时××分××秒”，输出的时间格式为“××日××时××分××秒”。
常用集合类使用方法
a631278993的博客
09-29 205
转载请注明原文地址：http://www.cnblogs.com/ygj0930/p/5920991.html 在编程中，我们经常需要考虑数据的储存方法——到底用什么东西去安置这些数据呢？ 一般，少的可以用数组，但是数组只能存放规定大小、同一类型的数据；这样的话，不定长的可以试试链表，但是链表检索起来需要从头到尾，一旦数据多了会很慢。如果需要为一个对象存放多个不同类型的数...
数据结构期末报告 实验四
zhangnuanxin520的博客
05-20 838
1.对下列数据表，分别采用二分查找算法实现查找，给出查找过程依次所比较的元素（的下标），并以二分查找的判定树来解释。 实验测试数据： 第一组数据： 数据表为 (1,2,3,4,6,7,8,9,10,11,12,13,17,18,19,20,24,25,26,30,35,40,45,50,100) 查找的元素分别为： 2，8，20, 30，50，5，15，33，110 第二组数据：自拟 #include<iostream> #include<cmath> #include
数据结构-排序算法集合（包含所有排序）
turn__back的博客
03-09 185
1.比较排序：     1）.插入排序（直接插入排序、希尔排序）     2）.选择排序（选择排序、堆排序）     3）.交换排序（冒泡排序、快速排序）     4）.归并排序（归并排序） 2.非比较排序：     1）.计数排序     2）.基数排序（LSD、MSD）
练习赛14.1,。集合的划分
u012761443的专栏
12-02 782
集合的划分 Time Limit : 3000/1000ms (Java/Other) Memory Limit : 65535/32768K (Java/Other) Total Submission(s) : 19 Accepted Submission(s) : 7 Font: Times New Roman | Verdana | Georgia Font Size: ← →
数据结构实验之排序算法及其应用【附代码&实验成果】
米莱虾
04-14 4665
一、实验目的 1）理解并掌握各种常用内部排序算法的基本概念、思想和方法。掌握常用内部排序算法流程。 2）掌握常用的排序方法，深刻理解排序的定义和各种排序方法的特点。 3）通过实验观察不同方法的不同之处，记录并分析各种排序方法的结果。 二、实验环境 1）自备计算机，windows操作系统以及相关的编译器（如Devc++）。 三、实验要求 1）理解及熟练运用直接插入排序、快速排序、堆排序和归并排序、哈希排序等内部排序算法。 2）通过计数统计各算法的关键字比较次数和关键字移动次数。 3）分析算法的时间复杂度、空间
数据结构、集合框架整合
Muyu_Z的博客
05-31 1178
一.数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。1.集合：数据结构中的元素之间除了“同属一个集合”的相互关系2.线性结构：数据结构中的元素存在一对一的相互关系3.树形结构：数据结构中的元素存在一对多的相互关系4.图形结构：数据结构中的元素存在多对多的相互关系常用的数据结构：数组、栈、队列、链表、树、图、堆、散列表二.各类数据结构1.数组数组：将...
计算机科学中的集合论：广泛使用的属于关系
11-20 474
简单概括起来就是： 对象 ∈ 类 关系实例 ∈ 关系模式 关系模式 ∈ 设计范式 字符串 ∈ 正则表达式模式 元组 ∈ 表 算法问题实例 ∈ 算法问题 ... ... 用集合论的观点思考计算机科学的许多问题，可以避免疑惑。 转载于:https://www.cnblogs.com/xinchrome/p/4981121.html...
Java第四周常用类与集合框架上机实验四学会包装类常用方法使用
java技术专家全栈成长之路
09-07 703
package test9_7; /*** * 实验任务 包装类之间转换 包装类对象转换为对应的基本数据类型变量 实验要求 定义一个String str = "1234"; 将其转换为double类型并输出 使用Double类创建double类型变量db并赋值1234 比较两者是否一致 * @author HP-Develope
头歌Java算法与数据结构测试——插入排序
05-29
插入排序是一种简单直观的排序算法，它的基本思想是将一个数据序列分为已排序和未排序两部分，每次从未排序的部分选取一个元素插入到已排序的部分中，使得插入后仍保持有序。以下是插入排序的Java代码实现： ``` ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值