240505-基础算法-排序【未完待续】

已于 2024-05-05 15:58:29 修改
阅读量143 收藏
点赞数 1
分类专栏： 算法 文章标签： 快速排序 排序算法
于 2020-07-11 16:57:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44965626/article/details/107286722
版权

本文主要内容：

  1. 插入排序
  2. 选择排序
  3. 冒泡排序
  4. 快速排序
  5. 归并排序
  6. 堆排序
  7. 基数排序
  8. 希尔排序
  9. 计数排序
  10. 桶排序

本文所有代码均使用C#编写
240505天气：小雨转多云

算法总结图1

在这里插入图片描述

1 插入排序2

插入排序（Insertion Sort）：将序列分为已排序和未排序两部分，从未排序的部分选择元素插入到已排序的部分中，直到所有元素都被插入到已排序的部分。时间复杂度O(n2)。

void InsertSort(int[] nums)
{
    int n = nums.Length;
    for(int i = 1; i < n; i++)
    {
        int t = nums[i];
        int j = i;
        while(j > 0 && nums[j - 1] > t)
        {
            nums[j] = nums[j - 1];
            j--;
        }
        nums[j] = t;
    }
}

2 选择排序

从序列中选择最小的元素，放到序列的起始位置，再从剩余元素中选择最小的元素放到已排序序列的末尾。时间复杂度O(n2)。

void SelectSort(int[] nums)
{
    int n = nums.Length;
    for(int i = 0; i < n - 1; i++)
    {
        int minIndex = i;
        for(int j = i + 1; j < n; j++)
            if(nums[j] < nums[minIndex])
                minIndex = j;
        (nums[minIndex], nums[i]) = (nums[i], nums[minIndex]);
    }
}

3 冒泡排序

相邻元素比较，逐步将最大元素“冒泡”到序列最后。时间复杂度O(n^2)。

void BubbleSort(int[] nums)
{
    int n = nums.Length;
    for(int i = 0; i < n - 1; i++)
        for(int j = 0; j < n - 1 - i; j++)
            if(nums[j] > nums[j + 1])
                (nums[j], nums[j + 1]) = (nums[j + 1], nums[j]);
}

4 快速排序

1.基于分治的思想
2.先在递归区间内找到一个元素作为枢轴（pivot），将该区间处理成所有数小于等于pivot和所有数大于等于pivot的两个子区间
3.继续递归处理两个子区间，直到子区间长度小于等于1时结束递归

void QuickSort(int[] nums, int l, int r)
{
    if(l >= r)return;
    int i = l, j = r;
    int pivot = nums[l];
    while(i < j)
    {
        while(i < j && nums[j] >= pivot)j--;//前
        while(i < j && nums[i] <= pivot)i++;//后
        if(i < j)
            (nums[i], nums[j]) = (nums[j], nums[i]);
    }
    nums[l] = nums[i];
    nums[i] = pivot;
    QuickSort(nums, l, i - 1);
    QuickSort(nums, i + 1, r);
}

5 归并排序

1.基于分治的思想
2.将数组区间一分为而，先递归排序左子区间，再递归排序右子区间
3.将两个已经排好序的子区间归并成一个有序数组，然后结束递归

void MergeSort(int[] nums, int left, int right)
{
    if(left >= right)
        return;
    int midIndex = left + right >> 1;
    MergeSort(nums, left, midIndex);
    MergeSort(nums, midIndex + 1, right);
    int[] tempArr = new int[nums.Length];
    for(int i = 0; i < nums.Length; i++)
        tempArr[i] = nums[i];
    int p = left, q = midIndex + 1, r = left;
    while(p <= midIndex && q <= right)
    {
        if(tempArr[p] <= tempArr[q])
            nums[r++] = tempArr[p++];
        else
            nums[r++] = tempArr[q++];
    }
    while(p <= midIndex)
        nums[r++] = tempArr[p++];
    while(q <= right)
        nums[r++] = tempArr[q++];
}

6 堆排序

