九大排序算法原理并使用C++实现

已于 2023-11-09 14:25:42 修改
阅读量261 收藏 3
点赞数
文章标签： c++ 排序算法 算法
于 2020-08-12 20:37:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18431031/article/details/107881991
版权

1.插入排序
假设有N个待排序元素，下标从0到N - 1。从位置p = 1开始从前往后扫描直到N - 1，在第p趟时，我们将位置p上的元素向左移直至找到它前面的元素都比它小为止。时间复杂度为 O ( N 2 ) O(N^2) O(N2)。

#ifndef INSERTION_SORT_H
#define INSERTION_SORT_H

#include <vector>
#include <functional>
using namespace std;

template <typename Comparable>
void insertionSort(vector<Comparable> & a)
{
    for (int p = 1; p < a.size(); ++p) {
        Comparable tmp = std::move(a[p]);
        int j;
        for (j = p; j > 0 && tmp < a[j - 1]; --j)
            a[j] = std::move(a[j - 1]);
        a[j] = std::move(tmp);
    }
}

template <typename RandomIterator, typename Comparator>
void insertionSort(const RandomIterator & begin, const RandomIterator & end, Comparator lessThan)
{
    if (begin == end)
        return;
    RandomIterator j;
    for (RandomIterator p = begin + 1; p != end; ++p) {
        auto tmp = std::move(*p);
        for (j = p; j != begin && lessThan(tmp, *(j - 1)); --j)
            *j = std::move(*(j - 1));
        *j = std::move(tmp);
    }
}

template <typename RandomIterator>
void insertionSort(const RandomIterator & begin, const RandomIterator & end)
{
    insertionSort(begin, end, less<decltype(*begin)>{});
}

#endif

#include "insertion_sort.h"
#include <iostream>
using namespace std;

int main()
{
    int x;
    vector<int> a;
    for (int i = 0; i < 10; i++) {
        cin >> x;
        a.push_back(x);
    }
    insertionSort(begin(a), end(a));
    for (auto & tmp : a)
        cout << tmp << " ";
    cout << endl;
    return 0;
}

2.希尔排序
希尔排序是通过比较相距一定间隔的元素实现的，算法的大致思路是先设定一个间隔值gap，然后从第一个元素开始，依次比较与当前元素和相距为gap元素的大小，若当前元素大则交换，当比较的元素到达最后一个时，gap值除以2，再重新从前往后比较，直到gap值为0，排序结束。时间复杂度的上界为 O ( N 2 ) O(N^2) O(N2)。要想提高性能可以使用Hibbard增量序列，该增量的通式为2的k次方减1，k从1开始取，最坏运行时间为 O ( N 3 / 2 ) O(N^{3/2}) O(N3/2)，还有Sedgewick提出的几种增量序列。

#ifndef SHELL_SORT_H
#define SHELL_SORT_H

#include <vector>
using namespace std;

template <typename Comparable>
void shellsort(vector<Comparable> & a)
{
    for (int gap = a.size() / 2; gap > 0; gap /= 2)
        for (int i = gap; i < a.size(); ++i) {
            Comparable tmp = std::move(a[i]);
            int j = i;
            for (; j >= gap && tmp < a[j - gap]; j -= gap)
                a[j] = std::move(a[j - gap]);
            a[j] = std::move(tmp);
        }
}

#endif

#include "shell_sort.h"
#include <iostream>
using namespace std;

int main()
{
    int x;
    vector<int> v;
    for (int i = 0; i < 10; i++) {
        cin >> x;
        v.push_back(x);
    }
    shellsort(v);
    for (auto & tmp : v)
        cout << tmp << " ";
    cout << endl;
    return 0;
}

3.堆排序
堆排序的运行时间为 O ( N l o g N ) O(NlogN) O(NlogN)，需要一个附加的数组。该算法是通过依次删除（max）堆中最大的元素并把该元素放到堆刚刚减少元素的位置上来实现的，执行N - 1次删除最大值操作后，数组中的元素就变成从小到大排列了。

