简单选择排序（Simple Select Sort）

最新推荐文章于 2021-04-04 00:24:53 发布
原创 最新推荐文章于 2021-04-04 00:24:53 发布 · 720 阅读 · 1 ·
CC 4.0 BY-SA版权
本文为博主原创文章，未经博主允许不得转载。
文章标签：

#排序算法 #简单选择排序

本文详细介绍简单选择排序算法的原理及实现过程，通过示例代码展示了如何在C语言中实现该算法，并提供了递归版本的选择排序。

简单选择排序（Simple Select Sort）


简单选择排序是入门级别的排序算法，算法易懂，实现简单。

假设现在有一个待排序序列，长度是n，要求从小到大排序。

简单选择排序将要进行n-1次外循环（不需要进行n次，因为n个元素中已经有n-1个是确定了的，最后一个当然也是确定了的），在每次外循环中选择一个最小的/最大的放置在当前选择范围的最左边/最右边。

在第0次外循环时，内循环选择位置0至位置n-1的（共n个数字）最小的数字放置在位置0处；
在第1次外循环时，内循环选择位置1至位置n-1的（共n-1个数字）最小的数字放置在位置1处；
……

#include <stdio.h>
#include <stdlib.h>

/************************************************
 * 函数名称：print_array
 * 参数列表：1.int *parray:一个int类型指针，指向一个数组首地址
 *           2.int n：一个int类型变量，指明数组大小
 * 函数描述：输出数组中每个元素
 * 返回值  ：void
 * Author  ：test1280
 * History ：2017/04/14
 * *********************************************/
void print_array(int *parray, int n)
{
    int i;
    for (i=0; i<n; i++)
    {   
        printf("%d ", parray[i]);   
    }   
    printf("\n");
}

/************************************************
 * 函数名称：selectSort
 * 参数列表：1.int *parray:一个int类型指针，指向一个数组首地址
 *           2.int n：一个int类型变量，指明数组大小
 * 函数描述：简单选择排序
 * 返回值  ：void
 * Author  ：test1280
 * History ：2017/04/15
 * *********************************************/
void selectSort(int *parray, int n)
{
    int i, j;
    int minIdx;
    int tmp;
    for (i=0; i<n-1; i++)
    {
        minIdx = i;

        printf("----------------------------------\n");
        printf("before swap:minIdx=%d, i=%d\narray:\n", minIdx, i);
        print_array(parray, 8);

        for (j=i+1; j<n; j++)
        {
            if (parray[minIdx]>parray[j])
            {
                minIdx = j;
            }
        }
        if (i!=minIdx)
        {
            tmp = parray[i];
            parray[i] = parray[minIdx];
            parray[minIdx] = tmp;
        }
        printf("after swap:minIdx=%d, i=%d\narray:\n", minIdx, i);
        print_array(parray, 8);
        printf("----------------------------------\n\n");
    }
}

int main()
{
    int array[8] = {49, 38, 65, 97, 76, 13, 27, 49};
    print_array(array, 8);
    selectSort(array, 8);
    print_array(array, 8);
    return 0;
}

输出如下：

[test1280@localhost sort]$ ./main 
49 38 65 97 76 13 27 49 
----------------------------------
before swap:minIdx=0, i=0
array:
49 38 65 97 76 13 27 49 
after swap:minIdx=5, i=0
array:
13 38 65 97 76 49 27 49 
----------------------------------

----------------------------------
before swap:minIdx=1, i=1
array:
13 38 65 97 76 49 27 49 
after swap:minIdx=6, i=1
array:
13 27 65 97 76 49 38 49 
----------------------------------

----------------------------------
before swap:minIdx=2, i=2
array:
13 27 65 97 76 49 38 49 
after swap:minIdx=6, i=2
array:
13 27 38 97 76 49 65 49 
----------------------------------

----------------------------------
before swap:minIdx=3, i=3
array:
13 27 38 97 76 49 65 49 
after swap:minIdx=5, i=3
array:
13 27 38 49 76 97 65 49 
----------------------------------

----------------------------------
before swap:minIdx=4, i=4
array:
13 27 38 49 76 97 65 49 
after swap:minIdx=7, i=4
array:
13 27 38 49 49 97 65 76 
----------------------------------