将数组存入小根堆中，第1次取出的堆顶元素就是最小的，然后移除堆顶元素，第2次取出的堆顶元素就是第2小的，以此类推

void HeapSort(int[] nums)
{
    int n = nums.Length;
    int[] myHeap = new int[n];
    int myHeapSize = myHeap.Length;
    for(int i = 0; i < n; i++)
        myHeap[i] = nums[i];
    for(int i = n / 2; i >= 0; i--)
        Down(myHeap, i, myHeapSize);
    for(int i = 0; i < n; i++)
    {
        nums[i] = myHeap[0];
        (myHeap[0], myHeap[myHeapSize - 1]) = (myHeap[myHeapSize - 1], myHeap[0]);
        myHeapSize--;
        Down(myHeap, 0, myHeapSize);
    }

}
//下沉
void Down(int[] myHeap, int curIndex, int myHeapSize)
{
    int minIndex = curIndex;
    int leftSon = curIndex * 2, rightSon = curIndex * 2 + 1;
    if(leftSon < myHeapSize && myHeap[leftSon] < myHeap[minIndex])
        minIndex = leftSon;
    if(rightSon < myHeapSize && myHeap[rightSon] < myHeap[minIndex])
        minIndex = rightSon;
    if(minIndex != curIndex)
    {
        (myHeap[curIndex], myHeap[minIndex]) = (myHeap[minIndex], myHeap[curIndex]);
        Down(myHeap, minIndex, myHeapSize);
    }
}

7 基数排序

将待排序的整数拆分成多个数字位上的值，然后从最低位到最高位依次对每个数字位上的值进行排序。

在这里插入图片描述
练习题：164. 最大间距

void RadixSort(int[] nums) 
 {
    int n = nums.Length;
    int exp = 1;
    int[] numCnt = new int[10];
    int[,] tempSet = new int[10,n];
    for(int i = 0; i < 10; i++){
        for(int j = 0; j < n; j++){
            int k = (nums[j] / exp) % 10;
            tempSet[k,numCnt[k]] = nums[j];
            numCnt[k]++;
        }
        for(int j = 0, t = 0; j < 10; j++){
            
            for(int k = 0; k < numCnt[j]; k++){
                nums[t++] = tempSet[j,k];
            }
            numCnt[j] = 0;
        }
        exp *= 10;
    }
}

8 希尔排序

参考：十大经典排序算法最强总结（含JAVA代码实现）

对插入排序的一种优化。将数组分为gap个组，组内进行插入排序，然后缩小分组，继续进行插入排序，最后整个数组分为1个组，进行插入排序时移动元素的次数会减少很多

void ShellSort(int[] nums)
{
    int n = nums.Length;
    int gap = n / 2;
    while(gap > 0)
    {
        for(int i = gap; i < n; i++)
        {
            int temp = nums[i];
            int j = i;
            while(j - gap >= 0 && nums[j - gap] > temp)
            {
                nums[j] = nums[j - gap];
                j -= gap;
            }
            nums[j] = temp;
        }
        gap /= 2;
    }
}

9 计数排序

将原数组中每个数nums[i]出现的次数保存到另一个数组中count[]，数组下标就为nums[i]，数组值为nums[i]出现的次数，然后根据count[]来对原数组nums[]进行排序

void CountingSort(int[] nums)
{
    int n = nums.Length;
    if(n < 1)
        return;
    int minNum = nums[0];
    int maxNum = nums[0];
    foreach(int num in nums)
    {
        minNum = Math.Min(minNum, num);
        maxNum = Math.Max(maxNum, num);
    }
    int range = maxNum - minNum + 1;
    int[] count = new int[range];
    foreach(int num in nums)
        count[num - minNum]++;
    for(int i = 1; i < range; i++)
        count[i] += count[i - 1];
    int[] temp = new int[n];
    foreach(int num in nums)
    {
        int index = count[num - minNum] - 1;
        temp[index] = num;
        count[num - minNum]--;
    }
    Array.Copy(temp, nums, nums.Length);
}

10 桶排序