#ifndef HEAP_SORT_H
#define HEAP_SORT_H

#include <vector>
using namespace std;

inline int leftChild(int i)
{
    return 2 * i + 1;
}

template <typename Comparable>
void percDown(vector<Comparable> & a, int i, int n)
{
    int child;
    Comparable tmp;
    for (tmp = std::move(a[i]); leftChild(i) < n; i = child) {
        child = leftChild(i);
        if (child != n - 1 && a[child] < a[child + 1])
            ++child;
        if (tmp < a[child])
            a[i] = std::move(a[child]);
        else
            break;
    }
    a[i] = std::move(tmp);
}

template <typename Comparable>
void heapsort(vector<Comparable> & a)
{
    for (int i = a.size() / 2 - 1; i >= 0; --i) /* buildHeap */
        percDown(a, i, a.size());
    for (int j = a.size() - 1; j > 0; --j) { /* deleteMax */
        std::swap(a[0], a[j]);
        percDown(a, 0, j);
    }
}

#endif

#include "heap_sort.h"
#include <iostream>
using namespace std;

int main()
{
    int x;
    vector<int> v;
    for (int i = 0; i < 10; i++) {
        cin >> x;
        v.push_back(x);
    }
    heapsort(v);
    for (auto & tmp : v)
        cout << tmp << " ";
    cout << endl;
    return 0;
}

4.归并排序
归并排序算法的大概思路是先把待排序数组分成两部分，分别对那两部分进行排序，再将那两部分合并到一起。时间复杂度为 O ( N l o g N ) O(NlogN) O(NlogN)。

#ifndef MERGE_SORT_H
#define MERGE_SORT_H

#include <vector>
using namespace std;

/**
 * tmpArray为放置归并结果的数组
 * leftPos为子数组最左元素的下标
 * rightPos为后半部分起点的下标
 * rightEnd为子数组最右元素的下标
 */
template <typename Comparable>
void merge(vector<Comparable> & a, vector<Comparable> & tmpArray, int leftPos, int rightPos, int rightEnd)
{
    int leftEnd = rightPos - 1;
    int tmpPos = leftPos;
    int numElements = rightEnd - leftPos + 1;
    while (leftPos <= leftEnd && rightPos <= rightEnd)
        if (a[leftPos] <= a[rightPos])
            tmpArray[tmpPos++] = std::move(a[leftPos++]);
        else
            tmpArray[tmpPos++] = std::move(a[rightPos++]);
    while (leftPos <= leftEnd)
        tmpArray[tmpPos++] = std::move(a[leftPos++]);
    while (rightPos <= rightEnd)
        tmpArray[tmpPos++] = std::move(a[rightPos++]);
    for (int i = 0; i < numElements; ++i, --rightEnd)
        a[rightEnd] = std::move(tmpArray[rightEnd]);
}

template <typename Comparable>
void mergeSort(vector<Comparable> & a, vector<Comparable> & tmpArray, int left, int right)
{
    if (left < right) {
        int center = (left + right) / 2;
        mergeSort(a, tmpArray, left, center);
        mergeSort(a, tmpArray, center + 1, right);
        merge(a, tmpArray, left, center + 1, right);
    }
}

template <typename Comparable>
void mergeSort(vector<Comparable> & a)
{
    vector<Comparable> tmpArray(a.size());
    mergeSort(a, tmpArray, 0, a.size() - 1);
}

#endif

#include "merge_sort.h"
#include <iostream>
using namespace std;

int main()
{
    int x;
    vector<int> v;
    for (int i = 0; i < 10; i++) {
        cin >> x;
        v.push_back(x);
    }
    mergeSort(v);
    for (auto & tmp : v)
        cout << tmp << " ";
    cout << endl;
    return 0;
}