----------------------------------
before swap:minIdx=5, i=5
array:
13 27 38 49 49 97 65 76 
after swap:minIdx=6, i=5
array:
13 27 38 49 49 65 97 76 
----------------------------------

----------------------------------
before swap:minIdx=6, i=6
array:
13 27 38 49 49 65 97 76 
after swap:minIdx=7, i=6
array:
13 27 38 49 49 65 76 97 
----------------------------------

13 27 38 49 49 65 76 97 
[test1280@localhost sort]$


示意图：

49 38 65 97 76 13 27 49 中最小的是13，那么把13的下标记录下来，到最后和最初的下标值比较，如果不相等，那么就交换两个元素。

注意下，对比冒泡排序，当待排序序列中每个对象比较复杂的时候，显然以简单选择排序，可以减少很多不必要的构造函数的调用，效率会高很多。

交换后为：

13 38 65 97 76 49 27 49

这样，13一定是最后排好序中最小的那个，位置已经确定。

现在继续从位置1处到位置n-1处的n-1个数字排序：

最小的是27，

13 38 65 97 76 49 27 49

最后发现初始minIdx是1，最小值的下标是6，进行交换：

13 27 65 97 76 49 38 49

以此类推。

也可以将大数放置在右侧，如下：

#include <stdio.h>
#include <stdlib.h>

/************************************************
 * 函数名称：print_array
 * 参数列表：1.int *parray:一个int类型指针，指向一个数组首地址
 *           2.int n：一个int类型变量，指明数组大小
 * 函数描述：输出数组中每个元素
 * 返回值  ：void
 * Author  ：test1280
 * History ：2017/04/14
 * *********************************************/
void print_array(int *parray, int n)
{
    int i;
    for (i=0; i<n; i++)
    {
        printf("%d ", parray[i]);
    }
    printf("\n");
}

/************************************************
 * 函数名称：selectSort
 * 参数列表：1.int *parray:一个int类型指针，指向一个数组首地址
 *           2.int n：一个int类型变量，指明数组大小
 * 函数描述：简单选择排序
 * 返回值  ：void
 * Author  ：test1280
 * History ：2017/04/15
 * *********************************************/
void selectSort(int *parray, int n)
{
    int i, j;
    int maxIdx;
    int tmp;
    for (i=n-1; i>0; i--)
    {
        maxIdx = i;

        printf("----------------------------------\n");
        printf("before swap:maxIdx=%d, i=%d\narray:\n", maxIdx, i);
        print_array(parray, 8);

        for (j=0; j<i; j++)
        {
            if (parray[maxIdx]<parray[j])
            {
                maxIdx = j;
            }
        }
        if (i!=maxIdx)
        {
            tmp = parray[i];
            parray[i] = parray[maxIdx];
            parray[maxIdx] = tmp;
        }
        printf("after swap:maxIdx=%d, i=%d\narray:\n", maxIdx, i);
        print_array(parray, 8);
        printf("----------------------------------\n\n");
    }
}

int main()
{
    int array[8] = {49, 38, 65, 97, 76, 13, 27, 49};
    print_array(array, 8);
    selectSort(array, 8);
    print_array(array, 8);
    return 0;
}

输出如下：

[test1280@localhost sort]$ ./main
49 38 65 97 76 13 27 49 
----------------------------------
before swap:maxIdx=7, i=7
array:
49 38 65 97 76 13 27 49 
after swap:maxIdx=3, i=7
array:
49 38 65 49 76 13 27 97 
----------------------------------

----------------------------------
before swap:maxIdx=6, i=6
array:
49 38 65 49 76 13 27 97 
after swap:maxIdx=4, i=6
array:
49 38 65 49 27 13 76 97 
----------------------------------

----------------------------------
before swap:maxIdx=5, i=5
array:
49 38 65 49 27 13 76 97 
after swap:maxIdx=2, i=5
array:
49 38 13 49 27 65 76 97 
----------------------------------

