算法之经典排序算法

最新推荐文章于 2021-05-25 02:14:22 发布
最新推荐文章于 2021-05-25 02:14:22 发布
阅读量821 收藏
点赞数 1
分类专栏： 数据结构及经典算法：C语言实现 算法C语言实现 文章标签： 插入排序 希尔排序 冒泡排序 选择排序 快速排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010710458/article/details/78438880
版权

基本排序算法

选择排序

首先，找出数组中的最小元素，并用首位的元素与它交换。然后，从后面找出次大元素，并用第二个位置的元素与它变换。重复此步骤，直到排序完整个数组。这个方法称做选择排序(selection sort），因为它重复性地选择剩余元素中的最小元素来完成排序。

这里写图片描述

插入排序

人们通常排列扑克的方法是一次考虑一张牌，将它插入到已经排序过的牌的适当位置中（时刻保持有序），这里通过一次回溯遍历将新的数据和已排好序的数据一一比较，找到适当的位置。在排序过程中 ， 当前索引左边的元素己有序 ， 但并非处于它们的最终位置，因为它们还必须移动，为后面碰到的更小元素腾出空间。不过，当索引到达右终端时，整个数组已经排序完毕。

这里写图片描述

对应排序动画

冒泡排序

冒泡排序不断地扫描文件，交换没有按序排列的邻近元素，直到完成整个文件的排序才停止 。 冒泡排序的主要优点是它易于实现，但实际上是否真的比插入排序和选择排序更容易实现值得商榷。 一般来说，冒泡排序会比其他两种方法要慢 。假如我们总是从右到左地移动文件。 第一遍中只要碰到最小元素，就用它左边的元素与它交换，最终将它放到数组的左末端 。 在第二遍中，将次小元素放到适当的位置，依此类推 。 因此，N遍足以完成排序任务，而且尽管冒泡排序将元素放到位要做更多的工作，但它的操作方式属于选择排序的一种。

希尔排序

希尔排序也称缩小增量排序，完全是为了优化插入排序而产生的。插入排序速度慢，因为它进行的唯一变换仅仅涉及到邻接项，因此，在数组中，项只能一次移动一个位置。如果最小数值在最右端，则需要N步将他移到位。希尔排序先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。

这里写图片描述

基本排序对应c源代码

sort.h

#ifndef SORT_H
#define SORT_H

#include <stdio.h>
typedef int Item;//定义排序的数据类型类型，为了实现万能比较，可以使用回调函数进行比较。
bool isSort(int *a , int N);
void DispalyItems(const Item *a , int N);
void SelectionSort(int *a , int N);
void InsertionSort(Item *a , int N);
void BubbleSort(Item *a , int N);
void ShellSort(Item *a , int N);
#endif // SORT_H

sort.c

#include <stdbool.h>
#include "sort.h"
static int less(Item a ,Item b)//为了是程序通用化，修改比较程序即可。
{
    if(a < b)
        return 1;
    else
        return 0;
}
static void exch(Item *a , int i , int j)
{
    Item swap = a[i];
    a[i] = a[j];
    a[j] = swap;
}
bool isSort(Item *a , int N)
{
    for(int i =1 ; i<N ; i++){
        if(less(a[i] , a[i-1]))
            return false;
    }
    return true;
}
void DispalyItems(const Item *a , int N)
{
    for(int i = 0 ; i < N ; i++)
        printf("%4d",a[i]);
    printf("\n");
}
void SelectionSort(Item *a , int N)//选择排序
{
    int i , j;
    int min;//记录最小项索引
    for(i = 0 ; i < N ; i++ ){
        min = i;
        for(j = i + 1 ; j< N ; j++)//找出后面最小项索引并记录
            if(less(a[j] , a[min]))
                min = j;
        exch(a , i , min);//最后一项自己和自己交换不变。
    }
}
void InsertionSort(Item *a , int N)//插入排序
{
    int i , j;
    for( i = 0 ; i < N ; i++)
        for(j = i ; j > 0 ; j--){
            if(less(a[j] , a[j-1]))//插入前面已经排好序项目中
                exch(a , j , j-1);
            else
                break;//可以停止了因为前面已经排好序了不必继续遍历
        }
}
void BubbleSort(Item *a , int N)//冒泡排序
{
    int i ,j;
    for(i = 0 ; i < N ; i++)
        for(j = i+1 ; j<N ; j++)
            if(less(a[j] , a[i]))//插入前面已经排好序项目中
                exch(a , i , j);
}
void ShellSort(Item *a , int N)//希尔排序和插入排序很像
{
    int i , j;
    int h = 1;//间隔大小
    while(h < N/3) h = 3 * h +1;//计算最大间隔。运用高纳德的 3n+1序列
    for( ; h >= 1 ; h /= 3 ){//h间隔一层循环
        for( i = h ; i < N ; i++)
            for(j = i ; j >= h ; j -= h){
                if(less(a[j] , a[j-h]))//插入前面已经排好序项目中
                    exch(a , j , j-h);
                else
                    break;//可以停止了因为前面已经排好序了不必继续遍历
            }
    }
}

main.c

#include "sort.h"
#include "stdlib.h"
#define N 100
int main(void)
{
    Item *a = (Item *)malloc(N * sizeof(Item));
    for(int i = 0 ; i < N ; i++)
        a[i] = 1000*(1.0*rand()/RAND_MAX);//产生随机数
    DispalyItems(a , N);
    ShellSort(a , N);
    if( isSort(a , N) )
        printf("sorted\n");
    else
        printf("not sorted\n");
    DispalyItems(a , N);
    return 0;
}

归并排序

分治思想：大问题分割成小问题解决，然后用所有小问题的答案来解决整个大问题。

归并排序是建立在归并操作上的一种有效的排序算法。该算法是分治法的一个非常典型的应用。首先考虑下如何将将二个有序数列合并。只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可，也就是下面merge实现的代码。
要将一个数组排序，可以先（递归地）将它分成两半分别排序，然后将结果归并起来。归并排序最吸引人的性质就是可以保证任意长度为N的数组排序所需要时间和NlgN成正比，缺点在于需要额外和N成正比的辅助空间。

自顶向下归并排序

/**************归并排序****************/
static void merge(Item *a , Item *aux , int lo , int mid , int hi)
{
    for(int k = lo ; k <= hi ; k++)
        aux[k] = a[k];//将a数组复制到aux
    int i = lo , j = mid + 1;
    for(int k = lo ; k <= hi ; k++){//合并
        if( i  > mid) a[k] = aux[j++];//左边数据取完
        else if(j > hi) a[k] = aux[i++];//右边数据取完
        else if( less(aux[j] , aux[i]) ) a[k] = aux[j++];//
        else a[k] = aux[i++];
    }
}
static void MSort(Item *a , Item *aux , int lo , int hi)
{
    if(hi <= lo) return ;
    int mid = lo + (hi - lo)/2;
    MSort(a , aux , lo , mid);//左半边排序
    MSort(a , aux , mid+1 , hi);//右半边排序
    merge(a , aux , lo , mid , hi);//归并
}
void MergeSort(Item *a , int N)
{
    Item *aux = (Item *)malloc(N * sizeof(Item));
    MSort(a , aux , 0 , N - 1);//递归调用
    free(aux);//释放缓冲空间
}
#define N 16
int main(void)
{
    Item *a = (Item *)malloc(N * sizeof(Item));
    for(int i = 0 ; i < N ; i++)
        a[i] = 1000*(1.0*rand()/RAND_MAX);//产生随机数
    DispalyItems(a , N);
    MergeSort(a , N);
    if( isSort(a , N) )
        printf("sorted\n");
    else
        printf("not sorted\n");
    DispalyItems(a , N);
    return 0;
}

下面两个图显示了递归调用的过程。
这里写图片描述
这里写图片描述

自底向上归并排序

先归并微型数组，然后再成对归并得到子数组。一张图搞定这个方法。

#define MIN(a , b) ( (a) > (b) ) ? (b) : (a)
static void MSort(Item *a , Item *aux , int lo , int hi)
{
    if(hi <= lo) return ;
    int mid = lo + (hi - lo)/2;
    MSort(a , aux , lo , mid);//左半边排序
    MSort(a , aux , mid+1 , hi);//右半边排序
    merge(a , aux , lo , mid , hi);//归并
}
void MergeBUSort(Item *a , int N)
{
    int sz , lo;
    Item *aux = (Item *)malloc(N * sizeof(Item));
    for(sz = 1 ; sz < N ; sz = sz + sz ){//sz子数组大小
        for( lo = 0 ; lo < N - sz ; lo += sz + sz){//lo子数组索引
            merge(a , aux , lo , lo+sz-1 , MIN(lo+sz+sz-1 , N-1));
        }
    }
    free(aux);//释放缓冲空间
}
#define N 16
int main(void)
{
    Item *a = (Item *)malloc(N * sizeof(Item));
    for(int i = 0 ; i < N ; i++)
        a[i] = 1000*(1.0*rand()/RAND_MAX);//产生随机数
    DispalyItems(a , N);
    MergeBUSort(a , N);
    if( isSort(a , N) )
        printf("sorted\n");
    else
        printf("not sorted\n");
    DispalyItems(a , N);
    return 0;
}

这里写图片描述

稳定性：排序算法，对于两个相等的键，排完序后都保存了他们的相对顺序，那么就说排序算法是稳定的。插入、归并排序都是稳定的。

快速排序

快速排序是一种分治的排序算法。可能是应用最为广泛的排序算法了，实现简单并且适用于各种不同的输入数据且在一般应用中比其他排序算法快。最牛的特点是原地排序（仅仅需要很小的辅助栈，一个暂存变量），且长度为N的数组排序所需要的时间和NlgN成正比。

这里写图片描述

/**************快速排序****************/
static int partition(Item *a , int lo , int hi)//快速排序的切分
{
    int i = lo , j = hi + 1;
    Item v = a[lo];//用来切分数组的元素
    while(1){
        while(less(a[++i] , v))//扫描左边直到比v大停止
            if(i == hi)
                break;
        while(less(v , a[--j]))//扫描右边直到比v小停止
            if(j == lo)
                break;
        if(i >= j)//检查是否指针i和j交叉
            break;
        exch(a , i , j);
    }
    exch(a , lo , j);//交换切分元素
    return j;//返回切分元素的索引
}
static void Psort(Item *a , int lo , int hi)//内部调用排序
{
    int j;
    if(hi < lo) return;
    j = partition(a , lo , hi);//切分
    Psort(a , lo , j-1);//左半部分排序，继续切分
    Psort(a , j+1 , hi);//右半部分排序，继续切分
}
void QuickSort(Item *a , int N)
{
    Psort(a , 0 , N-1);
}
#define N 16
int main(void)
{
    Item *a = (Item *)malloc(N * sizeof(Item));
    for(int i = 0 ; i < N ; i++)
        a[i] = 1000*(1.0*rand()/RAND_MAX);//产生随机数
    DispalyItems(a , N);
    QuickSort(a , N);
    if( isSort(a , N) )
        printf("sorted\n");
    else
        printf("not sorted\n");
    DispalyItems(a , N);
    return 0;
}

优先队列

许多应用要求我们使用按顺序排列的键来处理记录，但并不要求全部有序排列，或者所有的记录一次性排好。通常，搜集到一个记录集，处理其中具有最大键的记录；也许接着加入更多新目录，再处理具有当前最大键的记录，如此等等。这种情况下， 一个好的数据结构应该支持插入新记录、删除最大元素的运算，这样的数据结构称为优先队列 (priority queue) 。优先队列应该支持两种操作：删除最大元素和插入元素。
这里写图片描述
上图为优先队列实现过程，根据过程非常容易写出实现的代码。

数组实现

/**************优先队列数组实现***************************/
Item *pq;
int pqindex = 0;//记录优先队列中的元素个数。
void UnorderedArrayMaxPQ(int capacity)//动态创建优先队列缓冲区大小,并返回首地址
{
    pq = (Item *)malloc( sizeof(Item) * capacity);
}
bool pqisEmpty()
{
    return (pqindex == 0);
}
int pqSize()
{
    return pqindex;
}
void pqInsert(Item x)
{
    pq[pqindex++] = x;
}
Item pqdelMax()
{
    int max = 0 , i = 0;
    for( i = 0 ; i < pqindex ; i++){
        if(less(pq[max] , pq[i])) max = i;//找出最大元素下标
    }
    exch(pq , max , pqindex-1);//把最大元素交换到缓冲最后
    return pq[--pqindex];//返回最大元素，并且缓冲队列记录减去1
}
void dispalypq()
{
    int i;
    printf("pqsize = %d, " , pqindex);
    for( i = 0 ; i < pqindex ; i++){
        printf("%d   " , pq[i]);
    }
    printf("\n");
}

int main(void)
{
    UnorderedArrayMaxPQ(10);
    pqInsert(3);
    pqInsert(1);
    pqInsert(4);
    pqInsert(7);
    pqInsert(9);
    pqInsert(0);
    dispalypq();

    pqdelMax();
    dispalypq();

    pqdelMax();
    dispalypq();

    pqdelMax();
    dispalypq();

    pqdelMax();
    dispalypq();
    return 0;
}

这里写图片描述
实现起来很简单，通过一个数组缓冲数据，然后输出最大值而已。

二叉堆实现

堆：一种简单的数据结构，可以有效的支持基本优先队列运算。在堆中，记录保存在教组中，确保每个键大于其他两个指定位置的键。反过来，这两个键的每个键卫必须大于另外的两个键。将键看作一颗二叉树结构中的元素，那么当一颗二叉树的每个节点都大于等于他的两个子节点时，被称为堆有序。
二叉堆：是堆有序的完全二叉树，并在数组中按照层级储存（不使用数组第一个位置，因为那样表示更加方便。并且第一个元素可以当作哨兵元素）。
这里写图片描述
为了满足二叉堆规则：需要提供两种操作 swim（上浮），sink（下沉）。

swim操作为了消除子节点比父节点大：
这里写图片描述
sink操作为了消除父节点比子节点小：
这里写图片描述

通过swim和sink就可以通过二叉堆规则实现优先队列
其中insert操作，需要swim配合，delMax需要sink配合，这几个ppt图片已经清楚说明了操作详情。
这里写图片描述
这里写图片描述

#include "sort.h"
/**************优先队列二插堆实现***************************/
static Item *pq;
static int N;//优先队列索引
void PQinit(int maxN)
{
    pq = (Item *)malloc(sizeof(Item) * (maxN + 1));//分配缓冲空间
    N = 0;
}
static int less(Item a ,Item b)
{
    if(a < b)
        return 1;
    else
        return 0;
}
static void exch(Item *a , int i , int j)
{
    Item swap = a[i];
    a[i] = a[j];
    a[j] = swap;
}
static void swim(Item *a , int k)//插入元素上浮到合适位置
{
    while(k > 1 && less(a[k/2] , a[k])){//父节点小于子节点
        exch(a , k , k/2);//交换
        k = k/2;//索引下一次遍历
    }
}
static void sink(Item *a , int k , int N)//删除元素下沉到合适位置,N缓冲队列最后元素索引
{
    int j;
    while(2 * k <= N){
        j = 2*k;
        if(j < N && less(a[j] , a[j+1])  ) j++;//在子节点中选择较大的一个
        if(!less(a[k] , a[j])) break;//如果已经满足条件，结束循环
        exch(a , k , j);//交换父子节点
        k= j;//迭代，继续下次循环
    }
}
void PQinsert(Item k)
{
    pq[++N] = k;
    swim(pq,N);//将元素找到合适位置
}
Item delMax()
{
    exch(pq, 1 , N);//将最大元素换到队列尾部
    sink(pq , 1 , N-1);
    return pq[N--];//删除一个元素
}
void dispalypq()
{
    int i;
    printf("pqsize = %d, " , N);
    for( i = 1 ; i <= N ; i++){
        printf("%d   " , pq[i]);
    }
    printf("\n");
}
#include "sort.h"
#include "stdlib.h"
int main(void)
{
    PQinit(10);
//    bool pqisEmpty();
//    int  pqSize();
//    void dispalypq();
    PQinsert(3);
    PQinsert(1);
    PQinsert(4);
    PQinsert(7);
    PQinsert(9);
    PQinsert(0);
    dispalypq();

    delMax();
    dispalypq();

    delMax();
    dispalypq();

    delMax();
    dispalypq();

    delMax();
    dispalypq();
    return 0;
}

这里写图片描述
结果就是二叉堆形式的优先队列。

堆排序

1991年的计算机先驱奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德(Robert W．Floyd）和威廉姆斯(J．Williams）在1964年共同发明了著名的堆排序算法（Heap Sort)。堆排序在唯一利用空间和时间的方法，当空间十分紧张的时候，很流行，因为它并不不需要辅助，且只需要几行代码就可以实现，具有较好的性能。堆排序需要两步：
构造堆：将原始数组重新组织并安排进一个堆中。
下沉阶段：从堆中依次按递减顺序取出所有元素并取得排序结果。

构造堆可以从左到右遍历数组，通过上浮操作保证指针左边的元素已经是一个有序的完全二叉树即可，就像连续向优先队列里面插入元素一样。更好的方法是从右到左通过下沉方法构造一个堆，经过的的步骤明显比较小。实际过程就如同下图一样，一直使用下沉操作进行。下面示意图说明了一切。

这里写图片描述

void HeapSort(Item *a , int N)
{
    int k;
    for(k = N/2 ; k >=1 ; k--)//在原数组上面构造堆阶段
        sink(a , k , N);//N是最后元素索引
    while(N > 1){             //交换下沉操作
        exch(a , 1 , N);
        sink(a , 1 , --N);
    }
}

#include "sort.h"
#include "stdlib.h"
#define N 16
int main(void)
{
    Item *a = (Item *)malloc(((N+1)) * sizeof(Item));
    for(int i = 1 ; i < N+1 ; i++)
        a[i] = 1000*(1.0*rand()/RAND_MAX);//产生随机数
    DispalyItems(a+1 , N);
    HeapSort(a , N);//a[0]并没有用
    if( isSort(a+1 , N) )
        printf("sorted\n");
    else
        printf("not sorted\n");
    DispalyItems(a+1 , N);
    return 0;
}

这里写图片描述
这里写图片描述

排序应用及方法对比

这里写图片描述

有时需要偏执狂
关注
专栏目录
各种排序算法总结（ppt）
12-04
深入浅出的全面介绍 精妙总结 可以把握与运用排序
快速排序算法演示(PPT).rar
11-27
自己做的快速排序算法演示,是根据代码做成的PPT,里面有代码!PPT会一步一步分解排序算法，可以对照里面的代码进行查看。
大数据十大经典算法SVM-讲解PPT
07-02
大数据十大经典算法SVM-讲解PPT大数据十大经典算法SVM-讲解PPT大数据十大经典算法SVM-讲解PPT大数据十大经典算法SVM-讲解PPT
JavaScript实现经典排序算法之冒泡排序
11-27
冒泡排序可谓是最经典的排序算法了，它是基于比较的排序算法，时间复杂度为O(n^2)，其优点是实现简单，n较小时性能较好。 1）算法原理  相邻的数据进行两两比较，小数放在前面，大数放在后面，这样一趟下来，最小...
MoreWindows白话经典算法之七大排序第2版(高清)
09-10
本书《更多Windows白话经典算法之七大排序第2版》是一部深入浅出讲解七种经典排序算法的著作，旨在帮助读者理解并掌握冒泡排序、直接插入排序、直接选择排序、希尔排序、归并排序、快速排序以及堆排序等基本概念和...
JavaScript实现经典排序算法之选择排序
11-30
表现最稳定的排序算法之一，因为无论什么数据进去都是O(n²)的时间复杂度…..所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间。 1）算法原理  先在未排序序列中找到最小（大）元素，...
JavaScript实现经典排序算法之插入排序
01-19
插入排序的代码实现虽然... 插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上
十大经典排序算法堆排序详细图解（通俗易懂）
最新发布
09-26
十大经典排序算法堆排序详细图解（通俗易懂）十大经典排序算法堆排序详细图解（通俗易懂）十大经典排序算法堆排序详细图解（通俗易懂）十大经典排序算法堆排序详细图解（通俗易懂）十大经典排序算法堆排序详细图解...
排序算法的PPT文档
07-23
老师可以用得到。 有代表的算法都在里面。 还有算法解析，排序深度，时间，排序次数，等等。。很深透。物有所值
常用的排序算法(java实现)，附带一个PPT动画演示、详解了其中三种
06-29
1. 一个PPT 用动画演示了 插入排序，直接插入排序，希尔排序，附带讲解。 2. 附带其他几种常用排序的java实现的源码。 3. PPT 还是简洁、美观的，可用作模板。
快速排序ppt
11-20
几张树图快速掌握快速排序的方法，上课用的没有程序可以参考一下
C++10大排序算法PPT及代码示例，视频动图演示
06-27
冒泡排序、快速排序；：简单插入、希尔排序；简单选择、堆排序；简单归并、多路归并；计数排序；桶排序；基数排序的PPT讲解及代码演示
内部排序算法资料（PPT+java代码）
08-14
内部排序算法资料（PPT+java代码）
发现一个理解  快速排序和堆排序  很好的 PPT文件 ：分享
liNewman的博客
05-22 213
发现一个理解  快速排序和堆排序  很好的 PPT文件 ：分享 发现一个理解  快速排序算法  很好的 PPT文件 ：分享  http://wenku.baidu.com/link?url=59S_uFigK9mG9g7G7b9J1qL5u7tL8J7KG35_fuXRGLgToAnRsojZI30bz-BHxEjqu-tiFG7Gjj1...
c语言的排序算法ppt,C语言常见排序算法.ppt
weixin_36241447的博客
05-25 283
C语言常见排序算法.ppt上章回顾,二叉树的定义 树深度的定义 什么样的二叉树是满二叉树 中序遍历的规则,常见排序算法,第六章,预习检查课程目标,本章概述 几种常见排序算法。 本章目标 熟悉常见的查找算法和排序算法 难点 快速排序算法,本章结构,数据结构与算法初步常见的排序算法,6.1 常见的排序算法,冒泡排序 快速排序 直接插入排序 希尔排序 选择排序 堆排序 归并排序,6.1.1 冒泡排序算法...
排序算法 演示动画 matlab,排序算法及MATLAB实现ppt课件.ppt
weixin_34385646的博客
03-24 322
《排序算法及MATLAB实现ppt课件.ppt》由会员分享，可在线阅读，更多相关《排序算法及MATLAB实现ppt课件.ppt(40页珍藏版)》请在人人文库网上搜索。1、排序算法,1,排序,例：对1、9、6、11、3这5个数字进行从小到大排序？ 结果：1、3、6、9、11 思考：如何编程让计算机完成排序？,2,排序算法的种类：,1、冒泡排序(Bubble Sort) 2、选择排序(Selectio...
c语言排序算法存储结构,数据结构(c语言)--种排序算法.ppt
weixin_33397994的博客
05-20 283
数据结构(c语言)--种排序算法6. 记录和排序表的数据结构 在本章的讨论中，除特殊声明外，一般采用顺序结构存储排序表。 记录和排序表的类型定义如下： #define MAXNUM … /* MAXNUM 为足够大的数*/ typedef struct { keytype key; /*关键码字段*/ ...
排序算法解析：八大经典排序法
它通过将数组按某一增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。 8. **计数排序**： 计数排序不是基于比较的排序...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

有时需要偏执狂

请我喝咖啡

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值