5.快速排序
快速排序的思路大致是取待排序数组 S S S中的任一元素为枢纽元，将除去枢纽元外的元素划分为小于等于枢纽元的集合 S 1 S1 S1以及大于等于枢纽元的集合 S 2 S2 S2，返回排序后的 S 1 S1 S1，后跟枢纽元，继而再跟 S 2 S2 S2。在这里，采用三数中值法选取枢纽元，选取 S S S中最左边，最右边以及中间的元素，取它们大小处于中间的值作为枢纽元，并把枢纽元与最后的元素交换位置。接着是分割策略，把 S S S分成三部分，这里用 i i i代表 S S S的最左边元素， j j j代表右边枢纽元的前一个元素，将 i i i右移，移过那些小于枢纽元的元素，将 j j j左移，移过那些大于枢纽元的元素，当 i i i和 j j j停止时，如果 i i i在 j j j的左边，那么将这两个元素交换，重复该过程直到 i i i和 j j j彼此交错为止。
对于很小的数组，快速排序性能不如插入排序，故这里当元素个数小于10的时候用插入排序。

#ifndef QUICK_SORT_H
#define QUICK_SORT_H

#include <vector>
using namespace std;

template <typename Comparable>
void insertionSort(vector<Comparable> & a, int left, int right)
{
    if (left == right)
        return;
    for (int p = left; p <= right; ++p) {
        Comparable tmp = std::move(a[p]);
        int j;
        for (j = p; j > 0 && tmp < a[j - 1]; --j)
            a[j] = std::move(a[j - 1]);
        a[j] = std::move(tmp);
    }
}

/*
* 返回 left center right 三项的中值
*/
template <typename Comparable>
const Comparable & median3(vector<Comparable> & a, int left, int right)
{
    int center = (left + right) / 2;
    if (a[center] < a[left])
        std::swap(a[left], a[center]);
    if (a[right] < a[left])
        std::swap(a[left], a[right]);
    if (a[right] < a[center])
        std::swap(a[center], a[right]);
    std::swap(a[center], a[right - 1]);
    return a[right - 1];
}

/*
* 使用三中值分割法
*/
template <typename Comparable>
void quicksort(vector<Comparable> & a, int left, int right)
{
    if (left + 10 <= right) {
        const Comparable & pivot = median3(a, left, right);
        int i = left, j = right - 1;
        // 开始分割
        for (; ;) {
            while (a[++i] < pivot) {}
            while (pivot < a[--j]) {}
            if (i < j)
                std::swap(a[i], a[j]);
            else
                break;
        }
        std::swap(a[i], a[right - 1]); // 恢复枢纽元
        quicksort(a, left, i - 1); // 将小于等于枢纽元的元素排序
        quicksort(a, i + 1, right); // 将大于等于枢纽元的元素排序
    }
    else // 若元素小于10个则进行插入排序
        insertionSort(a, left, right);
}

template <typename Comparable>
void quicksort(vector<Comparable> & a)
{
    quicksort(a, 0, a.size() - 1);
}

#endif

#include "quick_sort.h"
#include <iostream>
using namespace std;

int main()
{
    int x;
    vector<int> v;
    for (int i = 0; i < 15; i++) {
        cin >> x;
        v.push_back(x);
    }
    quicksort(v);
    for (auto & tmp : v)
        cout << tmp << " ";
    cout << endl;
    return 0;
}

6.桶排序
桶排序中待排序的元素必须只由小于 M M M的正整数构成的，算法的思路大概是使用一个大小为 M M M的count数组，初始化为全0，当读入待排序元素 a i ai ai时，count[ a i ai ai]增1。在所有的输入数据读入后，扫描count数组，打印出排序后的数据，时间复杂度为 O ( M + N ) O(M + N) O(M+N)。

#include <vector>
#include <cstring>
#include <iostream>
using namespace std;

int findMax(vector<int> & v, int N)
{
    int Max = v[0];
    for (int i = 1; i < N; i++) {
        if (v[i] > Max)
            Max = v[i];
    }
    return Max;
}

