数据结构期末作业（内部排序算法比较）

最新推荐文章于 2024-07-24 15:28:00 发布
最新推荐文章于 2024-07-24 15:28:00 发布
阅读量83 收藏
点赞数 1
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_72974455/article/details/132182068
版权

 题目要求：

内部排序算法比较

[问题描述]

各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大概执行时间。试通过随机的数据比较各算法的关键字比较次数和关键字移动次数，以取得直观感受。

[基本要求]

（1） 对以下8种常用的内部排序算法任意选择8种进行比较：直接插入排序；希尔排序；冒泡排序；快速排序；简单选择排序；堆排序；归并排序；基数排序。

（2） 待排序表的表长不小于100；其中的数据要用伪随机数产生程序产生；至少要用5组不同的输入数据作比较；比较的指标为有关键字参加的比较次数和关键字移动次数（关键字交换计为3次移动）。

[测试数据]

由随机产生器决定。

[实现提示]

主要工作是设法在程序中适当的地方插入计数操作。程序还可以包括计算几组数据得出结果波动大小的解释。注意分块调试的方法。

 代码：

#include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#define SIZE 2000
typedef struct Radix
{
 	int nValue;
 	struct Radix *pNext;
}Radix;

void MIN(double *average_move,double *average_compare);

void Insert_sort(int *number,int n,int &move,int &compare,int &sing);


void Shell_sort(int *number,int n,int &move,int &compare,int &sing);


void Bubble_sort(int *number,int n,int &move,int &compare,int &sing);

int partition(int *number, int s, int t);
void Quick_sort(int *number,int s,int t,int &move,int &compare,int &sing);


void Selection_sort(int *number,int n,int &move,int &compare,int &sing);

void Down(int a[], int i, int n);
void Build_Heap(int a[], int size);
void Heap_sort(int *number,int n,int &move,int &compare,int &sing);


void Merge(int *number,int left,int right,int mid,int &move,int &compare);
void Merge_sort(int *number,int left,int right,int &move,int &compare,int &sing);


void Radix_sort(int *number,int n,int &move,int &compare,int &sing);

void print(double *move,double *compare);
void Genert_random_numbers(int *number,int n);
double average(int *shu);
void Error(int sing);
void PRINT(double *move,double *compare);

