各种排序算法

最新推荐文章于 2024-08-12 23:54:13 发布
最新推荐文章于 2024-08-12 23:54:13 发布
阅读量471 收藏
点赞数 1
文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kone_624701247/article/details/12293747
版权
以下内容来自《大话数据结构》一书的附带源代码。 
/*
-----------------------------------------------------------
									平均时间复杂度   空间复杂度
排序：插入排序类   直接插入排序     O(n^2)
	  
			       希尔排序         O(n^1.3)
				   
	  选择排序类   简单选择排序     O(n^2)
				   堆排序           O(n*logn)
				   
	  交换排序类   冒泡排序         O(n^2)
				   快速排序         O(n*logn)
				   
	  归并排序类   归并排序         O(n*logn)
-----------------------------------------------------------
时间复杂度：问题规模 n ， 时间复杂度O(f(n))  
	大O阶方法：
	1、常数阶O(1) : 执行次数与 n 无关 
	2、线性阶O(n) : 一重n次循环  for(int i = 0; i<n; i++)
	3、对数阶O(logn) :
		int count  = 1;
		while(count < n) {count = count * 2;}   //执行次数x为：2^x = n 
	4、平方阶O(n^x) : x重n次循环
		
 				
空间复杂度：
*/
#include <stdio.h>    
#include <string.h>
#include <ctype.h>      
#include <stdlib.h>   
#include <io.h>  
#include <math.h>  
#include <time.h>

#define OK      1
#define ERROR   0
#define TRUE    1
#define FALSE   0

#define MAX_LENGTH_INSERT_SORT    7 /* 用于快速排序时判断是否选用插入排序阙值 */

typedef int Status; 

#define MAXSIZE 10000   /* 用于要排序数组个数最大值，可根据需要修改 */
typedef struct
{
	int r[MAXSIZE+1];	/* 用于存储要排序数组，r[0]用作哨兵或临时变量 */
	int length;			/* 用于记录顺序表的长度，r[1]--r[length]顺序表共length个元素 */   
}SqList;

/* 打印出L中数组r的元素 */
void print(SqList L)
{
	int i;
	for(i=1;i<L.length;i++)
		printf("%d,",L.r[i]);
	printf("%d",L.r[i]);      //打印出r[length]
	printf("\n");
}

/* 交换L中数组r的下标为i和j的值 */
void swap(SqList *L,int i,int j) 
{ 
	int temp = L->r[i]; 
	L->r[i] = L->r[j]; 
	L->r[j] = temp; 
}

/* 对顺序表L作   交换排序（冒泡排序初级版） ****************************************************/
void BubbleSort0(SqList *L)
{ 
	int i,j;
	for(i=1;i < L->length;i++)
	{
		for(j=i+1;j<=L->length;j++)    // 第i个元素分别与i后面的元素比较大小
		{
			if(L->r[i] > L->r[j])     
			{
				 swap(L,i,j);     /* 交换L->r[i]与L->r[j]的值 */
			}
		}
	}
}

/* 对顺序表L作  冒泡排序 ***********************************************************************/
//从右往左依次将比较相邻元素直到将最小值冒到最左
void BubbleSort(SqList *L)
{ 
	int i,j;
	for(i=1;i < L->length;i++)
	{
		for(j = L->length-1;j>=i;j--)  /* 注意j是从后往前循环 */
		{
			if(L->r[j] > L->r[j+1]) /* 若前者大于后者（注意这里与上一算法的差异）*/
			{
				 swap(L,j,j+1);/* 交换L->r[j]与L->r[j+1]的值 */
			}
		}
	}
}

/* 对顺序表L作  改进冒泡算法 *******************************************************************/
void BubbleSort2(SqList *L)
{ 
	int i,j; 
	Status flag = TRUE;			/* flag用来作为标记 */   //Status : int类型的重定义
	for(i=1;i<L->length && flag;i++) /* 若flag为true说明有过数据交换，否则停止循环 */
	{
		flag = FALSE;				/* 初始为False */
		for(j=L->length-1;j>=i;j--)
		{
			if(L->r[j] > L->r[j+1]) 
			{
				 swap(L,j,j+1);	/* 交换L->r[j]与L->r[j+1]的值 */
				 flag = TRUE;		/* 如果有数据交换，则flag为true */
			}						/* 如果一轮下来都没有数据交换，那就证明数组已经排好序啦 */
		}
	}
}