桶排序可以看做时计数排序的一种优化，计数排序可以看做单个元素作为1个桶的桶排序，桶排序一般以区间作为桶的宽度（即每个桶能装的元素种类数）。
桶排序的原理是将原数组分为若干段，每一段元素丢到一个桶中，再对每个桶分别排序，最后将各个桶中的元素从头到尾连起来

void BucketSort(int[] nums)
{
    int n = nums.Length;
    if(n < 1)
        return;
    int minNum = nums[0];
    int maxNum = nums[0];
    for(int i = 1; i < n; i++)
    {
        minNum = Math.Min(minNum, nums[i]);
        maxNum = Math.Max(maxNum, nums[i]);
    }
    int range = maxNum - minNum;
    int bucketCount = range / n + 1;
    List<List<int>> buckets = new List<List<int>>(bucketCount);

    for(int i = 0; i < bucketCount; i++)
        buckets.Add(new List<int>());
    
    foreach(int num in nums)
    {
        int bucketIndex = (num - minNum) / n;
        buckets[bucketIndex].Add(num);
    }

    buckets.ForEach((List<int> list)=> list.Sort());

    int numsIndex = 0;
    for(int i = 0; i < bucketCount; i++)
    {
        List<int> bucket = buckets[i];
        bucket.ForEach((int num) => nums[numsIndex++] = num);
    }
}

10个排序算法完整代码（C#）

using System.Net;

int[] nums = {125, 16, 214, 111, 2, 30};


void InsertSort(int[] nums)
{
    int n = nums.Length;
    for(int i = 1; i < n; i++)
    {
        int t = nums[i];
        int j = i;
        while(j > 0 && nums[j - 1] > t)
        {
            nums[j] = nums[j - 1];
            j--;
        }
        nums[j] = t;
    }
}

void SelectSort(int[] nums)
{
    int n = nums.Length;
    for(int i = 0; i < n - 1; i++)
    {
        int minIndex = i;
        for(int j = i + 1; j < n; j++)
            if(nums[j] < nums[minIndex])
                minIndex = j;
        (nums[minIndex], nums[i]) = (nums[i], nums[minIndex]);
    }
}

void BubbleSort(int[] nums)
{
    int n = nums.Length;
    for(int i = 0; i < n - 1; i++)
        for(int j = 0; j < n - 1 - i; j++)
            if(nums[j] > nums[j + 1])
                (nums[j], nums[j + 1]) = (nums[j + 1], nums[j]);
}

void QuickSort(int[] nums, int l, int r)
{
    if(l >= r)return;
    int i = l, j = r;
    int pivot = nums[l];
    while(i < j)
    {
        while(i < j && nums[j] >= pivot)j--;
        while(i < j && nums[i] <= pivot)i++;
        if(i < j)
            (nums[i], nums[j]) = (nums[j], nums[i]);
    }
    nums[l] = nums[i];
    nums[i] = pivot;
    QuickSort(nums, l, j - 1);
    QuickSort(nums, j + 1, r);
}

void MergeSort(int[] nums, int left, int right)
{
    if(left >= right)
        return;
    int midIndex = left + right >> 1;
    MergeSort(nums, left, midIndex);
    MergeSort(nums, midIndex + 1, right);
    int[] tempArr = new int[nums.Length];
    for(int i = 0; i < nums.Length; i++)
        tempArr[i] = nums[i];
    int p = left, q = midIndex + 1, r = left;
    while(p <= midIndex && q <= right)
    {
        if(tempArr[p] <= tempArr[q])
            nums[r++] = tempArr[p++];
        else
            nums[r++] = tempArr[q++];
    }
    while(p <= midIndex)
        nums[r++] = tempArr[p++];
    while(q <= right)
        nums[r++] = tempArr[q++];
}


