排序算法详解

最新推荐文章于 2024-07-16 21:04:22 发布
最新推荐文章于 2024-07-16 21:04:22 发布
阅读量884 收藏 17
点赞数 19
分类专栏： 算法与数据结构 文章标签： 排序算法 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu_xinLL/article/details/135755449
版权
O(n^2)
代码实现：
void select_sort( int * arr , int l , int r ) {
    for ( int i = 0, I = r - 1; i < I; i++) {
        int ind = i;
        for ( int j = i + 1; j < r ; j++) {
            if ( arr [j] < arr [ind]) ind = j;
        }
        swap( arr [i], arr [ind]);
    }
    return ;
}
O（n^2）但比选择排序略快
代码实现：
void insert_sort( int * arr , int l , int r ) {
    for ( int i = l + 1; i < r ; i++) {
        int j = i;
        while (j > l && arr [j] < arr [j - 1]) {
            swap( arr [j], arr [j - 1]);
            j--;
        }
    }
    return ;
} ;
优化：
void unguarded_insert_sort( int * arr , int l , int r ) {
    int ind = l ;
    for ( int i = l + 1; i < r ; i++) {
        if ( arr [ind] > arr [i]) ind = i;
    }
    //保证了插入排序算法的稳定性
    while (ind > l ) {
        swap( arr [ind], arr [ind - 1]);
        ind -= 1;
    }
    for ( int i = l + 1; i < r ; i++) {
        int j = i;
        //体现了无监督
        while ( arr [j] < arr [j - 1]) {
            swap( arr [j], arr [j - 1]);
            j--;
        }
    }
    return ;
}
希尔排序（分组插入排序） 
1、设计⼀个【步长】序列 
2、按照步长，对序列进⾏分组，每组采用插⼊排序 
3、直到执 ⾏ 到步长为1为 ⽌
希尔排序的效率和【步长序列】紧密相关 
参考时间复杂度：O(nlogn) ~ O(n^2) 
O(n^2) 希尔增量序列：n/2、n/4、n/8、n/16 …… 
O(n^1.5) Hibbard增量序列：1、3、7 … 2k-1
代码实现：
void unguarded_insert_sort( int * arr , int l , int r , int step ) {
    int ind = l ;
    for ( int i = l + step ; i < r ; i += step ) {
        if ( arr [i] < arr [ind]) ind = i;
    }
    while (ind > l ) {
        swap ( arr [ind], arr [ind - step ]);
        ind -= step ;
    }
    for ( int i = l + 2 * step ; i < r ; i += step ) {
        int j = i;
        while ( arr [j] < arr [j - step ]) {
            swap ( arr [j], arr [j - step ]);
            j -= step ;
        }
    }
    return ;
}
void shell_sort( int * arr , int l , int r ) {
    int k = 2, n = ( r - l ), step;
    do {
        //计算步长
        step = n / k == 0 ? 1 : n / k;
        for ( int i = l , I = l + step; i < I; i++) {
            unguarded_insert_sort( arr , i, r , step);
        }
        k *= 2;
    } while (step != 1);
    return ;
}
void shell_sort_hibbard( int * arr , int l , int r ) {
    int step = 1, n = ( r - l );
    //计算步长
    while (step <= n / 2) step = step * 2 + 1;
    do {
        step /= 2;
        for ( int i = l , I = l + step; i < I; i++) {
            unguarded_insert_sort( arr , i, r , step);
        }
    } while (step > 1);
    return ;
}
冒泡排序
1、将数组分成『已排序区』和『待排序区』 
2、从头到尾扫描『待排序区』，若前面元素比后面元素⼤，则交换。 
3、每⼀轮都会将『待排序区』中最⼤的放到『已排序区』的开头 
4、直到『待排序区』没有元素为⽌
void bubble_sort( int * arr , int l , int r ) {
        for ( int i = r - 1, I = l + 1; i >= I; i--) {
               for ( int j = l ; j < i; j++) {
                       if ( arr [j] > arr [j + 1])swap( arr [j], arr [j + 1]);
              }
       }
        return ;
}
void bubble_sort_plus ( int * arr , int l , int r ) {
        for ( int i = r - 1, I = l + 1, cnt; i >= I; i--) {
              cnt = 0;
               for ( int j = l ; j < i; j++) {
                       if ( arr [j] <= arr [j + 1]) continue ;
                      swap( arr [j], arr [j + 1]);
                      cnt += 1;
              }
               if (cnt == 0) break ;
       }
        return ;
}
快速排序
时间复杂度：O(nlogn) ~ O(n2)
1.选择数组第一个数为基准值
2.选左右端为指针，移动指针，将数组分为大于基准值和小于基准值的两部分
3.由于快排属于树形结构，所以递归实现
void quick_sort( int * arr , int l , int r ) {
        if ( r - l <= 2) {
               if ( r - l <= 1) return ;
               if ( arr [ l ] > arr [ l + 1]) swap( arr [ l ], arr [ l + 1]);
               return ;
       }
        //partition
        int x = l, y = r - 1, z = arr [ l ];
        while (x < y) {
               while (x < y && z <= arr [y]) --y;
               if (x < y) arr [x++] = arr [y];
               while (x < y && arr [x] <= z) ++x;
               if (x < y) arr [y--] = arr [x];
       }
        arr [x] = z;
        //左闭右开
       quick_sort( arr , 1, x);
       quick_sort( arr , x + 1, r );
        return ;
}
//优化1
void quick_sort_v1( int * arr , int l , int r ) {
    if ( r - l <= 2) {
        if ( r - l <= 1) return ;
        if ( arr [ l ] > arr [ l + 1]) swap( arr [ l ], arr [ l + 1]);
        return ;
    }
    // partition
    int x = l , y = r - 1, z = arr [ l ];
    do {
        //减少了分区的判断操作
        while ( arr [x] < z) ++x;
        while ( arr [y] > z) --y;
        if (x <= y) {
            swap( arr [x], arr [y]);
            ++x, --y;
        }
    } while (x <= y);
    quick_sort_v1( arr , l , x);
    quick_sort_v1( arr , x, r );
    return ;
}
//三点取中法
inline int three_point_select( int a , int b , int c ) {
    if ( a > b ) swap( a , b );
    if ( a > c ) swap( a , c );
    if ( b > c ) swap( b , c );
    return b ;
}
void quick_sort_v2( int * arr , int l , int r ) {
    if ( r - l <= 2) {
        if ( r - l <= 1) return ;
        if ( arr [ l ] > arr [ l + 1]) swap( arr [ l ], arr [ l + 1]);
        return ;
    }
    // partition
    //减少树形结构的层数，减少递归调用的次数
    int x = l , y = r - 1;
    int z = three_point_select(
        arr [ l ],
        arr [ r - 1],
        arr [( l + r ) / 2]
    );
    do {
        while ( arr [x] < z) ++x;
        while ( arr [y] > z) --y;
        if (x <= y) {
            swap( arr [x], arr [y]);
            ++x, --y;
        }
    } while (x <= y);
    quick_sort_v2( arr , l , x);
    quick_sort_v2( arr , x, r );
    return ;
}
void quick_sort_v3( int * arr , int l , int r ) {
    if ( r - l <= 2) {
        if ( r - l <= 1) return ;
        if ( arr [ l ] > arr [ l + 1]) swap( arr [ l ], arr [ l + 1]);
        return ;
    }
    //单边递归法
    while ( l < r ) {
        // partition
        int x = l , y = r - 1;
        int z = three_point_select(
            arr [ l ],
            arr [ r - 1],
            arr [( l + r ) / 2]
        );
        do {
            while ( arr [x] < z) ++x;
            while ( arr [y] > z) --y;
            if (x <= y) {
                swap( arr [x], arr [y]);
                ++x, --y;
            }
        } while (x <= y);
        quick_sort_v3( arr , l , x); // left
        //右边循环实现
        l = x;
    }
    return ;
}
#define threshold 16
void unguarded_insert_sort( int * arr , int l , int r ) {
    int ind = l ;
    for ( int i = l + 1; i < r ; i++) {
        if ( arr [i] < arr [ind]) ind = i;
    }
    while (ind > l ) {
        swap( arr [ind], arr [ind - 1]);
        ind -= 1;
    }
    for ( int i = l + 1; i < r ; i++) {
        int j = i;
        while ( arr [j] < arr [j - 1]) {
            swap( arr [j], arr [j - 1]);
            j -= 1;
        }
    }
    return ;
}
void __quick_sort_v4( int * arr , int l , int r ) {
    //在阈值内采用插入排序
    while ( r - l > threshold ) {
        // partition
        int x = l , y = r - 1;
        int z = three_point_select(
            arr [ l ],
            arr [ r - 1],
            arr [( l + r ) / 2]
        );
        do {
            while ( arr [x] < z) ++x;
            while ( arr [y] > z) --y;
            if (x <= y) {
                swap( arr [x], arr [y]);
                ++x, --y;
            }
        } while (x <= y);
        __quick_sort_v4( arr , l , x); // left
        l = x;
    }
    return ;
}
void quick_sort_v4( int * arr , int l , int r ) {
    __quick_sort_v4( arr , l , r );
    unguarded_insert_sort( arr , l , r );
    return ;
}
归并排序
//保留数组上一次的归并排序结果
int *buff;
buff = ( int *)malloc( sizeof ( int ) * BIG_DATA_N );
//
void merge_sort( int * arr , int l , int r ) {
    if ( r - l <= 1) return ;
    int mid = ( l + r ) / 2;
//分区
    merge_sort( arr , l , mid);
    merge_sort( arr , mid, r );
    // merge
    int p1 = l , p2 = mid, k = 0;
    while (p1 < mid || p2 < r ) {
        if (p2 == r || (p1 < mid && arr [p1] <= arr [p2])) {
            buff[k++] = arr [p1++];
        } else {
            buff[k++] = arr [p2++];
        }
    }
//拷贝
    for ( int i = l ; i < r ; i++) arr [i] = buff[i - l ];
    return ;
}
应用：求解逆序问题（海贼oj_248）
基数排序--O(logK * n)
步骤：
1.将要排序数分为两部分，作为基数
2.分别计算相同基数的被排序数的个数，确定从哪开始排序
3.分别以基数的大小进行排序，基数相同的数相对位置不变
代码实现：
//正数的排序
void radix_sort( int * arr , int l , int r ) {
    #define K 65536
    int *cnt  = ( int *)malloc( sizeof ( int ) * K );
    int *temp = ( int *)malloc( sizeof ( int ) * ( r - l ));
    // round 1
    //将前2^16位作为基数
    memset(cnt, 0, sizeof ( int ) * K );
    for ( int i = l ; i < r ; i++) cnt[ arr [i] % K ] += 1;
    for ( int i = 1; i < K ; i++) cnt[i] += cnt[i - 1];
    for ( int i = r - 1; i >= l ; i--) temp[--cnt[ arr [i] % K ]] = arr [i];
    memcpy( arr + l , temp, sizeof ( int ) * ( r - l ));
    // round 2
    //将后2^16位作为基数
    memset(cnt, 0, sizeof ( int ) * K );
    for ( int i = l ; i < r ; i++) cnt[ arr [i] / K ] += 1;
    for ( int i = 1; i < K ; i++) cnt[i] += cnt[i - 1];
    for ( int i = r - 1; i >= l ; i--) temp[--cnt[ arr [i] / K ]] = arr [i];
    memcpy( arr + l , temp, sizeof ( int ) * ( r - l ));
    return ;
}
总结：
排序算法的稳定性：相同元素的相对位置不改变，则排序算法具有稳定性。
稳定排序：插入排序，冒泡排序，归并排序，基数排序
非稳定排序：选择排序，希尔排序，快速排序，堆排序
内部/外部排序：只可以使用内存空间/可以使用内存空间和硬盘空间，进行排序。
外部排序可以用于大数据排序。
内部排序： 插入排序，冒泡排序， 选择排序，希尔排序，快速排序，堆排序。
外部排序： 归并排序，基数排序
sort:
#include<algorithm>
sort(首指针/首迭代器，尾指针+1/尾迭代器，cmp(函数))
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <stack>
#include <algorithm>
#include <string>
#include <map>
#include <set>
#include <vector>
#include "0.sort_test.h"
using namespace std;
void output( int * arr , int n , const char * s = "arr" );
template < typename T >
void output( vector < T >& arr );
void test1() {
    printf( "\ntest array : \n" );
    // sort array
    int * arr = getRandData(10);
    output(arr, 10);
    //从小到大
    sort(arr, arr + 10); // [)
    output(arr, 10);
    //从大到小
    sort(arr, arr + 10, greater < int >());
    output(arr, 10);
    free(arr);
    return ;
}
void test2() {
    printf( "\ntest vector : \n" );
    // sort vector
    vector < int > arr;
    for ( int i = 0; i < 10; i++) arr.push_back(rand() % 10000);
    output(arr);
    sort(arr.begin(), arr.end());
    output(arr);
    sort(arr.begin(), arr.end(), greater < int >());
    output(arr);
    return ;
}
struct Data {
    int x, y;
};
ostream & operator<< ( ostream & out , const Data & d ) {
    out << "(" << d .x << ", " << d .y << ")" ;
    return out ;
}
bool cmp( const Data & a , const Data & b ) {
    //先按x从小到大排
    if ( a .x != b .x) return a .x < b .x;
    //再按y从大到小排
    return a .y > b .y;
}
void test3() {
    printf( "\ntest my data structure : \n" );
    vector < Data > arr;
    for ( int i = 0; i < 10; i++) {
        Data d;
        d.x = rand() % 10, d.y = rand() % 10;
        arr.push_back(d);
    }
    output(arr);
    sort(arr.begin(), arr.end(), cmp);
    output(arr);
    return ;
}
void test4() {
    //不改变原数组数据的排序--下标排序
    printf( "\ntest sort ind : \n" );
    int * arr = getRandData(10);
    int * ind = getRandData(10);
    for ( int i = 0; i < 10; i++) ind[i] = i;
    output(arr, 10);
    //表达式
    sort(ind, ind + 10, [&]( int i , int j ) -> bool {
        return arr[ i ] < arr[ j ];
        });
    output(arr, 10);
    output(ind, 10, "ind" );
    return ;
}
int main() {
    test1();
    test2();
    test3();
    test4();
    return 0;
}
template < typename T >
void output( vector < T >& arr ) {
    printf( "arr[%lu] = " , arr .size());
    for ( int i = 0; i < arr .size(); i++) {
        cout << arr [i] << " " ;
    }
    printf( "\n" );
    return ;
}
void output( int * arr , int n , const char * s ) {
    printf( "%s[%d] = " , s , n );
    for ( int i = 0; i < n ; i++) {
        printf( "%d " , arr [i]);
    }
    printf( "\n" );
    return ;
}
拓扑排序：
有向无环图：指的是一个无回路的有向图。如果有一个非有向无环图，且A点出发向B经C可回到A，形成一个环。将从C到A的边方向改为从A到C，则变成有向无环图。 一个有向无环图至少有一个入度为0的顶点和一个出度为0的顶点。
对一个 有向无环图 ( Directed Acyclic Graph 简称 DAG ) G 进行拓扑排序，是将 G 中所有顶点排成一个线性序列，使得图中任意一对顶点 u 和 v ，若边 < u , v > ∈ E ( G )，则 u 在线性序列中出现在 v 之前。通常，这样的线性序列称为满足拓扑次序 ( Topological Order ) 的序列，简称拓扑序列。 由某个集合上的一个偏序得到该集合上的一个全序，这个操作称之为拓扑排序。
ps:
  • 离散数学中关于偏序和全序的定义：
         若集合X上的关系是R,且R是自反的、反对称的和传递的，则称R是集合X上的偏序关系。 设R是集合X上的偏序（Partial Order）,如果对每个x,y属于X必有xRy 或 yRx，则称R是集合X上的全序关系。 比较简单的理解：偏序是指集合中只有部分成员可以比较，全序是指集合中所有的成员之间均可以比较。
  • 若图中存在有向环，则不可能使顶点满足拓扑次序。