/* 对顺序表L作  简单选择排序 *******************************************************************/
//选出未排序的最小元素加到已排序中去
void SelectSort(SqList *L)
{
	int i,j,min;
	for(i=1;i<L->length;i++)
	{ 
		min = i;						 /* 将当前下标定义为最小值下标 */
		for (j = i+1;j <= L->length;j++) /* 循环之后的数据 */
        {
			if (L->r[min] > L->r[j])	 /* 如果有小于当前最小值的关键字 */
                min = j;				 /* 将此关键字的下标赋值给min */
        }
		if(i!=min)						 /* 若min不等于i，说明找到更小的，交换 */
			swap(L,i,min);				 /* 交换L->r[i]与L->r[min]的值 */
	}
}

/* 对顺序表L作  直接插入排序 *******************************************************************/
//将元素依次插入到已排序中去
void InsertSort(SqList *L)
{ 
	int i,j;
	for(i=2;i<=L->length;i++)
	{
		 /*i之前的元素都已经排好序了，判断i元素是否大于i-1元素，若小于则需找到i元素的插入点*/
		if (L->r[i] < L->r[i-1])
		{
			L->r[0] = L->r[i];                   /* 设置哨兵，就是备份数据嘛*/
			for(j=i-1;L->r[j] > L->r[0];j--)  
				L->r[j+1] = L->r[j];             /* 记录后移 */
			L->r[j+1] = L->r[0]; /* 插入到正确位置 */
		}
	}
}

/* 对顺序表L作  希尔排序 ***********************************************************************/
//先按增量分组，之后各分组执行直接插入排序
/*如：7，9，2，3，6，9，44，66，12 增量为3
  则分为3组：7，3，44 和 9，6，66 和 2，9，12*/
void ShellSort(SqList *L)
{
	int i,j,k = 0;
	int increment = L->length;
	do
	{
		increment = increment/3 + 1;   /* 增量序列 */  //这个增量也可用其他取法
		for(i=increment+1;i<=L->length;i++)   /*这个循环里面原理同直接插入排序*/
		{
			if (L->r[i] < L->r[i-increment])  /* 需将L->r[i]插入有序增量子表 */ 
			{ 
				L->r[0] = L->r[i]; /*  暂存在L->r[0] */
				for(j=i-increment;j>0 && L->r[0] < L->r[j];j-=increment)
					L->r[j+increment] = L->r[j]; /*  记录后移，查找插入位置 */
				L->r[j+increment] = L->r[0]; /*  插入 */
			}
		}
		printf("第%d趟排序结果: ",++k);
		print(*L);
	}
	while(increment>1);    //当增量大于1时继续排序
}


/* 堆排序***************************************************************************************/
/* 
大顶堆：1、完全二叉树，2、每个节点的值 >= 其左右子节点的值
小顶堆：1、完全二叉树，2、每个节点的值 <= 其左右子节点的值  
*/

/* 已知L->r[s..m]中记录的关键字除L->r[s]之外均满足堆的定义， */
/* 本函数调整L->r[s]的关键字,使L->r[s..m]成为一个大顶堆 */
void HeapAdjust(SqList *L,int s,int m)
{ 
	int temp,j;
	temp = L->r[s];
	//画个堆出来便知：若S是父节点，则2*s是其左子节点，2*s+1是右子节点
	for(j=2*s;j<=m;j*=2) /* 沿关键字较大的孩子结点向下筛选 */
	{
		if(j<m && L->r[j] < L->r[j+1])
			++j;           /* j为关键字中较大的记录的下标 */
		if(temp>=L->r[j])
			break;          /* rc应插入在位置s上 */  //break 跳出for循环
		L->r[s] = L->r[j];
		s = j;
	}
	L->r[s] = temp; /* 插入 */
}