void bucketsort(vector<int> & v, int N)
{
    int M, i;
    M = findMax(v, N);
    int count[M + 1];
    memset(count, 0, sizeof(count));
    for (i = 0; i < N; i++)
        count[v[i]]++;
    for (i = 0; i <= M; i++) {
        while (count[i] > 0) {
            cout << i << " ";
            count[i]--;
        }
    }
    cout << endl;
}

int main()
{
    int x;
    vector<int> v;
    for (int i = 0; i < 13; i++) {
        cin >> x;
        v.push_back(x);
    }
    bucketsort(v, v.size());
    return 0;
}

7.基数排序
对字符串排序：

void radixSortA(vector<string> & arr, int stringLen)
{
    const int BUCKETS = 256;
    vector<vector<string> > buckets(BUCKETS);

    for (int pos = stringLen - 1; pos >= 0; --pos) {
        for (string & s : arr)
            buckets[s[pos]].push_back(std::move(s));
        cout << endl;
        int idx = 0;
        for (auto & thisBucket : buckets) {
            for (string & s : thisBucket)
                arr[idx++] = std::move(s);
            thisBucket.clear();
        }
    }
}

对字符串进行计数排序：

void countingRadixSort(vector<string> & arr, int stringLen)
{
    const int BUCKETS = 256;
    int N = arr.size();
    vector<string> buffer(N);
    vector<string> *in = &arr;
    vector<string> *out = &buffer;
    for (int pos = stringLen - 1; pos >= 0; --pos) {
        vector<int> count(BUCKETS + 1);

        for (int i = 0; i < N; ++i)
            ++count[(*in)[i][pos] + 1];

        for (int b = 1; b <= BUCKETS; ++b)
            count[b] += count[b - 1];

        for (int i = 0; i < N; ++i)
            (*out)[count[(*in)[i][pos]]++] = std::move((*in)[i]);
        std::swap(in, out);
    }

    if (stringLen % 2 == 1)
        for (int i = 0; i < arr.size(); ++i)
            (*out)[i] = std::move((*in)[i]);
}

对长度不一致的字符串进行排序：

void radixSort(vector<string> & arr, int maxLen)
{
    const int BUCKETS = 256;

    vector<vector<string> > wordsByLength(maxLen + 1);
    vector<vector<string> > buckets(BUCKETS);

    for (string & s : arr)
        wordsByLength[s.length()].push_back(std::move(s));

    int idx = 0;
    for (auto & wordList : wordsByLength)
        for (string & s : wordList)
            arr[idx++] = std::move(s);

    int startingIndex = arr.size();
    for (int pos = maxLen - 1; pos >= 0; --pos) {
        startingIndex -= wordsByLength[pos + 1].size();

        for (int i = startingIndex; i < arr.size(); ++i)
            buckets[arr[i][pos]].push_back(std::move(arr[i]));

        idx = startingIndex;
        for (auto & thisBucket : buckets) {
            for (string & s : thisBucket)
                arr[idx++] = std::move(s);
            thisBucket.clear();
        }
    }
}

8.冒泡排序

#include <vector>
#include <iostream>
using namespace std;

template <typename Comparable>
void bubblesort(vector<Comparable> & a, int n)
{
    for (int i = 0; i < n - 1; ++i) {
        for (int j = i; j < n; ++j)
            if (a[i] > a[j])
                std::swap(a[i], a[j]);
    }
}

template <typename Comparable>
void bubblesort(vector<Comparable> & a)
{
    bubblesort(a, a.size());
}

int main()
{
    int x;
    vector<int> v;
    for (int i = 0; i < 2; i++) {
        cin >> x;
        v.push_back(x);
    }
    bubblesort(v);
    for (auto & tmp : v)
        cout << tmp << " ";
    cout << endl;
    return 0;
}

9.选择排序
从待排序数组的第一个元素开始比较，找出比当前元素小的并且是最小的元素和第一个元素互换，以此类推。