int main () {
	int x,i=0;
	double average_move[8],average_compare[8];
	do{
		printf ("*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\n*\n");
		printf ("* 1: 输入1生成数据表格      *\n*\n");
		printf ("* 2: 输入-1退出程序         *\n*\n");
		printf ("* 3: 输入0得出结论          *\n*\n"); 
		printf ("*-*-*-*-*-*-*-*-*-*-*-*-*-*-*\n") ;
		printf ("* 请输入：");
		scanf ("%d",&x);
		if (x==1){
			printf ("case %d:\n",i++);
			MIN(average_move,average_compare);
			printf ("\n");
			printf ("是否输出最小结果：1(输出) 2(不输出)\n请输入1或2：");
			int c;
			scanf ("%d",&c);
			if (c==1){
				print(average_move,average_compare); 
			} 
		}else if (x==0){
			print(average_move,average_compare); 
		}else if (x==-1){
			printf ("退出程序");
			break;
		}
		
	}while(1);
	return 0;
}
void MIN(double *average_move,double *average_compare){
	int n=SIZE,j,i,k;
	int Insert_move[6]= {0},Insert_compare[6]= {0};
	int Shell_move[6]= {0},Shell_compare[6]= {0};
	int Bubble_move[6]= {0},Bubble_compare[6]= {0};
	int Quick_move[6]= {0},Quick_compare[6]= {0};
	int Simple_selection_move[6]= {0},Simple_selection_compare[6]= {0};
	int Heap_move[6]= {0},Heap_compare[6]= {0};
	int Merge_move[6]= {0},Merge_compare[6]= {0};
	int Radix_move[6]= {0},Radix_compare[6]= {0};
	int number[SIZE];
	int left=0,right=n-1,s=0,t=n-1;
	for (k=0; k<8; k++) {
		for (j=0; j<6; j++) {
			Genert_random_numbers(number,n);
			int sing=-1;
			switch(k) {
				case 0: 
					Insert_sort(number,n,Insert_move[j],Insert_compare[j],sing);
					break;
				case 1:
					Shell_sort(number,n,Shell_move[j],Shell_compare[j],sing);
					break;
				case 2:
					Bubble_sort(number,n,Bubble_move[j],Bubble_compare[j],sing);
					break;
				case 3:	
					Quick_sort(number,s,t,Quick_move[j],Quick_compare[j],sing);
					break;
				case 4:
					Selection_sort(number,n,Simple_selection_move[j],Simple_selection_compare[j],sing);
					break;
				case 5:
					Heap_sort(number,n,Heap_move[j],Heap_compare[j],sing);
					break;
				case 6:
					
					Merge_sort(number,left,right,Merge_move[j],Merge_compare[j],sing);
					break;
				case 7:
					Radix_sort(number,n,Radix_move[j],Radix_compare[j],sing);
					break;
			}
			if (sing!=-1)Error(sing);
		}
	}

	for (k=0; k<8; k++) {
		switch(k) {
			case 0:
			average_move[k]=average(Insert_move);
				average_compare[k]=average(Insert_compare);
				break;
			case 1:
				average_move[k]=average(Shell_move);
				average_compare[k]=average(Shell_compare);
				break;
			case 2:
				average_move[k]=average(Bubble_move);
				average_compare[k]=average(Bubble_compare);
				break;
			case 3:
				average_move[k]=average(Quick_move);
				average_compare[k]=average(Quick_compare);
				break;
			case 4:
				average_move[k]=average(Simple_selection_move);
				average_compare[k]=average(Simple_selection_compare);
				break;
			case 5:
				average_move[k]=average(Heap_move);
				average_compare[k]=average(Heap_compare);
				break;
			case 6:
				average_move[k]=average(Merge_move);
				average_compare[k]=average(Merge_compare);
				break;
			case 7:
				average_move[k]=average(Radix_move);
				average_compare[k]=average(Radix_compare);
				break;
			}
		}
	PRINT(average_move,average_compare);
}
void print(double *move,double *compare){
	int move_min=0,compare_min=0;
	for (int i=0;i<8;i++){
		if (move[i]<move[move_min]){
			move_min=i;
		}
		if (compare[i]<compare[compare_min]){
			compare_min=i;
		}
	}
	switch(move_min){
		case 0:
			printf ("插入排序次数移动最少：移动次数平均数为%f\n\n",move[move_min]);
			break;
		case 1:
			printf ("希尔排序次数移动最少：移动次数平均数为%f\n\n",move[move_min]);
			break;
		case 2:
			printf ("冒泡排序次数移动最少：移动次数平均数为%f\n\n",move[move_min]);
			break;
		case 3:
			printf ("快速排序次数移动最少：移动次数平均数为%f\n\n",move[move_min]);
			break;
		case 4:
			printf ("简单选择排序次数移动最少：移动次数平均数为%f\n\n",move[move_min]);
			break;
		case 5:
			printf ("堆排序次数移动最少：移动次数平均数为%f\n\n",move[move_min]);
			break;
		case 6:
			printf ("归并排序次数移动最少：移动次数平均数为%f\n\n",move[move_min]);
			break;
		case 7: 
			printf ("基数排序次数移动最少：移动次数平均数为%f\n\n",move[move_min]);
			break;
	 } 
	 switch(compare_min){
		case 0:
			printf ("插入排序次数比较最少：比较次数平均数为%f\n\n",compare[compare_min]);
			break;
		case 1:
			printf ("希尔排序次数比较最少：比较次数平均数为%f\n\n",compare[compare_min]);
			break;
		case 2:
			printf ("冒泡排序次数比较最少：比较次数平均数为%f\n\n",compare[compare_min]);
			break;
		case 3:
			printf ("快速排序次数比较最少：比较次数平均数为%f\n\n",compare[compare_min]);
			break;
		case 4:
			printf ("简单选择排序次数比较最少：比较次数平均数为%f\n\n",compare[compare_min]);
			break;
		case 5:
			printf ("堆排序次数比较最少：比较次数平均数为%f\n\n",compare[compare_min]);
			break;
		case 6:
			printf ("归并排序次数比较最少：比较次数平均数为%f\n\n",compare[compare_min]);
			break;
		case 7: 
			printf ("基数排序次数比较最少：比较次数平均数为%f\n\n",compare[compare_min]);
			break;
	 } 
	
} 
void Genert_random_numbers(int *number,int n) {
	int i=0;
	srand((unsigned int)time(NULL));
	for (i=0; i<n; i++) {

		number[i]=rand()%(1000-10+1)+10;
	}
}
void Error(int sing) {
	switch(sing) {
		case 0:
			printf ("Insert_sort han shu fan hui cuo wu\n");
			break;
		case 1:
			printf ("Shell_sort han shu fan hui cuo wu\n");
			break;
		case 2:
			printf ("Bubble_sort han shu fan hui cuo wu\n");
			break;
		case 3:
			printf ("Quick_sort han shu fan hui cuo wu\n");
			break;
		case 4:
			printf ("Selection_sort han shu fan hui cuo wu\n");
			break;
		case 5:
			printf ("Heap_sort han shu fan hui cuo wu\n");
			break;
		case 6:
			printf ("Merge_sort han shu fan hui cuo wu\n");
			break;
		case 7:
			printf ("Radix_sort han shu fan hui cuo wu\n");
			break;
	}
}
void PRINT(double *move,double *compare) { 
	for (int i=0;i<50;i++){
		printf("_"); 
	}
	printf ("\n");
	int len=10,i,j;
	            printf ("| Sort_name     | Average_move   Average_compare  |\n");
	            printf ("|               |");
	printf ("\n");
	for (i=0; i<8; i++) {
		switch(i) {
			case 0:
				printf ("| Insert_sort   | %-8.2f       %-8.2f         |\n",move[i],compare[i]);
				printf ("|               |                           ");
				break;
			case 1:
				printf ("| Shell_sort    | %-8.2f       %-8.2f         |\n",move[i],compare[i]);
				printf ("|               |");
				break;
			case 2:
				printf ("| Bubble_sort   | %-8.2f       %-8.2f         |\n",move[i],compare[i]);
				printf ("|               |");
				break;
			case 3:
				printf ("| Quick_sort    | %-8.2f       %-8.2f         |\n",move[i],compare[i]);
				printf ("|               |");
				break;
			case 4:
				printf ("| Selection_sort| %-8.2f       %-8.2f         |\n",move[i],compare[i]);
				printf ("|               |");
				break;
			case 5:
				printf ("| Heap_sort     | %-8.2f       %-8.2f         |\n",move[i],compare[i]);
				printf ("|               |");
				break;
			case 6:
				printf ("| Merge_sort    | %-8.2f       %-8.2f         |\n",move[i],compare[i]);
				printf ("|               |");
				break;
			case 7:
				printf ("| Radix_sort    | %-8.2f       %-8.2f         |\n",move[i],compare[i]);
				break;
		}
		
		if (i!=7){
			printf ("\n");
		}
		
	}
	for (j=0; j<50; j++) {
			printf ("-");
		}
	
}
double average(int *shu) {
	int sum=0,i;
	for (i=0; i<6; i++) {
		sum+=shu[i];
	}
	return sum/6;
}
void print(int *newnumber) {
	for (int i=0; i<SIZE; i++) {
		printf ("%-5d",newnumber[i]);
	}
	printf ("\n");
}
/*
	插入排序 
*/
void Insert_sort(int *number,int n,int &move,int &compare,int &sing) {
	int i,j,temp;
	move=0,compare=0;
	for (i=1; i<n; i++) {
		if (number[i]<number[i-1]){
			temp=number[i];
			for (j=i-1; j>=0&&number[j]>temp; j--) {
				number[j+1]=number[j];
				compare++;
				move++;
			}
			number[j+1]=temp;
			move++;
		}
	}
}
/*
	希尔排序 
*/
void Shell_sort(int *number,int n,int &move,int &compare,int &sing) {
	int i,temp,j,dk=n/2;
	move=0,compare=0;
	while(dk>0) {
		for(i=dk; i<n; i+=dk)
			for(j=i; j>0; j-=dk)
				if(number[j]<number[j-dk]) {
					temp=number[j];
					number[j]=number[j-dk];
					number[j-dk]=temp;
					compare++;
					move++;
				}
		dk=dk/2;
	}

}
/*
	冒泡排序 
*/
void Bubble_sort(int *number, int n,int &move,int &compare,int &sing) {
	int i, j;
	for (i = 0; i < n - 1; i++) {

		for (j = n - 1; j > i; j--) {

			if (number[j] < number[j - 1]) {
				compare++;	
				move += 3;

				int tmp = number[j - 1];
				number[j - 1] = number[j];
				number[j] = tmp;
			}
		}

	}
}
/*
	快速排序 
*/
int partition(int *number, int s, int t,int &move,int &compare) {	//一趟划分
    int i = s, j = t;
    int tmp = number[i]; //以a[i]为基准
    while (i < j) {  
		//从两端交替向中间扫描,直至i=j为止
        while (j > i && number[j] >= tmp) {
            j--;           //从右向左扫描,找一个小于tmp的a[j]
            compare++; //进行比较
        }
        number[i] = number[j]; //找到这样的a[j],放入a[i]处
        move++;  //移动+1
        while (i < j && number[i] <= tmp) {
            i++;           //从左向右扫描,找一个大于tmp的a[i]
            compare++; //比较加一
        }
        number[j] = number[i]; //找到这样的number[i],放入a[j]处
        move++;  //移动加一
    }
    number[i] = tmp;
    move += 2; //temp的交换
    return i;
}
void Quick_sort(int  *number, int s, int t,int &move,int &compare,int &sing) {
	int i;
	if (s < t) {
		i = partition(number, s, t,move,compare);
		Quick_sort(number, s, i - 1,move,compare,sing);//对左递归排序
		Quick_sort(number, i + 1, t,move,compare,sing);//对右递归排序
	}
}
/*
	选择排序 
*/
void Selection_sort(int *number,int n,int &move,int &compare,int &sing) {

	int min;                          
	int i,j;

	for (i = 0; i<n; i++) {

		min = i;                     
		for (j = i+1; j<n; j++) {

			compare++;		
			if (number[j]<number[min]) {

				min = j;	
			}
		}
		if(min != i) {

			int tmp = number[i];
			number[i] = number[min];
			number[min] = tmp;
			move += 3;
		}
	}
}