void HeapSort(int[] nums)
{
    int n = nums.Length;
    int[] myHeap = new int[n];
    int myHeapSize = myHeap.Length;
    for(int i = 0; i < n; i++)
        myHeap[i] = nums[i];
    for(int i = n / 2; i >= 0; i--)
        Down(myHeap, i, myHeapSize);
    for(int i = 0; i < n; i++)
    {
        nums[i] = myHeap[0];
        (myHeap[0], myHeap[myHeapSize - 1]) = (myHeap[myHeapSize - 1], myHeap[0]);
        myHeapSize--;
        Down(myHeap, 0, myHeapSize);
    }

}

void Down(int[] myHeap, int curIndex, int myHeapSize)
{
    int minIndex = curIndex;
    int leftSon = curIndex * 2, rightSon = curIndex * 2 + 1;
    if(leftSon < myHeapSize && myHeap[leftSon] < myHeap[minIndex])
        minIndex = leftSon;
    if(rightSon < myHeapSize && myHeap[rightSon] < myHeap[minIndex])
        minIndex = rightSon;
    if(minIndex != curIndex)
    {
        (myHeap[curIndex], myHeap[minIndex]) = (myHeap[minIndex], myHeap[curIndex]);
        Down(myHeap, minIndex, myHeapSize);
    }
}

 void RadixSort(int[] nums) 
 {
    int n = nums.Length;
    int exp = 1;
    int[] numCnt = new int[10];
    int[,] tempSet = new int[10,n];
    for(int i = 0; i < 10; i++){
        for(int j = 0; j < n; j++){
            int k = (nums[j] / exp) % 10;
            tempSet[k,numCnt[k]] = nums[j];
            numCnt[k]++;
        }
        for(int j = 0, t = 0; j < 10; j++){
            
            for(int k = 0; k < numCnt[j]; k++){
                nums[t++] = tempSet[j,k];
            }
            numCnt[j] = 0;
        }
        exp *= 10;
    }
}

void ShellSort(int[] nums)
{
    int n = nums.Length;
    int gap = n / 2;
    while(gap > 0)
    {
        for(int i = gap; i < n; i++)
        {
            int temp = nums[i];
            int j = i;
            while(j - gap >= 0 && nums[j - gap] > temp)
            {
                nums[j] = nums[j - gap];
                j -= gap;
            }
            nums[j] = temp;
        }
        gap /= 2;
    }
}

void CountingSort(int[] nums)
{
    int n = nums.Length;
    if(n < 1)
        return;
    int minNum = nums[0];
    int maxNum = nums[0];
    foreach(int num in nums)
    {
        minNum = Math.Min(minNum, num);
        maxNum = Math.Max(maxNum, num);
    }
    int range = maxNum - minNum + 1;
    int[] count = new int[range];
    foreach(int num in nums)
        count[num - minNum]++;
    for(int i = 1; i < range; i++)
        count[i] += count[i - 1];
    int[] temp = new int[n];
    foreach(int num in nums)
    {
        int index = count[num - minNum] - 1;
        temp[index] = num;
        count[num - minNum]--;
    }
    Array.Copy(temp, nums, nums.Length);
}

void BucketSort(int[] nums)
{
    int n = nums.Length;
    if(n < 1)
        return;
    int minNum = nums[0];
    int maxNum = nums[0];
    for(int i = 1; i < n; i++)
    {
        minNum = Math.Min(minNum, nums[i]);
        maxNum = Math.Max(maxNum, nums[i]);
    }
    int range = maxNum - minNum;
    int bucketCount = range / n + 1;
    List<List<int>> buckets = new List<List<int>>(bucketCount);

    for(int i = 0; i < bucketCount; i++)
        buckets.Add(new List<int>());
    
    foreach(int num in nums)
    {
        int bucketIndex = (num - minNum) / n;
        buckets[bucketIndex].Add(num);
    }

    buckets.ForEach((List<int> list)=> list.Sort());

    int numsIndex = 0;
    for(int i = 0; i < bucketCount; i++)
    {
        List<int> bucket = buckets[i];
        bucket.ForEach((int num) => nums[numsIndex++] = num);
    }
}

