排序总结(C++)

最新推荐文章于 2024-07-10 21:04:15 发布
最新推荐文章于 2024-07-10 21:04:15 发布
阅读量191 收藏
点赞数
文章标签： c/c++ 数据结构与算法 shell
原文链接：https://segmentfault.com/a/1190000013022277
版权

冒泡排序

基础知识

  • 冒泡排序：比较相邻的元素。如果第一个比第二个大，就交换他们两个。每次最外面的循环，得到一个最小值。
  • 时间复杂度：$O(n^2)$
https://blog.csdn.net/guoweim...

代码实现

#include <iostream>
using namespace std;

int a[10] = {3,2,7,5,1,9,6,4,0,8};

void BubbleSort(int a[], int n){
    for(int i=0; i<n-1; i++){//控制外循环次数
        for(int j=0; j<n-1-i; j++){
            if(a[j+1] < a[j]){
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
    /*
        for(int i=0; i<n-1; i++){
        for(int j=i+1; j<n; j++){
            if(a[j] < a[i]){
                int temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
    }
    */
}

int main() {
    int size = sizeof(a)/sizeof(a[0]);
    cout<<"........before sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;

    BubbleSort(a, size);
    cout<<"........after sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;
    return 0;
}

clipboard.png

快速排序

基础知识

  • 快速排序采用的是分治的思想。

  • 基本思路：

    • 在数据集之中，选择一个元素作为“基准”。
    • 所有小于“基准”的元素，都移到“基准”的左边；所有大于“基准”的元素，都移到“基准”的右边。
    • 对“基准”左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。

  • 注意：

    • 要先从右边哨兵开始寻找（这样做的是保证哨兵i和哨兵j共同指向的元素比“基准”小）
    • 交换的前提是：哨兵i指向的元素比“基准”大，哨兵j指向的元素比“基准”小，且哨兵i比哨兵j小。
  • 算法复杂度：$O(nlog_2n)$

clipboard.png

代码实现

#include <iostream>
using namespace std;

int a[10] = {3,2,7,5,1,9,6,4,0,8};

void quickSort(int a[], int left, int right){
    if(left>right)  return;
    int temp = a[left];
    int i = left;
    int j = right;
    while(i != j){
    //注意顺序，保证右边哨兵最先开始
        while(i<j && a[j]>=temp){
            j--;
        }
        while(i<j && a[i]<=temp){
            i++;
        }
        if(i<j){
            int temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
    }

    a[left]  = a[i];
    a[i] = temp;

    quickSort(a,left, i-1);
    quickSort(a, i+1, right);
}

int main() {
    int size = sizeof(a)/sizeof(a[0]);
    cout<<"........before sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;

    quickSort(a, 0, size-1);
    cout<<"........after sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;
    return 0;
}

插入排序

基本知识

  • 插入排序:将一个记录插入到已排序好的有序表中，从而得到一个新的有序序列
  • 时间复杂度：$O(n^2)$

clipboard.png

代码实现

#include <iostream>
using namespace std;

int a[10] = {3,2,7,5,1,9,6,4,0,8};
int temp[10];

void InsertSort(int a[] , int n){
    for(int i=0; i<n; i++){
        for(int j=i; j>0; j--){
            if(a[j]<a[j-1]){
                int temp = a[j];
                a[j] = a[j-1];
                a[j-1] = temp;
            }
        }
    }
}

int main() {
    int size = sizeof(a)/sizeof(a[0]);
    cout<<"........before sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;

    InsertSort(a, size);
    cout<<"........after sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;
    return 0;
}

clipboard.png

Shell排序

基础知识

  • Shell排序是插入排序的一种，它是针对直接插入排序算法的改进。该方法又称缩小增量排序。
  • 对于n个待排序的数列，取一个小于n的整数gap(gap被称为步长)将待排序元素分成若干个组子序列，所有距离为gap的倍数的记录放在同一个组中；然后，对各组内的元素进行直接插入排序。 这一趟排序完成之后，每一个组的元素都是有序的。然后减小gap的值，并重复执行上述的分组和排序。重复这样的操作，当gap=1时，整个数列就是有序的。
  • 时间复杂度：$O(n^{1.3})$

clipboard.png

代码实现

#include <iostream>
using namespace std;

int a[10] = {3,2,7,5,1,9,6,4,0,8};


void ShellSort(int a[], int n){
    int i,j,gap;
    for(gap = n/2; gap>0; gap /=2){
    //以下是快速插入排序
        for(i=gap; i<n; i++){
            for(j=i; j>0; j -=gap){
                if(a[j-gap]>a[j]){
                    int temp = a[j-gap];
                    a[j-gap] = a[j];
                    a[j] = temp;

                }
            }
        }
    }
}

int main() {
    int size = sizeof(a)/sizeof(a[0]);
    cout<<"........before sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;

    ShellSort(a, size);
    cout<<"........after sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;
    return 0;
}

clipboard.png

选择排序

基础知识

  • 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
  • 时间复杂度：$O(n^2)$

clipboard.png

代码实现

#include <iostream>
using namespace std;

int a[10] = {3,2,7,5,1,9,6,4,0,8};

void SelectSort(int a[], int n){
    for(int i=0; i<n-1; i++){//每次循环，寻找到i位置最小的值
        int index = i;
        //index用来记录最小元素的下标
        for(int j=i+1; j<n; j++){
            if(a[j] < a[index]){
                index = j;
            }
        }

        if(index != i){
            int temp = a[index];
            a[index] = a[i];
            a[i] = temp;
        }
    }
}

int main() {
    int size = sizeof(a)/sizeof(a[0]);
    cout<<"........before sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;

    SelectSort(a, size);
    cout<<"........after sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;
    return 0;
}

堆排序

基础知识

  • 堆排序是一种树形选择排序，在排序过程中可以把元素看成是一颗完全二叉树，每个节点都大（小）于它的两个子节点。
  • 当每个节点都大于等于它的两个子节点时，就称为大顶堆，也叫堆有序； 当每个节点都小于等于它的两个子节点时，就称为小顶堆。

  • 完全二叉树的规律：

    • 索引为i的左孩子的索引是 (2*i+1);
    • 索引为i的左孩子的索引是 (2*i+2);
    • 索引为i的父结点的索引是 (i-1)/2;

  • 算法思想：

    • 将长度为n的待排序的数组进行堆有序化构造成一个大顶堆
    • 将根节点与尾节点交换并输出此时的尾节点
    • 将剩余的n -1个节点重新进行堆有序化
    • 重复步骤2，步骤3直至构造成一个有序序列
  • 时间复杂度：$O(nlog_2n)$

clipboard.png
clipboard.png
clipboard.png
clipboard.png

代码实现

#include <iostream>
using namespace std;

int a[10] = {3,2,7,5,1,9,6,4,0,8};

void swap(int a[], int i, int j){
    int temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

void heapAdjust(int a[], int i, int len){//保证根节点最大
    int left, right, child;

    while(2*i+1 <= len){判断当前节点有无左节点，保证当前节点不是叶子节点
        left = 2*i+1;        
        right = left+1;
        child = left;
        if(left<len && a[left]<a[right]){
            child++;//左右子节点的最大值
        }
        if(a[i]<a[child]){//当前节点比孩子节点要小，需要调整位置
            swap(a, i, child);
        }
        else
            break;

        i = child;
    }
}

void heapSort(int a[], int n){
    for(int i=(n-1)/2; i>=0; i--){//从最后一个非叶子节点开始构建大顶堆，以上图例子(8-1)/2=3,也就是说a[3]以后都是叶子节点。
        heapAdjust(a, i, n);
    }

    n = n-1;//因为下标从0开始，所以尾节点下标是n-1
    while(n>0){
        swap(a, 0, n);//交换根节点与尾节点
        n--;//把尾节点排除在外
        heapAdjust(a, 0, n);
    }
}

int main() {
    int size = sizeof(a)/sizeof(a[0]);
    cout<<"........before sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;

    heapSort(a, size);
    cout<<"........after sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;
    return 0;
}

归并排序（合并排序）

基础知识

  • 归并排序采用的是分治的思想；
  • 归并操作即将两个已经排序的序列合并成一个序列的操作；

  • 基本实现：

    • 分解：将当前区间一分为二，并递归的对左右子区间进行分解，直到子区间长度为1；
    • 合并：将两个有序的子区间合并成一个有序的区间。
      clipboard.png
  • 时间复杂度：$nlogn$（理解：分解可以理解为n个节点的完全二叉树层数为$log_2n$,即$O(logn)$;合并可以理解为每层都需要扫描比较一遍所有数据，所以为$O(n)$）

代码实现

#include <iostream>
using namespace std;

int a[10] = {3,2,7,5,1,9,6,4,0,8};
int temp[10];

void Merge(int a[], int start, int mid, int end, int temp[]){
    int pb = 0;
    int p1 = start;
    int p2 = mid+1;

    while(p1<=mid && p2<=end){
        if(a[p1] < a[p2]){
            temp[pb++] = a[p1++];
        }
        else{
            temp[pb++] = a[p2++];
        }
    }

    while(p1<=mid){
        temp[pb++] = a[p1++];
    }
    while(p2<=end){
        temp[pb++] = a[p2++];
    }

    for(int i=0; i<end-start+1; i++){
        a[start+i] = temp[i];
    }
}

void MergeSort(int a[], int start, int end, int temp[]){
    if(start<end){
        int mid = start + (end - start)/2;

        MergeSort(a, start, mid, temp);
        MergeSort(a, mid+1, end, temp);

        Merge(a, start, mid, end, temp);
    }
}

int main() {
    int size = sizeof(a)/sizeof(a[0]);
    cout<<"........before sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;

    MergeSort(a, 0, size-1, temp);
    cout<<"........after sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;
    return 0;
}

clipboard.png

桶排序

基础知识

  • 时间复杂度：$O(n+K)$
  • 工作的原理是将数组分到有限数量的桶里。每个桶再个别排序。
  • 桶排序使用线性时间，并不是比较排序。

clipboard.png

代码实现

//一种最简单的桶排序
#include <iostream>
#include <cstring>

using namespace std;

int a[10] = {3,2,7,5,1,9,6,4,0,8};

void bucketSort(int a[], int size, int max){
//size是待排序数组的大小；max是待排序数组中的最大值
    int buckets[max];
    memset(buckets, 0, max* sizeof(int));

    for(int i=0; i<size; i++){
        buckets[a[i]]++;
    }
    int i,j;
    for(i=0,j=0; i<max; i++){
        while(buckets[i]>0){
            buckets[i]--;
            a[j] = i;
            j++;

        }
    }
}
int main() {
    int size = sizeof(a)/sizeof(a[0]);
    cout<<"........before sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;

    bucketSort(a, size, 10);
    cout<<"........after sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;
    return 0;
}

计数排序

基础知识

  • 计数排序是一种非基于比较的排序算法，其空间复杂度和时间复杂度均为$O(n+k)$，其中k是整数的范围。快于任何比较排序算法。
  • 它是基数排序的一个关键部分。

clipboard.png

代码实现

#include <iostream>
#include <cstring>

using namespace std;

int a[6] = {0,7,2,6,0,8};

int getMax(int a[], int size){
    int max = a[0];
    for(int i=1; i<size; i++){
        if(max<a[i]){
            max = a[i];
        }
    }
    return max;
}
void countSort(int a[], int size){
    int max = getMax(a, size)+1;
    int output[size];
    memset(output, 0, size* sizeof(int));
    int buckets[max];
    memset(buckets, 0, max* sizeof(int));

    for(int i=0; i<size; i++){
        buckets[a[i]]++;
    }
    for(int i=0; i<max; i++){
        buckets[i+1] += buckets[i];
    }
    cout<<buckets[max]<<endl;
    for(int i=0; i<size; i++){
        output[buckets[a[i]]-1] = a[i];
        buckets[a[i]]--;
    }
    for (int i = 0; i < size; ++i) {
        a[i] = output[i];
    }
}


int main() {
    int size = sizeof(a)/sizeof(a[0]);
    cout<<"........before sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;

    countSort(a, size);
    cout<<"........after sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;
    return 0;
}

基数排序

基础知识

  • 主要思想：将所有待比较数值(注意,必须是正整数)统一为同样的数位长度，数位较短的数前面补零。 然后，从最低位开始, 依次进行一次稳定排序。（从低位开始的原因是：如果要从高位排序，那么次高位的排序会影响高位已经排好的大小关系。在数学中， 数位越高，数位值对数的大小的影响就越大。）

clipboard.png

  • 举个例子：

clipboard.png
clipboard.png

代码实现

#include <iostream>
using namespace std;

int a[10] = {13,2,90,165,211,768,89,889,0,28};

int getMax(int a[], int size){
    int max = a[0];
    for(int i=1; i<size; i++){
        if(max<a[i]){
            max = a[i];
        }
    }
    return max;

}

void countSort(int a[], int size, int exp){
    int output[size];//注意这是动态数组，在堆上分配，需要delete。
    for(int i=0; i<size; i++){
        output[i] = 0;
    }
    /*
     * int output[size];
     *
     * delete output;
     * */

    int buckets[10]={0};

    for(int i=0; i<size; i++){
        buckets[(a[i]/exp)%10]++;
    }

    for(int i=0; i<10; i++){
        buckets[i+1] +=buckets[i];
    }

    for(int i=size; i>=0; i--){/*这里需要注意，从大开始递减。
    原因是：buckets[(a[i]/exp)%10](临时数组的下标)的值是递减的；
    第一轮循环以后，个位值大的在数组下标大。因此相同十位的数，数组下标大的先进临时数组。*/
        output[buckets[(a[i]/exp)%10]-1] = a[i];//因为索引是从0开始的，所以要减1
        buckets[(a[i]/exp)%10]--;
    }

    for(int i=0; i<size; i++){
        a[i] = output[i];
    }

    //delete output;
}

void radixSort(int a[], int size){
    int exp;
    int max = getMax(a, size);
    for(exp=1; max/exp>0; exp *= 10){
        countSort(a,size,exp);
    }
}

int main() {
    int size = sizeof(a)/sizeof(a[0]);
    cout<<"........before sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;

    radixSort(a, size);
    cout<<"........after sort........"<<endl;
    for(int i=0; i<size; i++){
        cout<<a[i]<<",";
    }
    cout<<endl;
    return 0;
}

总结

内排序与外排序

  • 内排序：指在排序期间数据对象全部存放在内存的排序。以上讲的都是内部排序。
  • 外排序：指在排序期间全部对象太多，不能同时存放在内存中，必须根据排序过程的要求，不断在内，外存间移动的排序。

基于比较的排序

  • 基于比较的排序：插入排序，选择排序，交换排序，归并排序。基于比较的排序算法是不能突破$O(nlog_2n)$的。n个数有$n!$个可能的排列情况，也就是说基于比较的排序算法的判定树有$n!$个叶子结点，比较次数至少为$log(n!)=O(nlogn)$(斯特林公式)。
  • 基于线性的排序（非比较排序）：计数排序，桶排序，基数排序。不受$O(nlog_2n)$$的影响。其时间复杂度依赖于数据的范围。非基于比较的排序算法的使用都是有条件限制的，例如元素的大小限制等。

clipboard.png

参考： https://www.cnblogs.com/zyb42...
weixin_34406061
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++排序算法-冒泡排序
11-08
冒泡排序的步骤可以总结为以下几点： 1. 从序列的第一个元素开始，比较相邻的两个元素。 2. 如果前一个元素大于后一个元素，就交换它们的位置。 3. 继续对每一对相邻元素进行相同的操作，直到序列的最后一个元素。 4...
c++排序函数总结
06-17
c++常用排序算法总结，代码实现简洁易懂，方便大家参考使用。
【C/C++】排序总结
weixin_34075551的博客
04-21 66
#pragmaonce #include<iostream> #include<assert.h> usingnamespacestd; //直接排序：指的是设定2个下标/指针。然后从下标1开始进行比较， //升序情况下：若在前的下标/指针大于当前比较数值。就进行数组的后移。 //直到满足当前序列值。然后最终将当前比较数值进行替换。 //PS：...
C++排序总结
面包的博客
03-29 894
顺序如下： 1.各排序算法实现 2.各排序算法比较 1.1选择排序 把选择排序写在前面，因为这是我上学以来学的第一个排序算法 思路：在第i次处理中选出从i到len-1的最小值，将其与当前i位置上的元素进行交换 #include #include #include using namespace std; template void selectSort(T *num,int le
四种基本排序总结（C++）
TOP_handsome的博客
04-28 557
标题四种基本排序总结（C++） 一、选择排序 思路：现将一组数输入数组，从第一个数开始比较，与其后面的每一个数进行比较，若后面的数字比位于第一个位置的数字小的话，两个数字进行交换，当第一个位置的数字与它后面的所有数字比较（交换）过后，第一个位置上的数字就是最小的数字。再从第二个数字比较，同理再经过一遍比较后，第二位的数字是第二小的数字…以此类推，最后在这个数组中已经从小到大排好了顺序，再将此数组依...
排序C++实现总结
weixin_42077777的博客
10-02 174
几种排序算法实现C++冒泡排序简单选择排序插入排序希尔排序堆排序归并排序快速排序 注：本文所有代码源自《数据结构与算法C++描述》一书 冒泡排序 简单选择排序 插入排序 基本思想：已知从位置0到位置p-1都是排过序的状态，在前p+1个位置找到第p个元素的正确位置。 最坏 N(N+1)/2; 平均 N(N+1)/4 //简单的插入排序 template<typename Comparable> void insertionSort(vector<Comparable> &a
c++排序算法总结
qq_30111427的博客
04-06 645
c++排序算法总结
c++排序算法
11-24
此排序算法为本人平常学习练习所写，在学习的过程中也是非常希望和大家分享交流
详细总结C++的排序算法
12-26
它概括了数据结构中的所有常见的排序算法，给大家总结如下。 区分稳定与不稳定：快速、希尔、堆、选择不稳定，其他排序算法均稳定。 平均时间复杂度：冒泡，选择，插入是O(n2)，其他均是O(n*log2n) 最坏时间复杂度：...
各种常见排序代码 C++
04-04
各种常见的排序代码，总结一版，方便筒子们下载。使用c++实现，有需要添加的，可在评论区留言
C++排序算法总结
weixin_45259896的博客
10-09 151
一：排序算法考察指标 考察排序算法，我们一般要考察算法的复杂度和算法是否是稳定排序。稳定排序是指在一个序列中，A与B的值相等，经过排序后，A与B的相对顺序没有改变，则该算法称为稳定排序。 二：初等排序算法 void swap(int *a,int *b){ int v; v = *a; *a = *b; *b = v; } int insertSort(int *A,int N)｛ int i,j,v,sw=0; for(i=1;i<N-1;i++){ v = A[i]; j =
c++实验1-排序
zhnchun12的博客
03-14 309
一.问题及代码#include void main() { int a,b,c,t; cin>>a>>b>>c; if(a>b) { t=a; a=b; b=t; } if(a>c) { t=a; a=c; c=t; } if(b>c)
C++常用排序总结
jxhaha的博客
04-19 327
#include<iostream> #include<stdlib.h> #include<time.h> #include<chrono> #include<string> using namespace std; const int MAX_NUM = 1000; //没有任何基于比较的算法能够保证使用少于log(N!)~NlogN次比较将长度为N的数组排序 //选择排序与输入无关，不管输入是
c++常见的几种排序算法总结
云淡风轻、仅此一抹
08-14 3138
原文：c++常见的几种排序算法总结 源代码下载地址：http://www.zuidaima.com/share/1829391352843264.htm 常见的几种排序:冒泡排序、鸡尾酒排序、直接插入排序、折半插入排序、快速排序、桶排序、鸽巢排序、选择排序、奇偶排序、计数排序。 #include "stdafx.h" #include #include #include
C/C++十大排序大总结
小白的逆袭
06-23 1411
BubbleSort（冒泡排序） 定义：在同一个数组中，从数组第一个数开始，相邻两个数进行比较，按照小左大右或者大右小左的顺序，依次循环遍历，进行排序！ void BubbleSort(int *arr,int Length) { int i = 0; int j = 1; int sys = 0; for (i = 0; i < Length-1;...
NOIP 2017 赛前集训总结 C++版
McDonnell_Douglas的博客
11-05 2926
ps:csdn莫名其妙吞我制表符和空格，若看着不爽，，忍着吧 愉(坑)快(爹)的十月总算撑过去了(感觉身体被掏空。。)，，老衲终于从一个蒟蒻变成了另一个蒟蒻(没什么不对的。。），，回忆去年愉(悲)快(伤)的NOIP经历，，，(怎么办，感觉又要挂了)，，我们来总结一发惨痛的经验教训，，。 (在说正文之前我想先来一个*蛤蛤蛤*的笑容)
C++排序算法总结（可执行代码）
一叶知秋
09-10 7579
常见的分类算法还可以根据排序方式分为两大类：比较排序和非比较排序。本文中前七种算法都是比较排序，非比较排序有三种，分别为： 　　1）计数排序(Count Sort)（复杂度O(n+k)（其中k是待排序的n个数字中最大值） 　　2）基数排序(Bucket Sort)（复杂度O(nk)（其中k是最大数字的位数）        3）桶排序(Radix Sort)（复杂度O(n+k)（其中k...
C++类与对象-基础篇
最新发布
都市隸人的博客
07-10 1522
本文介绍了类与对象的基础知识，详细介绍了类的定义及使用
排序算法的比较 C++.docx
11-10
本文档深入探讨了C++中的排序算法比较，重点介绍了排序在计算机...总结来说，这个文档不仅提供了排序算法的基础知识，而且强调了在实际编程中的应用和性能优化，有助于学习者理解和实践C++中的排序算法，提升编程技能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值