/*
	堆排序 
*/
// 大顶堆 
void Down(int a[], int i, int n,int &move,int &compare) {
	int parent = i;                    // 父亲 
	int child  = 2 * i + 1;            // 孩子 
	while (child < n) {

		if (child + 1 < n) {
			compare++;	
			 // 判断子节点那个大，大的与父节点比较 比较次数+1
			if(a[child] < a[child + 1])
				child++;
		}
		compare++;
		if (a[parent] < a[child]) { 

			int key  = a[parent];
			a[parent] = a[child];
			a[child] = key;
			move +=3;		//交换+3
			parent = child;                 // 子节点给父节点 
		}
		child = child * 2 + 1; 
	}
}
//初始化 
void Build_Heap(int a[], int size,int &move,int &compare) {
	int i;
	for (i = size / 2 - 1; i >= 0; i--) { 
		Down(a, i, size,move,compare);       
	}
}
void Heap_sort(int *number, int n,int &move,int &compare,int &sing) {
	Build_Heap(number, n,move,compare);//初始化 
	int i;
	for (i = n - 1; i > 0; i--) {

		// 交换数据 
		int key  = number[0];
		number[0] = number[i];
		number[i] = key;
		move +=3; //交换 + 3

		Down(number, 0, i,move,compare); // 重新建立堆 
	}
}