// InsertSort(nums);
// SelectSort(nums);
// BubbleSort(nums);
// QuickSort(nums, 0, nums.Length - 1);
// MergeSort(nums, 0, nums.Length - 1);
// HeapSort(nums);
// RadixSort(nums);
// ShellSort(nums);
// CountingSort(nums);
BucketSort(nums);
for(int i = 0; i < nums.Length; i++)
    Console.Write(nums[i] + " ");

参考资料：

  1. https://www.cnblogs.com/guoyaohua/p/8600214.html ↩︎

  2. https://blog.csdn.net/weixin_64600209/article/details/131354250?ops_request_misc=&request_id=&biz_id=102&utm_term=%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95&utm_medium=distribute.pc_search_result.none-task-blog-2allsobaiduweb~default-3-131354250.nonecase&spm=1018.2226.3001.4187 ↩︎

IGP9
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
auto-packages-updater:未完待续
04-18
自动包装更新器 入门 将应用程序克隆到您的计算机。 查看解决方案的步骤： 在IDE上打开服务器应用程序（我使用VSCode）。 在终端中：npm i 在终端中：npm start 开始之前，请先阅读以下设置： -说明和使用方法： 转到settings.js文件，并确保所有设置都适合需要。 阅读INSTRUCTIONS.md文件中的完整说明指南。 通过“ npm start”运行脚本，然后开始魔术。 :) 在终端中：npm start 测试愉快！ :) 先决条件 您需要安装VSCode，Node并克隆应用程序，然后运行npm i。 建于 使用的Web框架-服务器端。 贡献 请阅读以获取有关我们的行为准则以及向我们提交请求请求的过程的详细信息。 版本控制 我们使用进行版本控制。 有关可用的版本，请参见此的。 作者 Or 初期工作 或Assayag GitHub： :
event-dates-calendar:未完待续
04-04
活动日期日历 建于2021年3月的Node.js应用程序，通过结合以下几个元素来创建记事本TXT文件日历：从以前的事件日期TXT文件中复制旧数据，并创建到期事件，生日事件和每天重复的常见事件周末/每个第二个周末。...
js基础 - 排序
Cheng的博客
04-08 112
冒泡排序 比较相邻的元素，如果第一个比第二个大，两者就交换位置。对每一对相邻元素做同样的工作，从开始的第一对到结尾的最后一对。重复以上的步骤，直到没有需要比较的数字。 冒泡排序的动画演示： 代码实现： function sort(arr) { for (let i = 0; i < arr.length - 1; i++) { for (let j = 0; j < arr.length - 1 - i; j++) { // 每次比较 数组的长度 - 1 - i if (arr[j
排序模型入门详解（未完待续）
lankuohsing的博客
10-31 5647
排序模型入门详解 文章目录排序模型入门详解1. 排序模型的应用场景point-wise排序模型pair-wise排序模型Ranknet https://yq.aliyun.com/articles/18 1. 排序模型的应用场景 当商家需要向用户提供多个商品供选择时，往往会遇到这个问题：如何将商品按照一定的顺序呈现给用户，以便使用户能够尽可能地完成购买流程？这就涉及到对商品的排序，用到的模型称排...
数据结构和算法基础（8）——排序算法
qq_51114283的博客
04-24 733
一、排序介绍 1.分类 1.1 内部排序和外部排序。 内部排序值将需要处理的所有数据都加载到内存中进行排序. 外部排序借助外部存储进行排序。 常见的内部排序有： 1.2 非线性时间比较类排序和线性时间非比较类排序 非线性时间比较类排序：通过比较来决定元素间的相对次序，由于时间复杂度不能突破O(nlogn)，因此成为非线性时间比较类排序。 线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此被称为线性时间非比较类排序。 2.排序算法一张图分
iOS面试题总结-未完待续
王俊岭的博客
07-13 436
iOS面试总结 1. 网络 HTTP协议(HyperText Transfer Protocol)的请求和响应 请求: 请求头, 请求行, 请求体 请求行: 指定请求方法, 请求路径 协议版本等信息 请求头: 描述客户端环境, 例如: host要请求的主机地址, UserAgent客户端类型, Accept 可接受数据类型, Accept_language可接受语言 请求体: 客户端要发送的具体数据, 例如上传时的上传数据 响应: 状态行,响应头, 响应数据 状态行: 包含http协议版本,
DHCPv6 学习笔记--未完待续
05-05
图还没剪切完呢，凑合看吧！嘿嘿！！！由于时间紧任务重，大家都讲究看吧
9--[小黑点的旅行（未完待续）].zip源码scratch2.0 3.0编程项目源文件源码案例素材源代码
04-16
9--[小黑点的旅行（未完待续）].zip源码scratch2.0 3.0编程项目源文件源码案例素材源代码9--[小黑点的旅行（未完待续）].zip源码scratch2.0 3.0编程项目源文件源码案例素材源代码9--[小黑点的旅行（未完待续）].zip...
spring-boot-1.5.3中文文档（未完待续）
07-17
spring boot-1.5.3官方文档的中文翻译，暂时没有翻译完，后续会更新
2021-06-29 MySql（未完待续）
一只肥嘟嘟的日常
06-29 420
目录 文章目录目录1、初识MySql1.1、什么是数据库1.2、数据库分类1.3、MySQL简介1.4、连接数据库2、 操作数据库2.1、操作数据库2.2、数据库的列类型2.3、数据库的字段属性（重点)2.4、创建数据库表（重点）2.5、 数据表的类型2.6、操作表1、复制表：2、删除表：3、修改表结构：4、修改表名:5、修改表的字段（重命名，修改约束！）：3、MySQL数据管理3.1、外键（了解即可）3.2、DML语言 （全部记住）3.3、添加3.4、修改3.5、删除4、查询数据（最重点）4.1、查询语
2021-08-19-leetcode-00001
三毛毳毳的博客
08-19 535
二分查找 704 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1 278 你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。 假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。 你可以通过调用 boo
算法（未完待续）
weixin_42236592的博客
08-05 167
基础算法
基础算法——离散化
qq_44965626的博客
07-13 1562
本文简单介绍了离散化的原理及实现方法
基础算法——用递归实现枚举
qq_44965626的博客
07-11 900
1. 1~n的排列型枚举 2. 1~n的组合型枚举 3. 1~n的指数型枚举 4. 关于有重复元素时枚举的思考
240504-关于买卖股票问题的解法
最新发布
qq_44965626的博客
05-04 653
思路：在前面的基础上更改第1个状态转移方程即可。优化：空间复杂度可以降低为o(1)优化：空间复杂度降低到o(k)补一版记忆化搜索的代码。
基础算法——高精度
qq_44965626的博客
07-12 520
高精度加法 高精度减法 高精度乘法（高精度乘低精度、高精度乘高精度） 高精度除法（高精度除以低精度）
数学知识——质数、约数
qq_44965626的博客
11-04 349
数学知识——质数、约数 质数 试除法判定质数 分解质因数 筛质数 约数 试除法求约数 约数个数 约数之和 最大公约数 质数 AcWing 866. 试除法判定质数 #include<iostream> using namespace std; int n; bool check(int x) { if(x < 2)return false; for(int i = 2; i <= x / i; i++) if(x % i ==
数学知识——组合数
qq_44965626的博客
11-04 284
数学知识——组合数 组合数I（n<=10000, a,b<=2000 mod p） 组合数II（n<=1000,a,b<=105 mod p） 组合数III(n<=20, a,b<=1018, mod p) 组合数IV（a,b<=5000） 满足条件的01序列 AcWing 885. 求组合数 I 核心思路：预处理、动态规划o(n2) 从a个数中选b个数的所有方案可以分为两类（从a个物品中任选一个设为x）： 选出的b个物品包含x：c[a-1][b-
java 泛型 父类_java泛型基础、子类泛型不能转换成父类泛型--未完待续
05-12
在Java中，泛型是一种强类型机制，它可以让你在编译时检查类型错误，从而提高代码的安全性和可读性。在使用泛型时，我们经常会遇到父类和子类的泛型转换问题。 首先，我们需要明确一点：子类泛型不能转换成父类泛型...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值