/*  对顺序表L进行  堆排序 */
void HeapSort(SqList *L)
{
	int i;
	for(i=L->length/2;i>0;i--)    /*  把L中的r构建成一个大根堆 */  //画个图你就懂啦
		 HeapAdjust(L,i,L->length);

	for(i=L->length;i>1;i--)
	{ 
		 swap(L,1,i);            /* 将堆顶记录(第1个元素) 和 当前未经排序子序列的最后一个记录交换（第i个元素） */
		 HeapAdjust(L,1,i-1);    /*  将L->r[1..i-1]重新调整为大根堆，L->r[i..length]为已排序的*/
	}
}

/* 归并排序*************************************************************************************/

/* 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] */
void Merge(int SR[],int TR[],int i,int m,int n)
{
	int j,k,l;
	for(j=m+1,k=i;i<=m && j<=n;k++)	/* 将SR中记录由小到大地并入TR */
	{
		if (SR[i] < SR[j])
			TR[k] = SR[i++];
		else
			TR[k] = SR[j++];
	}
	if(i<=m)
	{
		for(l=0;l<=m-i;l++)
			TR[k+l] = SR[i+l];		/* 将剩余的SR[i..m]复制到TR */
	}
	if(j<=n)
	{
		for(l=0;l<=n-j;l++)
			TR[k+l] = SR[j+l];		/* 将剩余的SR[j..n]复制到TR */
	}
}

/* 递归法 */
/* 将SR[s..t]归并排序为TR1[s..t] */
void MSort(int SR[],int TR1[],int s, int t)
{
	int m;
	int TR2[MAXSIZE+1];
	if(s==t)         
		TR1[s] = SR[s];
	else
	{
		m = (s+t)/2;				/* 将SR[s..t]平分为SR[s..m]和SR[m+1..t] */
		MSort(SR,TR2,s,m);		    /* 递归地将SR[s..m]归并为有序的TR2[s..m] */
		MSort(SR,TR2,m+1,t);	    /* 递归地将SR[m+1..t]归并为有序的TR2[m+1..t] */
		Merge(TR2,TR1,s,m,t);   	/* 将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t] */
	}
}

/* 对顺序表L作  归并排序 */
void MergeSort(SqList *L)
{ 
 	MSort(L->r,L->r,1,L->length);
}

/* 非递归法 */
/* 将SR[]中相邻长度为s的子序列两两归并到TR[] */
void MergePass(int SR[],int TR[],int s,int n)
{
	int i = 1;
	int j;
	while(i <= n-2*s+1)
	{/* 两两归并 */
		Merge(SR,TR,i,i+s-1,i+2*s-1);
		i = i+2*s;  
	}
	if(i<n-s+1) /* 归并最后两个序列 */
		Merge(SR,TR,i,i+s-1,n);
	else /* 若最后只剩下单个子序列 */
		for(j =i;j <= n;j++)
			TR[j] = SR[j];
}

/* 对顺序表L作  归并非递归排序 */
void MergeSort2(SqList *L)
{
	int* TR = (int*)malloc(L->length * sizeof(int));   /* 申请额外空间 */
    int k = 1;
	while(k < L->length)
	{
		MergePass(L->r,TR,k,L->length);
		k = 2*k;/* 子序列长度加倍 */
		MergePass(TR,L->r,k,L->length);
		k = 2*k;/* 子序列长度加倍 */       
	}
}

/* 快速排序*************************************************************************************/
 
/* 交换顺序表L中子表的记录，使枢轴记录到位，并返回其所在位置 
   此时在它之前的记录均小于它；在它之后的记录均大于它。 */
int Partition(SqList *L,int low,int high)
{ 
	int pivotkey;
	pivotkey = L->r[low];   //取枢轴方法：1、取第一个关键字；2、随机取得；3、三数取中法
	
	while(low<high) /*  从表的两端交替地向中间扫描 */
	{ 
		 while(low<high && L->r[high] >= pivotkey)
			high--; 
		 swap(L,low,high);/* 将比枢轴记录小的记录交换到低端 */
		 while(low<high && L->r[low] <= pivotkey)
			low++;
		 swap(L,low,high);/* 将比枢轴记录大的记录交换到高端 */
	}
	return low; /* 返回枢轴所在位置 */
}