/*
	归并排序 
*/
void Merge(int *number,int left,int right,int mid,int &move,int &compare) {
	int s[SIZE];//一个新数组用来存储排序好的数组
	int i = left, j = mid + 1;
	int sor = left;
	while (i <= mid && j <= right) {
		compare++;
		if (number[i] < number[j]) {	
			s[sor++] = number[i++];
			move++;
		} else {
			s[sor++] = number[j++];
			move++;
		}
	}
	while (i <= mid) {
		s[sor++] = number[i++];
		move++;
	}
	while (j <= right) {
		s[sor++] = number[j++];
		move++;
	}
	sor = left;
	while (sor <= right) {
		number[sor] = s[sor];
		move++;
		sor++;
	}
}
void Merge_sort(int *number,int left,int right,int &move,int &compare,int &sing){
	if(left<right){
		int mid = (left + right) / 2;
		Merge_sort(number,left, mid,move,compare,sing);
		Merge_sort(number, mid + 1, right,move,compare,sing);
		Merge(number, left, right, mid,move,compare);
	}
}
void Radix_sort(int *number,int n,int &move,int &compare,int &sing)
{
	int i,j,nLen=n;
 	if(number == NULL || nLen <= 0)return;
 	int nBit = 1;
 	int nMax = number[0];
 	//找出最大数
 	for(i = 1;i < nLen;i++)
 	{
  		if(nMax < number[i]){
   			nMax = number[i];
  		}
 	}
 	//计算位数
 	while(nMax /= 10){
  		nBit++;
 	}
 	int x = 1;
 	//定义一个指针数组来存数据,并开辟10个Radix空间
 	Radix **pRadix = (Radix **)malloc(sizeof(Radix *)*10);
 	Radix *pTemp = NULL;
 	Radix *pMark = NULL;
 	int nCount;
 	Radix *pDel = NULL;
 	//初始化为空
 	for(i = 0;i < 10;i++){
  		pRadix[i] = NULL;
 	}
 	for(i = 0;i < nBit;i++)
 	{
  	//按位排序
  		for(j = 0;j < nLen;j++){
   			pTemp = (Radix*)malloc(sizeof(Radix));
   			move++;
   			pTemp->nValue = number[j];
   			pTemp->pNext = NULL;
   			if(pRadix[number[j]/n%10] == NULL){
    			pRadix[number[j]/n%10] = pTemp;
   			}else{
    			pMark = pRadix[number[j]/n%10];
    			while(pMark->pNext != NULL){
     				pMark = pMark->pNext;
    			}
    			pMark->pNext = pTemp;
   			}
  		}
  		nCount = 0;
  	//将数据重新放回原数组
  		for(j = 0;j < 10;j++){
   			while(pRadix[j] != NULL){
    			number[nCount++] = pRadix[j]->nValue;
   				pDel = pRadix[j];
    			pRadix[j] = pRadix[j]->pNext;
    			free(pDel);
    			pDel = NULL;
    			move++;
   			}
  		}		
  		x *= 10;
  		
 	}
}