----------------------------------
before swap:maxIdx=4, i=4
array:
49 38 13 49 27 65 76 97 
after swap:maxIdx=0, i=4
array:
27 38 13 49 49 65 76 97 
----------------------------------

----------------------------------
before swap:maxIdx=3, i=3
array:
27 38 13 49 49 65 76 97 
after swap:maxIdx=3, i=3
array:
27 38 13 49 49 65 76 97 
----------------------------------

----------------------------------
before swap:maxIdx=2, i=2
array:
27 38 13 49 49 65 76 97 
after swap:maxIdx=1, i=2
array:
27 13 38 49 49 65 76 97 
----------------------------------

----------------------------------
before swap:maxIdx=1, i=1
array:
27 13 38 49 49 65 76 97 
after swap:maxIdx=0, i=1
array:
13 27 38 49 49 65 76 97 
----------------------------------

13 27 38 49 49 65 76 97 
[test1280@localhost sort]$

区别不是很大，不再赘述。

忽然想起来昨天的快速排序，是分治+挖坑填坑来做的，那能不能用分治到这里的简单选择排序呢？

递归版简单选择排序：

#include <stdio.h>
#include <stdlib.h>

/************************************************
 * 函数名称：print_array
 * 参数列表：1.int *parray:一个int类型指针，指向一个数组首地址
 *           2.int n：一个int类型变量，指明数组大小
 * 函数描述：输出数组中每个元素
 * 返回值  ：void
 * Author  ：test1280
 * History ：2017/04/14
 * *********************************************/
void print_array(int *parray, int n)
{
    int i;
    for (i=0; i<n; i++)
    {   
        printf("%d ", parray[i]);   
    }   
    printf("\n");
}

/************************************************
 * 函数名称：selectSort
 * 参数列表：1.int *parray:一个int类型指针，指向一个数组首地址
 *           2.int n：一个int类型变量，指明数组大小
 * 函数描述：简单选择排序
 * 返回值  ：void
 * Author  ：test1280
 * History ：2017/04/15
 * *********************************************/
void selectSort(int *parray, int n)
{
    int i;
    int maxIdx = n-1;
    for (i=0; i<n-1; i++)
    {
        if (parray[i]>parray[maxIdx])
        {
            maxIdx = i;
        }
    }
    if (maxIdx != (n-1))
    {
        int tmp = parray[n-1];
        parray[n-1] = parray[maxIdx];
        parray[maxIdx] = tmp;
    }
    if (n==2)
        return;
    selectSort(parray, n-1);
}

int main()
{
    int array[8] = {49, 38, 65, 97, 76, 13, 27, 49};
    print_array(array, 8);
    selectSort(array, 8);
    print_array(array, 8);
    return 0;
}

一开始写的时候直接错了……原来忘记了递归结束的条件。。。切记加上递归结束的条件。

当待排序数组为2时，排序完毕后已经不需要再排序了。

Over。