template <typename Comparable>
void selectionSort(vector<Comparable> & toSort)
{
    int minIndex;
    for (int i = 0; i < toSort.size(); ++i) {
        minIndex = i;
        for (int j = i + 1; j < toSort.size(); ++j) {
            if (toSort[j] < toSort[minIndex])
                swap(toSort[j], toSort[i]);
        }
    }
}
Soft'Wind
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C/C++实现三路快速排序算法原理
01-01
书接上文，上次讲到了双路快速排序，双路快速排序是将等于v（标志数）的数也进行交换，从而避免了在处理有大量重复数据的数组分组时的不平衡。而三路快速排序则是将等于v的数也分成一组，同样可以解决上述问题。其...
常见的几种排序算法（c++）
low5252的博客
03-12 8259
常见的几种排序算法（c++）一、冒泡排序二、插入排序三、选择排序四、归并排序五、希尔排序六、快速排序七、堆排序八、基数排序1.LSD(低位到高位的排序)2.MSD(高位到低位排序)算法比较 一、冒泡排序 1、算法思想 冒泡排序是一种简单的排序算法，通过循环遍历，将临近的两个元素进行比较，满足排序规则时，进行下一组元素对比，当不满足排序规则时，将两个元素交换位置，再继续进行下一组元素对比，确保最大的...
十大经典排序算法
nmslqwq的博客
10-10 617
排序算法是《数据结构与算法》中最基本的算法之一。 排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括： 关于时间复杂度 平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接...
C++实现七种经典排序算法
森的博客
04-08 3068
利用C++实现七种常见的排序算法： 具体的排序方法如下所示： （1）冒泡排序 基本思想：比较相邻的两个数，如果前者比后者大，则进行交换。每一轮排序结束，选出一个未排序中最大的数放到数组后面。常见冒泡排序算法如下所示： void bubblesort(int *arr,int n) { for (int i = 0; i < n; i++) { for (int j = ...
经典排序算法C++实现（10种）
weixin_42023936的博客
08-27 1599
C++实现经典排序算法插入排序希尔排序（缩小增量排序）选择排序堆排序冒泡排序冒泡排序的原理：快速排序合并排序折中排序新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章U...
C++实现五种常见排序算法
weixin_39318565的博客
06-20 4443
排序算法在工作和面试中都经常用到这里是常见的几种算法的C++实现
63_7种经典的排序算法原理及C++实现1
08-03
1.举个例，序列度len=8，初始增量为step=len/2=4，则将序列分成了4组每组两个元素，然后每组 2.事实上，增量序列不仅可以是[1,2,4,8,..
C/C++实现双路快速排序算法原理
01-21
本文实例为大家分享了C/C++实现双路快速排序算法的具体代码，供大家参考，具体内容如下 看了刘宇波的视频，讲双路快速排序的，原理讲的很直观，程序讲解也一看就懂。这里写一下自己的理解过程，也加深一下自己的理解...
c++十大经典排序算法
客舟中
12-28 5441
代码 1 冒泡排序 冒泡排序是一种简单直观的入门排序算法。它的原理就是从第一个元素开始，与后面的元素逐个比较，如果顺序不对就交换，直到没有可比较的元素为止。 1 // 冒泡排序 2 void BublingSort(int *arr, int len) 3 { 4 if(len == 0) 5 { 6 return; 7 } 8 std::cout<<"冒泡排序"<<std::endl; 9 for(i
十大排序算法（C++）
沉默、凝视的博客
02-21 561
十大排序算法（C++） 1、冒泡排序 原理：比较相邻两个元素，如果前一个比后一个大则交换二者位置（以升序为例），每进行一轮比较则可以把最大的元素放到相对最后的位置。每进行一轮比较就会有一个元素变为有序。循环对每轮越来越少的元素进行比较则最终变为有序序列。 如果序列元素初始时为有序，则一轮则可进行排序完毕，最好时间复杂度为O(n)；如果序列元素初始时是逆序，则需要n-1轮比较，且每轮要进行n-i次比较，最坏时间复杂度为O(n²)，平均时间复杂度为O(n²)。 // 冒泡排序 void SortBubblin
C++八种排序算法万字详解
我的博客
06-04 7192
哈喽，今天我来总结一下C++中的8中排序方法，这些排序在实际开发中能起到一些作用，也可以锻炼你的算法头脑。我也好长时间没上热榜了，这次准备做一个非常详细🔎的总结，看看能不能上热榜。既然叫排序算法，肯定要排序。我们要实现的效果是输入几个数，输出升序（或降序）排序后的结果，并找到时间复杂度最低的算法，应用到实际开发中。冒泡排序主要思路就是遍历数组，比较两个相邻的元素，也就是 arr[j] 和 arr[j+1] ，如果顺序错误就用 swap 函数或空杯交换，交换这两个元素。举个例子，数组是 a[5]={2,1,.
用C++实现十大经典排序算法
billy的博客
01-04 7579
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
C++ 排序算法
qq_24127015的博客
01-31 432
 1.冒泡排序 2.选择排序 3.插入排序 4.希尔排序 5.归并排序 6.快速排序 7.堆排序 8.计数排序 9.桶排序 10.基数排序 // sortdemo.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include &lt;stdio.h&gt; #include &lt;...
十大排序算法（C++版）
CltCj的博客
02-03 4640
十大排序算法前言一、直接插入排序二、折半插入排序三、希尔排序总结 前言 什么是排序？   排序：将一组杂乱无章的数据按一定规律顺次排列起来。即，将无序序列排成一个有序序列（由小到大或由大到小）的运算。 排序方法的分类   按数据存储介质：内部排序和外部排序   按比较器个数：串行排序和并行排序   按主要操作：比较排序和基数排序   按辅助空间：原地排序和非原地排序   按稳定性：稳定排序和非稳定排序   按自然性：自然排序和非自然排序 一、直接插入排序 基本思想：   每步将一个待排序的对象
c++十大经典算法排序
back_room的博客
06-22 502
c++十大经典算法排序
排序算法 C++实现
weixin_30735745的博客
08-09 125
一、插入排序 （Insertion Sort） void insertion_sort(vector<int>& number){ int length = number.size(); if(length <= 1) return; for(int index = 1; index < length; ++...
十大经典排序算法（C++实现）
m0_60935443的博客
03-22 8836
0、算法分类 排序算法是《数据结构与算法》中最基本的算法之一。 十种常见排序算法可以分为两大类： 比较类排序：通过比较来决定元素间的相对次序，时间复杂度为 O(nlogn)～O(n²)。 非比较类排序：不通过比较来决定元素间的相对次序，其时间复杂度可以突破 O(nlogn)，以线性时间运行。 名次解释： 时间/空间复杂度：描述一个算法执行时间/占用空间与数据规模的增长关系。 n：待排序列的个数。 k：“桶”的个数（上面的三种非比较类排序都是基于“桶”的思想实
【C++】常见的几种排序算法
zdb
11-02 6131
借用了这位大哥的图片：链接，也可以看此博客讲解直接插入排序。 这位大哥做了每种排序的讲解博客，很不错强推。。 此博客只为方便学习，造福人类。 （1）冒泡排序 冒泡排序的思路是数小的像泡泡一样冒出来，反过来我们可以理解为，数大的像石头一样沉下去。 我们遍历数组，从左到右，若右边的数比左边的大，则交换。 第一遍：最大的数沉下去 第二遍：第二大的数沉在倒数第二个位置 … 版本二为常见常用版本，版本三在二的基础上优化，避免了不需要的排序 class Sloution { public: //冒泡：时间复杂度O
学习记录—C++实现排序算法汇总
Coderwind的博客
08-28 600
学习记录—排序算法
排序算法可视化c++
最新发布
01-14
一种常见的实现方式是使用C语言结合图形库如OpenGL或SDL来创建一个窗口，然后在窗口中绘制出待排序的数据，在排序算法执行的每一个关键步骤中，通过改变绘制的元素的颜色或位置来表示元素的排序状态。 以冒泡排序为...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值