effort看看喽
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构 | 各种排序算法梳理 | 复习版
知识库搭建ing
01-17 1218
本篇为对先前学习笔记中所涉及到的排序算法的学习整理，主要用于期末复习梳理，重点侧重于算法思想。
数据结构与算法期末复习——知识点+题库
软件手的博客
05-12 9022
大学生 数据结构期末复习——知识点+题库 四川轻化工
5-40 奥运排行榜 (25分)
星夜征程
08-30 5513
5-40 奥运排行榜 (25分)每年奥运会各大媒体都会公布一个排行榜，但是细心的读者发现，不同国家的排行榜略有不同。比如中国金牌总数列第一的时候，中国媒体就公布“金牌榜”；而美国的奖牌总数第一，于是美国媒体就公布“奖牌榜”。如果人口少的国家公布一个“国民人均奖牌榜”，说不定非洲的国家会成为榜魁…… 现在就请你写一个程序，对每个前来咨询的国家按照对其最有利的方式计算它的排名。 输入格式:输入的第
数据结构——八大排序算法（面试/数据结构期末考试-简单且详细）
噜噜噜噜鲁
11-05 441
一般认为希尔排序的分组如下所示，每个颜色对应一组，共5组，并对每一组进行直接插入排序由于是分5组，我们令gap = 5，i与j始终相差5，从第一组开始进行排序，排序后令i++。这种分组方法相比于前面说的按顺序分组的方法，大概率将小的数据放在前面，大的数据放在后面，使得这组数据更加有序。
数据结构实验六 排序算法的实现
流苏的博客
05-22 2783
数据结构实验六 排序算法的实现（冒泡、选择、快速排序）。本篇内容为数据结构实验系列完结篇。
数据结构 | 排序算法——归并排序
做技术人 · 产优质博客 · 找好工作
10-12 831
七大常见排序算法之归并排序，【递归与非递归】两种方法详细教学
数据结构篇——五分钟带你记住常见排序算法口诀
ac不知深的博客
12-30 4415
一、前言 二、引言 1、概念 2、与生活相关
《数据结构》知识点汇总+算法代码总结【全】
热门推荐
qq_44622401的博客
08-13 8万+
写在前面：本文写于吴签时期，在家备考时刷完数据结构王道书之后想着把书中重点梳理汇总一下。本文内容包括但不局限于王道数据结构每章的知识点及其课后习题所涵盖的知识点。本人曾在大三期间打过一些程序设计类比赛，所以本文所涉及到的代码不一定局限于王道书，但思想都一样。 期末复习和备考408均可使用第一章：绪论（不在考研大纲但很重要）第二章：线性表第三章：栈和队列第四章：串第五章：树与二叉树第六章：图第七章：查找 第一章：绪论（不在考研大纲但很重要） 数据结构三要素：逻辑结构、存储结构、数据的运算；其中逻辑结构包括线
数据结构与算法——知识点总结
记录知识，学习分享
06-02 2万+
本文包含数据结构与算法主要的基本知识点，便于知识的梳理和回顾。 如需详细了解具体知识点请自行结合课本或者网上查阅。 目录 1、概述 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 1、概述 从 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 ...
数据结构与算法期末作业-哈夫曼算法压缩和解压ASCII文件
05-12
在这个期末作业中，学生使用哈夫曼算法实现了一个对ASCII字符文件进行压缩和解压的程序。以下是这个程序实现的关键知识点： 1. **哈夫曼树**：哈夫曼树（Huffman Tree）是一种特殊的二叉树，每个内部节点代表一个...
数据结构与算法分析期末试卷（湖南大学）.pdf
01-07
"数据结构与算法分析期末试卷（湖南大学）" 本资源是一个数据结构与算法分析期末试卷，来自湖南大学。试卷共分为五部分，包括判断题、选择题、填空题、简答题和应用题。 数据结构是计算机科学中的一门基础学科，...
scau归并排序 SCAU数据结构年期末复习
07-05
本资源摘要信息涵盖了SCAU数据结构年期末复习的主要知识点，包括数据结构的概念、时间复杂度、算法设计、表的顺序存储结构、链式存储结构、栈的实现、队列的实现等。 数据结构的概念： * 数据元素是数据的基本单位...
算法与数据结构 期末考试复习.ppt
05-30
《算法与数据结构》是计算机科学中的核心课程，它涵盖了如何高效地组织和处理数据的基本原理。本课程的复习资料主要关注四大类数据结构：集合、线性结构、树形结构和图状结构，以及相应的操作方法和存储结构。 1. *...
山东科技大学数据结构期末试卷分析
12-12
山东科技大学数据结构期末试卷分析主要涵盖了数据结构的多个方面，包括图论、树、排序算法、查找算法、树形存储结构、图存储结构、哈夫曼编码、KMP 算法、AOV 网络拓扑排序等。 从试卷中可以看到，数据结构是计算机...
c语言（7.23）
fhgfyrsg的博客
07-23 593
【代码】c语言（7.23）
【算法与数据结构】并查集
2301_79728896的博客
07-23 345
合并和查询集合的数据结构，KruskalLCA查询的时间复杂度：小于O(log2​n)近乎O(1)
Linux嵌入式学习——数据结构——线性表的链式结构
最新发布
m0_71703182的博客
07-24 768
在链表的尾部插入一个新节点，该节点包含指定的数据data。函数返回成功或失败的状态码。
手撕数据结构02--二分搜索（附源码）
weixin_64593595的博客
07-24 344
对于二分搜索的理论与实现的知识点学习。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值