/* 对顺序表L中的子序列L->r[low..high]作快速排序 */
void QSort(SqList *L,int low,int high)
{ 
	int pivot;
	if(low<high)
	{
			//枢轴:在数组中找一个关键字，使其左边关键字比他小，右边比她大，
			pivot = Partition(L,low,high); /*  将L->r[low..high]一分为二，算出枢轴值pivot */
			QSort(L,low,pivot-1);		/*  对低子表递归排序 */
			QSort(L,pivot+1,high);		/*  对高子表递归排序 */
	}
}

/* 对顺序表L作  快速排序 */
void QuickSort(SqList *L)
{ 
	QSort(L,1,L->length);
}

/* 改进后快速排序*******************************************************************************/
/* 快速排序优化算法 */
int Partition1(SqList *L,int low,int high)
{ 
	int pivotkey;
	
	/*与Partition不同的是：这里取枢轴用了 三数取中法*****************/
	int m = low + (high - low) / 2;     /* 计算数组中间的元素的下标 */  
	if (L->r[low] > L->r[high])			
		swap(L,low,high);	            /* 交换左端与右端数据，保证左端较小 */
	if (L->r[m] > L->r[high])
		swap(L,high,m);		            /* 交换中间与右端数据，保证中间较小 */
	if (L->r[m] > L->r[low])
		swap(L,m,low);		            /* 交换中间与左端数据，保证左端较小 */
	/*****************************************************************/
	
	pivotkey = L->r[low]; /* 用子表的第一个记录作枢轴记录 */
	L->r[0] = pivotkey;  /* 将枢轴关键字备份到L->r[0] */
	
	while(low<high) /*  从表的两端交替地向中间扫描 */
	{ 
		 while(low<high&&L->r[high]>=pivotkey)
			high--;
		 L->r[low]=L->r[high];
		 while(low<high&&L->r[low]<=pivotkey)
			low++;
		 L->r[high]=L->r[low];
	}
	L->r[low]=L->r[0];
	return low; /* 返回枢轴所在位置 */
}

void QSort1(SqList *L,int low,int high)
{ 
	int pivot;
	if( (high-low) > MAX_LENGTH_INSERT_SORT/*宏：7*/ )
	{
		while(low<high)
		{
			pivot = Partition1(L,low,high); /*  将L->r[low..high]一分为二，算出枢轴值pivot */
			QSort1(L,low,pivot-1);		/*  对低子表递归排序 */
		   /* QSort(L,pivot+1,high);		  对高子表递归排序 */
		   //第一次递归后，变量low 就没有用处了，所以这样比QSort缩短了堆栈深度，从而提高了整体性能。
			low = pivot+1;	/* 尾递归 */  
		}
	}
	else     //比较短的适合用 直接插入排序
		InsertSort(L);   /* 对顺序表L作  直接插入排序 */
}

/* 对顺序表L作  改进快速排序 */
void QuickSort1(SqList *L)
{ 
	QSort1(L,1,L->length);
}

/* *********************************************************************************************/
#define N 9
int main()
{
   int i;
   
   /* int d[N]={9,1,5,8,3,7,4,6,2}; */
   int d[N]={50,10,90,30,70,40,80,60,20};
   /* int d[N]={9,8,7,6,5,4,3,2,1}; */

   SqList l0,l1,l2,l3,l4,l5,l6,l7,l8,l9,l10;
   
   for(i=0;i<N;i++)
     l0.r[i+1]=d[i];
   l0.length=N;
   l1=l2=l3=l4=l5=l6=l7=l8=l9=l10=l0;
   printf("排序前:\n");
   print(l0);

   printf("初级冒泡排序:\n");
   BubbleSort0(&l0);
   print(l0);
   
   printf("冒泡排序:\n");
   BubbleSort(&l1);
   print(l1);
   
   printf("改进冒泡排序:\n");
   BubbleSort2(&l2);
   print(l2);
   
   printf("选择排序:\n");
   SelectSort(&l3);
   print(l3);
   
   printf("直接插入排序:\n");
   InsertSort(&l4);
   print(l4);

   printf("希尔排序:\n");
   ShellSort(&l5);
   print(l5);
	
   printf("堆排序:\n");
   HeapSort(&l6);
   print(l6);

   printf("归并排序（递归）:\n");
   MergeSort(&l7);
   print(l7);

   printf("归并排序（非递归）:\n");
   MergeSort2(&l8);
   print(l8);

   printf("快速排序:\n");
   QuickSort(&l9);
   print(l9);

   printf("改进快速排序:\n");
   QuickSort1(&l10);
   print(l10);

    /*大数据排序*/
	/* 
	srand(time(0));  
	int Max=10000;
	int d[10000];
	int i;
	SqList l0;
	for(i=0;i<Max;i++)
		d[i]=rand()%Max+1;
	for(i=0;i<Max;i++)
		l0.r[i+1]=d[i];
	l0.length=Max;
	MergeSort(l0);
	print(l0);
	*/
	return 0;
}