排序算法之Simple Sorts
Ran's Hacking Zone
03-08 574
0. 前言 Simple Sorts包括两种排序算法： 选择排序(Selection sort) 和 插入排序（Insertion sort)。 代码基于C++11编写，编译器使用g++4.9.2 版本。 测试数据集使用导论中提供的程序生成。 测试使用导论中提供的测试框架，加入相关的头文件，并进行相关算法调用(具体可参见插入排序中的测试源代码)。 1. 插入排序(Insertion sort)1.1
SimpleSort：文本文件的简单Python排序。 主要与Git一起练习
02-20
SimpleSort：文本文件的简单Python排序。 主要与Git一起练习
jquery.simpleselect:一个非常简单易用但非常强大的选择实现，带有方法和事件
07-07
#jQuery.SimpleSelect v. 0.3.2 11-12-2014 您是否遇到过这样的情况，当您迫切需要以编程方式打开，但您不能？ 或者接下来，您需要以某种特定方式设置列表项的样式，但是到目前为止您尝试过的所有插件（并且您现在已经测试了很多）都不允许这样做，因为，好吧，硬编码样式规则？ 或者，也许您只需要一个搜索和过滤器，附加到您的选择中，因为它是巨大的？ 或者您需要不会表现不佳的自动完成功能（因为，老实说，他们中的大多数都这样做）？ 而且您需要尽可能简单的所有这些 - 每个人都需要。 好吧，我曾经是你 - 我不得不编写这个插件。 欢迎，宾至如归！ ##LICENSE 版权所有 2014 UndeadBane ######根据 MIT 许可证获得许可，http://www.opensource.org/licenses/mit-license.php
简单选择排序SimpleSelectSort
weixin_34250434的博客
01-04 168
冒泡排序：在每一次比较的时候，如果发现相邻两数的次序不对，都会马上就把两数进行对调。 选择排序：则在比较过程中（内循环里面）并不进行对调，而是先记录下最小（大）数的下标，在一次扫描完成后再进行对调。 1、算法思想 在要排序的一组数中，选出最小（或者最大）的一个数与第 i（i=0）个位置的数交换；然后在剩下的数当中再找最...
<排序算法> 简单选择排序SelectSort
avv72052的博客
07-20 353
1.核心思想：每一趟在n-i+1中选取关键字最小的记录作为有序序列的第i个记录。简单排序最大的特点就是交换移动次数相当少，这样就节约了时间。通过分析时间复杂度也就是说如果从小到大进行排序，找最大的往后放或者找最小的往前放。简单选择排序没有优化，对数组没有要求。有序或者无序都没有差别。2.代码实现： 1 #include<iostream> 2 using name...
简单选择排序(Simple Selection Sort)
nidongla的博客
04-04 567
介绍： 　　简单选择排序的工作方式突出"选择"二字，每次从待排序数据中选择符合条件的元素放在已排序元素末尾。对于少量元素的排序，简单选择排序是一个有效的算法。 思想： 　　第一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小(大)元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。 性能分析： 　　时间复杂度：O(N^2) 　　空间复杂度：O(1) 　　稳定性：不稳定 代码实现： // Java代码 class .
php数据结构 算法(PHP描述) 简单选择排序 simple selection sort
12-19
在提供的例子中，最后展示了如何调用 `sort_simple_selection()` 函数对一个具体的数组进行排序。 简单选择排序的时间复杂度为O(n^2)，其中n是数组的长度。由于其效率较低，对于大数据集并不适用。但在理解排序算法...
PHP排序算法之简单选择排序(Simple Selection Sort)实例分析
10-18
在PHP中，我们可以编写如下的`SelectSort`函数来实现简单选择排序： ```php function SelectSort(array &$arr) { $count = count($arr); for ($i = 0; $i $count - 1; $i++) { $min = $i; for ($j = $i + 1; $j...
PHP简单选择排序（Simple Selection Sort）算法学习
01-20
本文实例为大家分享了PHP简单选择排序的具体代码，供大家参考，具体内容如下 基本思想： 通过 n – i 次关键字间的比较，从 n – i + 1 个记录中选出关键字最小的记录，并和第 i （1 <...function SelectSort(array
SimpleSelectSort(简单选择排序)
Yang
05-22 469
//平均时间复杂度O(n^2) //空间复杂度O(1) //最优时间复杂度O(n^2) //最坏时间复杂度O(n^2) //不稳定 #include <stdio.h>void swap(int *a, int *b){ int temp = *a; *a = *b; *b = temp; }void SimpleSelectSort(int a[], int n){
Simple Selection Sort（简单选择排序）
程序人生
09-29 514
算法思想 一个拥有若干元素的序列，重复遍历序列，将其中最大（或最小）的元素找出来，按顺序放到指定位置，再将次大（或次小）元素找出来放到指定位置，直到所有元素排完。 实现步骤 以从小到大为例： 1.遍历序列，找出最小元素 2.将找出的最小元素与第一个元素互换位置 3.从第二个元素开始遍历，重复步骤1和2 源码 C/C++ void SimpleSe...
简单选择排序，selectSort
xiao酱油的博客
02-17 471
// 简单选择排序，selectSort // O(n^2)，不稳定 #include &lt;cstdio&gt; void selectSort(int *arr, int length) { for(int i = 0; i &lt; length-1; i++) { int index = i; for(int j = i+1; j ...
简单选择排序SelectSort
weixin_30527143的博客
09-29 296
package com.cc.dataconsttuct.com; /*** * 简单选择排序：令A[0,n-1]有n个数据元素的数组，将数组A排列为一个非降序的有序数组； * 算法：首先在n个元素中找到最小元素，将其放在A[0]中，然后将剩下的n-1个元素中找到最小的放在A[1]中，这个过程不断进行下去。。。。 * @author caocx * */public class Sel...
简单选择排序（Simple Selection Sort）
博客
08-07 273
public static void paixu(int a[],int n){ for (int i=0; i<n; i++){ for (int j=i+1; j<n; j++){ if(a[i]>a[j]){ int t = a[i]; ...
选择排序—简单选择排序（Simple Selection Sort）
wgiyq的博客
01-09 1979
选择排序—简单选择排序（Simple Selection Sort） 基本思想 排序流程 算法实现 简单选择排序 改进二元选择排序 算法分析
排序之简单选择排序(Simple Selection Sort)
dangzhileiqaz的专栏
12-08 642
简单选择排序(Simple Selection Sort)基本思想：     首先在待排序序列中选择最小的元素与序列的第一个位置元素交换，然后在剩余序列中再找出最小的元素与第二个     位置元素交换。以此类推，直至第n-1个元素与第n个元素比较交换为止;(也可以理解为依次从无序区中选择最小的     元素插入到有序区的末尾位置) 算法操作: 设数组data[0......n-1]:
选择排序SelectSort
xiaoshiguang3的博客
06-21 387
选择排序SelectSort 1.基本介绍 选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到排序的目的。 选择排序（select sorting）也是一种简单的排序方法。它的基本思想是：第一次从arr[0]arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]arr[n-1]中选取最小值，与arr[1]交换，第三次从arr[2]arr[n-1]中选取最小值，与arr[2]交换，…，第i次从arr[i-1]arr[n-1]中选取最小值，与arr
简单选择排序算法(Simple Selection Sort)
fly_zxy的专栏
11-08 468
简单选择排序算法(Simple Selection Sort) 此排序算法是将元素与其它元素依次比较，如果反序，则记录最小值或最大值对于的索引(index)，等第二层for循环完毕后在根据最大值或最小值的索引所指向的值和i(第一层for循环的变量)指向的值进行互换位置。 此算法最大的特点是减少了排序元素交互位置的操作，提高了效率。 java代码实现 /** * 简单选择排序算法 ...
简单选择排序是稳定的
最新发布
08-23
<think>首先，用户的问题是基于之前的对话和引用内容，确认简单选择排序是否为稳定排序算法。用户提供了多个引用，我需要参考这些引用来回答问题。 回顾引用内容： - 引用[1]：明确指出选择排序是不稳定的排序算法，因为相等元素的相对位置可能改变。 - 引用[2]：举例证明选择排序不稳定，例如序列5 8 5 2 9，第一趟选择后，第一个5和2交换，导致两个5的相对顺序改变。 - 引用[3]：确认选择排序不是稳定排序算法。 - 引用[4]：讨论简单选择排序的稳定性，指出它是不稳定的，因为交换可能改变相等元素的顺序。 - 引用[5]：提供简单选择排序的代码实现，但没有直接讨论稳定性。 从这些引用中，可以总结出：简单选择排序是不稳定排序算法。 我的回答需要： - 清晰、结构良好。 - 使用中文。 - 包含数学表达式时，用$...$或$$...$$格式。 - 在引用内容后自然地添加引用标识，如[^1]。 - 最后生成相关问题。 回答结构： 1. **定义稳定排序算法**：简要解释什么是稳定排序算法。 2. **解释简单选择排序的工作原理**：描述算法步骤。 3. **分析稳定性**：说明为什么简单选择排序不稳定，并用例子证明。 4. **结论**：确认它是不稳定排序算法。 5. **代码示例（可选）**：如果有助于理解，可以展示代码。 6. **生成相关问题**：基于主题，生成3个相关问题。 生成相关问题： 1. 简单选择排序的时间复杂度是多少？ 2. 如何修改简单选择排序使其成为稳定排序算法？ 3. 稳定排序算法有哪些实际应用场景？ 确保回答真实可靠，基于引用内容。</think>### 简单选择排序是否为稳定排序算法？ 简单选择排序（Simple Selection Sort）是一种基于比较的排序算法，其核心思想是**重复从未排序部分选择最小（或最大）元素，与当前未排序序列的起始位置交换**。根据算法原理和示例分析，**简单选择排序不是稳定排序算法**。下面逐步解释原因。 --- #### 1. **稳定排序算法的定义** 在排序算法中，稳定性是指：如果序列中存在多个具有相同关键字的元素（例如相同的值），排序后这些元素的相对顺序（即原序列中的先后位置）保持不变[^4]。例如： - 原序列：$[ (3, \text{A}), (2, \text{B}), (3, \text{C}) ]$（其中数字为关键字，字母为辅助信息）。 - 稳定排序后：$[ (2, \text{B}), (3, \text{A}), (3, \text{C}) ]$（两个关键字为3的元素顺序未变）。 - 不稳定排序后：$[ (2, \text{B}), (3, \text{C}), (3, \text{A}) ]$（两个3的相对顺序改变）。 稳定性在某些场景（如多关键字排序）中至关重要[^4]。 --- #### 2. **简单选择排序的工作原理** 算法步骤如下（假设升序排序）： - **步骤1**：从数组第1个位置开始，扫描未排序部分（$i$ 到 $n$），找到最小元素的下标 $k$。 - **步骤2**：交换第 $i$ 个元素与最小元素（下标 $k$）。 - **步骤3**：忽略已排序部分，重复步骤1-2，直到所有元素有序。 算法的时间复杂度为 $O(n^2)$，空间复杂度为 $O(1)$[^3][^5]。 --- #### 3. **为什么简单选择排序不稳定？** 不稳定性的根源在于**交换操作可能破坏相等元素的相对顺序**。具体分析： - **问题点**：当序列中存在多个相等元素时，算法在查找最小元素时可能选择任意一个，交换时可能将后方的相等元素移动到前方相等元素之前[^1][^2]。 - **示例证明**：考虑序列 $[5_1, 8, 5_2, 2, 9]$（下标用于区分相同元素）。 - 第一趟：找到最小元素是 $2$（位置4），与第1个元素 $5_1$ 交换。 - 交换后序列：$[2, 8, 5_2, 5_1, 9]$。 - 结果：$5_1$ 和 $5_2$ 的相对顺序改变（原序列 $5_1$ 在 $5_2$ 前，排序后 $5_2$ 在 $5_1$ 前）[^2][^4]。 这个例子说明，简单选择排序的交换操作不保证相等元素的稳定性。 --- #### 4. **代码实现与稳定性分析** 参考引用[^5]的代码，交换逻辑直接导致不稳定性： ```c // 获取未排序部分最小元素的索引 int GetMin(int* ar, int left, int right) { int min = ar[left]; int index = left; for (int i = left + 1; i < right; i++) { if (ar[i] < min) { // 只比较值，不处理相等元素顺序 min = ar[i]; index = i; } } return index; } // 简单选择排序主体 void SelectSort(int* ar, int left, int right) { for (int i = left; i < right - 1; i++) { int index = GetMin(ar, i, right); if (index != i) { Swap(&ar[i], &ar[index]); // 交换操作可能破坏稳定性 } } } ``` - **关键问题**：`GetMin` 函数在遇到相等元素时，会优先选择索引更小的元素（因为 `if (ar[i] < min)` 只在严格小于时更新），但交换时可能将后方的相等元素移到前面[^2][^4]。 --- #### 5. **结论** 简单选择排序**不是稳定排序算法**，因为其交换机制无法保证相等元素的相对顺序不变。如果需要稳定排序，可改用以下算法： - **稳定排序替代方案**：如插入排序（$O(n^2)$）或归并排序（$O(n \log n)$）[^1]。 --- ### 相关问题 1. 简单选择排序的时间复杂度如何分析？为什么总是 $O(n^2)$？ 2. 如何修改简单选择排序的代码使其成为稳定排序算法？ 3. 在实际应用中，哪些场景必须使用稳定排序算法？
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值