作用： 图形的顶点可以表示要执行的任务（递归函数），并且边可以表示一个任务 （递归函数） 必须在另一个任务 （递归函数） 之前执行的约束；在这个应用中，拓扑排序只是一个有效的任务 （递归函数调用） 顺序，以此实现递归转非递归
拓扑排序实现过程：
1.找出入度为0的节点，入队
2.处理当前队首节点，将队首节点有向边指向的所有节点的入度减一，并将入度为一的节点入队（bfs）
3.队首元素出队，处理新的队首元素
4.循环至队为空
5.出队序列就为拓扑序列
代码演示：
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <stack>
#include <algorithm>
#include <string>
#include <map>
#include <set>
#include <vector>
using namespace std;
#define MAX_N 2000
//入度
int indeg[ MAX_N + 5] = {0};
//路径
vector < vector < int >> g( MAX_N + 5);
//拓扑序列
int ans[ MAX_N + 5], cnt = 0;
int main() {
    int n, m;
    cin >> n >> m;
    for ( int i = 0, a, b; i < m; i++) {
        cin >> a >> b;
        indeg[b] += 1;
        g [ a ] .push_back(b);
    }
    set < int > q;
    for ( int i = 1; i <= n; i++) {
        if (indeg[i] == 0) q.insert(i);
    }
    while (q.size() > 0) {
        int now = * q.begin(); // top()
        ans[cnt++] = now;
        q.erase(q.begin());   // pop()
        //-------
        for ( int i = 0, I = g [ now ] .size(); i < I; i++) {
            int t = g [ now ][ i ] ;
            indeg[t] -= 1;
            if (indeg[t] == 0) {
                q.insert(t);
            }
        }
        //-------
    }
    for ( int i = 0; i < n; i++) {
        if (i) cout << " " ;
        cout << ans[i];
    }
    cout << endl;
    return 0;
}
(╯▔皿▔)╯
关注
  • 19
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
排序算法
www1234的博客
04-10 341
排序算法,冒泡排序,选择排序,插入排序,希尔排序,快速排序,堆排序,归并排序
十大排序算法详解（一）冒泡排序、选择排序、插入排序、快速排序、希尔排序
热门推荐
HK的博客
06-27 18万+
冒泡排序、选择排序、插入排序、快速排序、希尔排序
十大经典排序算法-归并排序算法详解
qq_35344198的博客
06-19 12万+
一、什么是归并排序 1.概念 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照归并排序的思想，我们要把序列逐层进行拆分 序列逐层拆分如下 然后从下往上逐层合并，首先对第一层序列1（只包含元素4）和序列2（只包含元素5）进行合并 创建一个大序列，序列长度为两个小序列长度
十大经典排序算法-快速排序算法详解
qq_35344198的博客
06-16 8万+
一、什么是快速排序 1.概念 快速排序（Quick Sort）是从冒泡排序算法演变而来的，实际上是在冒泡排序基础上的递归分治法。快速排序在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列一边，比它小的元素移动到数列的另一边，从而把数列拆解成了两个部分 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照快速排序的思想，我们先选择一个基准元素，进行排序 我们选取4为我们的基准元素，并设置基准元素的位置为index，设置两个指针left和right，分别指向最左
Python排序算法详解
04-10
在编程领域，排序算法是数据处理中的核心部分，它用于将一组无序的数据按照特定顺序进行排列。Python作为一门简洁且强大的编程语言，内置了高效的排序函数`sorted()`和列表对象的`sort()`方法，但了解和掌握排序算法...
Javascript冒泡排序算法详解
10-25
主要介绍了Javascript冒泡排序算法的相关资料,需要的朋友可以参考下
堆排序算法详解与实现.zip
06-17
"堆排序算法详解与实现.pdf"这份文档可能包含了堆排序的详细理论分析、实例演示以及不同编程语言的实现代码。而"项目说明.pdf"可能提供了更多关于如何应用堆排序到实际项目中的指导和注意事项。 总之，堆排序是一种...
排序算法详解，动画演示
01-03
冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就交换位置。这个过程持续对数列的末尾进行，直到整个数列都排序完成。 冒泡排序的时间复杂度为O(n^2)，这使得它在...
经典7大排序算法详解
01-16
白话数据结构7大排序算法详解。
数据结构——排序算法(冒泡、快速、选择、插入)
TENET123的博客
07-13 1531
排序（Sort）是将无序的记录序列（或称文件）调整成有序的序列。排序算法在计算机科学中非常重要，因为它们可以提高数据检索效率、简化后续算法的复杂性和优化存储结构等。
排序——归并排序及排序章节总结
Blusher1的博客
07-13 918
前面的文章中 我们详细介绍了排序的概念，插入排序，交换排序与选择排序，这篇文章就详细介绍一下另一种排序算法：归并排序，以及对于排序章节进行一下总结
常见排序算法
weixin_50956409的博客
07-11 1034
不能！！！考虑这样一种情况，如果去掉等号，right在找小的过程中，遇到了和key相等的值就会停下。而left在找大的过程恰好也停在和key相等的位置，left和right交换，进行下一轮循环，right和left在原地又会进行交换，如此就陷入了死循环……
排序——交换排序
Blusher1的博客
07-12 732
在上篇文章我们详细介绍了排序的概念与直接插入排序，这篇文章就介绍一下一种排序方式：交换排序。
排序之冒泡排序
weixin_50960004的博客
07-13 318
lo,hi)，通过一个标志记录逆序的元素 ，该标志控制外层循环。
python实现插入排序、快速排序
最新发布
qq_42568323的博客
07-16 317
快速排序是一种分治算法，通常被认为是目前最快的排序算法之一。它的基本思想是通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个过程可以递归进行，以达到整个数据变成有序序列。通过以上实现，可以看到这两种排序算法在不同场景下的适用性。插入排序算法简单直观，适用于小规模数据；快速排序则效率高，适用于大规模数据。它的基本思想是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
二分查找和斐波那契查找
weixin_50960004的博客
07-13 487
表面上看，后一调整存在风险，此时只能确定切分点arr[mid]＞target ，“贸然”地将arr[mi]排除在进一步的查找范围之外，似乎可能因遗漏这些元素，而导致本应成功的查找以失败告终。也就是说，无论朝哪个方向深入，都只需做1次元素的大小比较，其二，统一沿两个方向深入所需要执行的比较次数，比如都统一为一次。在有序向量中的查找，遇到重复的元素时会返回秩最大的那个，上述查找无法实现这个功能，因此加以改进。所以这样的话，想进入左半区间，进行一次比较，想进入右半区间，会进行两次比较，右侧比较会多。
八大排序-01
m0_72410274的博客
07-13 194
【代码】八大排序-01
函数模板与类模板
程序员_小兵
07-12 1565
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值