西德德
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PHP 各种排序算法实现代码
01-20
php // 功能: PHP实现各种排序算法 // Author: windlike // Datetime: 2007-06-09 // 冒泡排序 function BubbleSort($arr){ $num = count($arr); for($i=1;$i<$num;$i++){ for($j=$num-1;$j>=$i;$j–){ if($arr[$...
时间复杂度：O(1)、O(n)、O(n^2)、O(logn) 哪种情况下会出现
X女王的博客
04-12 6512
时间复杂度往往用来衡量一个算法的好坏程度，这里就来介绍一下如何推导时间复杂度即各种时间复杂度出现的情况。 如何推导时间复杂度？ 时间复杂度的推导遵循3个原则： 如果运行时间跟n无关，是常数，则时间复杂度是O(1)； 只保留时间函数中的最高阶项； 去掉高阶项前面的系数； O(1)出现情况 若运行时间跟n的取值无关，即无论n取什么值，我的运行时间都不会变，则时间复杂度为O(1) public vo...
各种排序算法比较
wardseptember的博客
06-22 3151
排序算法的稳定性和源码 稳定性： 所谓稳定性是指当待排序列中有两个或两个以上相同的关键字时，排序前和排序后这些关键字的相对位置，如果没有发生变化就是稳定的，否则就是不稳定的。 如果关键字不能重复，则排序结果是唯一的，那么选择的排序算法稳定与否就无关紧要；如果关键字可以重复，则在选择排序算法是，就要根据具体的需求来考虑选择稳定的还是不稳定的排序算法。 排序算法 源码链接 ...
各种排序算法耗时比较
the_dog_tail_grass的博客
10-11 3962
我们知道，各个排序算法的时间复杂度从快速排序的nlogn到冒泡的n^2，但是即使时间复杂度相同，其具体的耗时也是不同的。今天就来实地测测每种算法到底耗时如何 一号选手：冒泡排序。我们知道冒泡排序算的上是最慢的一种排序方法了 #include<stdio.h> #include<stdlib.h> #include<memory.h> #include&lt...
各种排序算法的详细总结与比较
这里记录着我一点一滴的进步
09-04 2万+
最近开始找工作了，总结一些基本问题供复习。 排序算法可以说是一项基本功，解决实际问题中经常遇到，针对实际数据的特点选择合适的排序算法可以使程序获得更高的效率，有时候排序的稳定性还是实际问题中必须考虑的，这篇博客对常见的排序算法进行整理，包括：插入排序、选择排序、冒泡排序、快速排序、堆排序、归并排序、希尔排序、二叉树排序、计数排序、桶排序、基数排序。 比较排序和非比较排序 ...
常用十大排序算法
热门推荐
qq_51664685的博客
04-26 13万+
列举了常见的十大内部排序算法：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序，计数排序，桶排序。
各种排序算法的使用场景
请叫我皮皮虾的博客
09-29 2947
排序使用场景： (1)若n较小(如n≤50)，可采用直接插入或直接选择排序； 当记录规模较小时，直接插入排序较好； 否则因为直接选择移动的记录数少于直接插人，应选直接选择排序为宜。 (2)若文件初始状态基本有序(指正序)，则应选用直接插人或冒泡排序为宜； (3)若文件初始状态随机分布，则应选用快速排序为宜； (4)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或...
各种排序算法（内部排序）及其实现
luoluozlb
08-26 4770
本文是基于《数据结构（C语言版）（第二版）》（严蔚敏）其排序章节所做的总结。因此具体解释可以去参考此书。概念什么是排序排序是按关键字的非递减或非递增顺序对一组记录重新进行排列的操作。数学描述： 设n个记录的序列为 {R1, R2, …, Rn}，其关键字序列为 {K1, K2, …, Kn} 确定1, 2, …, n的一种排序p1, p2, …, pn，使之满足Kp1 <= Kp2 <= …
程序员那些必须掌握的排序算法(上)
。。。
08-17 8万+
现在的IT行业并不像以前那么好混了，从业人员过多，导致初级程序员过剩，这也间接导致了公司的招聘门槛越来越高，要求程序员掌握的知识也越来越多。 算法也是一个争论了很久的话题，程序员到底该不该掌握算法？不同的人有不同的答案，而事实上，很多公司都对算法有一定的要求，有些公司直接在面试的时候便会要求面试者手写算法题。这就对程序员的技术要求产生了很大的考验，所以面对如今的大环境，我们必须掌握算法，才能在今后...
【C语言】八大排序算法
weixin_63449996的博客
09-30 1万+
本文详细介绍了数据结构的排序算法，结合动图，基本思想，解析，代码，你也可以手撕算法。
各种排序算法比较.doc
09-20
接着，我们对比各种排序算法的性能。插入排序和冒泡排序虽然在最坏情况下时间复杂度较高，但在部分有序的数据集上表现优秀。选择排序在任何情况下都保持固定的时间复杂度，但不稳定。快速排序在大多数情况下表现出色...
利用前端动画实现算法可视化，比如各种排序算法动画实现.zip
06-01
这个名为"利用前端动画实现算法可视化，比如各种排序算法动画实现.zip"的资源包，旨在帮助我们利用前端技术来动态演示算法的过程，特别是各种排序算法。这不仅能够帮助初学者更好地理解算法的工作原理，也对专业...
各种排序算法的分析及java实现
it_man的专栏
12-20 4980
排序一直以来都是让我很头疼的事，以前上《数据结构》打酱油去了，整个学期下来才勉强能写出个冒泡排序。由于下半年要准备工作了，也知道排序算法的重要性（据说是面试必问的知识点），所以又花了点时间重新研究了一下。　　排序大的分类可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。下面讲的排序都是属于内排序。　　内排序有可以分为以下几类：　
Leetcode JAVA刷刷站（16）最接近的三数之和
m0_73399576的博客
08-12 589
Leetcode JAVA刷刷站——最接近的三数之和篇
数据结构与算法 - 排序算法
ltt159264的博客
08-12 695
近乎有序枢轴值选取得尽量随机化。
排序算法之桶排序
rd_w_csdn的博客
08-12 784
桶排序（bucket sort）是分治策略的一个典型应用。它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中；然后，在每个桶内部分别执行排序；最终按照桶的顺序将所有数据合并。
每天一道C语言精选编程题之排序整形数组
最新发布
huc_error的博客
08-12 376
冒泡排序是⼀种基础的排序算法，其基本思想是⽐较相邻的两个元素，如果它们的顺序错误就交换它 们的位置，直到整个序列有序为⽌。2. 在对序列中的所有相邻元素都进⾏了⼀次⽐较之后，第⼀轮排序结束，此时最后⼀个元素已经是整个序列中最⼤的元素。1. 从序列的第⼀个元素开始，对相邻的两个元素进⾏⽐较，如果顺序错误就交换它们的位置，使较。若在某⼀轮排序中未进⾏交换操作，则当前序列已经是升序状态，可以结束排序。⼩的元素排在前⾯，较⼤的元素排在后⾯。
C语言实现各种排序算法详解
"排序算法C语言实现，包括冒泡排序、快速排序、直接插入排序、希尔排序、选择排序、堆排序、归并排序等。" 本文将详细介绍几种经典的排序算法，这些算法在计算机科学和编程中有着广泛的应用，特别是在数据处理和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值