数据结构7--排序

最新推荐文章于 2024-11-10 20:17:28 发布
最新推荐文章于 2024-11-10 20:17:28 发布
阅读量166 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43807876/article/details/115409666
版权

排序的稳定性

在重复数据的前提下，这两个数据是否进行交换，如果进行交换了，则不稳定；没有进行交换，则稳定。

内排和外排

内部排序（全部放在内存中） 外部排序（部分放入内存） 以内存划分

排序的分类

  1. 按不同排序手段：插入排序、交换排序、选择排序、归并排序、计数排序
  2. 按时间复杂度：简单排序 O(n^2)、先进排序 O(log)、基数排序 O(d*n)

插入排序

1.直接插入排序

（1）基本思想：把待排序的记录按其关键码值的大小逐个插入到一个已经排序好的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列（扑克牌）每次从没有排序好的 插入到排序好的合适的位置

（2）时间复杂度：O(n^2)  空间复杂度：O(1)  是否稳定：稳定

（3）方法一：进行交换 一般默认第一个元素是已经排序好的 

end标记要插入的元素 当end的值小于前一个时，进行交换，end--，和之前的再进行比较直到不需要交换


//方法：1.有多少张排需要插入for 2.寻找插入位置 用while end标记
void InsertSort(int *ar, int left, int right)
{
	//有多少张排需要插入
	for (int i = left + 1; i < right; i++)
	{
		//寻找插入位置
		int end = i;
		//疑问为什么end>left 
		//left一直标记的都是0号位置 end一直标记的是要插入的值 是通过i来往后调整的
		while (end>left&&ar[end] < ar[end - 1])
		{
			Swap(&ar[end], &ar[end - 1]);
			end--;//和已经排好的元素都进行比较
		}
	}
	
}

（4）方法二：借用临时空间 将需要插入的值放入临时空间中 找到需要插入的位置

void InsertSort_1(int *ar, int left, int right)
{
	//有多少个元素要进行插入
	for (int i = left + 1; i < right; i++)
	{
		int tmp = ar[i];
		int end = i;
		while (end < left&&tmp < ar[end - 1])
		{
			ar[end] = ar[end - 1];
			end--;
		}
		//之前end的位置值都是空的
		ar[end] = tmp;
	}
}

（5）方法三：哨兵位的直接插入排序

思想：哨兵位a[0] 充当临时空间，并且控制越界；将待排序序列的第一个位置空出来设为哨兵位置，因此在定义序列式需要多给一个空间

void InsertSort_2(int *ar, int left, int right)
{
	for (int i = left + 1; i < right; ++i)
	{
		ar[0] = ar[i];//哨兵位
		int end = i;
		while (ar[0] < ar[end - 1])
		{
			ar[end] = ar[end - 1];
			end--;
		}
		ar[end] = ar[0];
	}
}

2.折半插入排序

思想：将待排序的序列插入已经排序好的序列中，每次查找插入位置都是从一半查起，使用临时空间

void BinInsertSort(int *ar, int left, int right)
{
	//有多少元素要插入
	for (int i = left + 1; i < right; ++i)
	{
		//寻找插入的位置
		int tmp = ar[i];
		//标记已经排序好的序列的范围
		int low = left;
		int high = i - 1;;
		while (low<=high)
		{
			int mid= (low + high) / 2;
			if (tmp < ar[mid])
			{
				high = mid - 1;
			}
			else{
				low = mid + 1;
			}
		}
		//将空间向后移动
		//high + 1就是要插入的位置
		for (int j = i - 1; j >= high + 1; j--)
		{
			ar[j + 1] = ar[j];
		}
		ar[high + 1] = tmp;
	}

}

3.希尔排序（缩小增量排序） 

（1）思想：先将整个待排序记录序列分割成为若敢子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序

（2）快的原因：基本有序、数据量小  时间复杂度：O（n^1.3~n^2） 是否稳定：不稳定   是对直接插入排序的优化

//dk是增量
//方法:1.控制dk里的每一对数据，遍历每一对数据，也就是遍历数组
//2.每一对数据进行比较 标志其第二个位置和起始位置
//3.每一个大集合中 和前面的序列进行比较，找到合适的位置
void ShellSort(int* ar, int left, int right)
{
	int dk = right - left;
	while (dk > 1)
	{
		dk = dk / 3 + 1;
		for (int i = left + dk; i < right; i++)//控制dk里的每一对数据
		{
			if (ar[i] < ar[i - dk])
			{
				int tmp = ar[i];//第二个位置
				int end = i - dk;//起始位置(相对来说)
				//和前面的序列进行比较（一趟中的）
				while (end >= left&&tmp > ar[end])
				{
					ar[end + dk] = ar[end];
					end -= dk;
				}
				ar[end + dk] = tmp;
			}
		}
	}
}

选择排序

1.直接选择排序

（1）基本思想：每一次从待排序的元素中选出最小或最大的一个元素，存放在序列的起始位置（依次往后放），直到全部待排序的数据元素排完

（2）时间复杂度：O(n^2) 空间复杂度：O(1)     是否稳定：不稳定

//1.要排序的元素for循环 2.默认第一个元素时最小的 用pos标记最小的 3.从剩下的元素中寻找最小的（和min比较）4.进行交换，看pos是否等于i
void SelectSort(int * ar, int left, int right)
{
	//要排序的元素
	for (int i = left; i < right; i++)
	{
		//寻找需要交换的元素 从剩下的元素里找
		   int min = ar[i];
		   int pos = i;//标记最小的
		   for (int j = i + 1; j < right; j++)
		   {
			   if (min > ar[j])
			   {
				   min = ar[j];
				   pos = j;
			   }
		   }
			//如果不相等 则找到后进行交换
			if (pos != i)
			{
				Swap(&ar[i], &ar[min]);
			}
	}
}

2.堆排序（重要）

（1）排升序建立大堆，降序建立小堆

（2）时间复杂度：O（N*logN） 空间复杂度 O（1） 稳定性：不稳定

void _ShifDown(int *ar, int left, int right, int curpos)
{
	//对该分支进行调整
	int i = curpos;//父节点
	int j = i * 2 + 1 + left;//子节点
	int n = right - left;
	while (j < n)
	{
		if (j + 1 < n&&ar[j] < ar[j + 1])
		{
			j++;
		}
		if (ar[j] > ar[i])
		{
			Swap(&ar[j], &ar[i]);
			i = j;
			j = i * 2 + 1;
		}
		else{
			break;
		}
	}
}
void HeapSort(int *ar, int left, int right)
{
	//创建大堆 先找到最后一个分支
	int n = right - left;
	int cur = n / 2 - 1 + left;
	//大的框架 每个分支
	while (cur >= 0)
	{
		_ShifDown(ar,left,right,cur);
		cur--;
	}
	//排序
	int end = right - 1;
	while (end > left)
	{
		Swap(&ar[left], &ar[end]);
		end--;//也就是说每次的最后一个都是最大的值
		_ShifDown(ar, left, end, left);
	}
}

交换排序

基本思想：根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置

交换排序特点：将键值较大的记录向序列尾部移动，键值较小的记录向序列头部移动

1.冒泡排序

（1）思想：对由n个记录组成的记录序列，最多经过（n-1）趟冒泡排序，就可以使记录序列成为有序序列；每一趟中比较相邻的元素，如果第一个比第二个大，就交换他们两个；对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对；针对所有的元素重复以上的步骤，直到没有任何一对数字需要比较。

（2）时间复杂度：O(N)  空间复杂度:O(1)  稳定性：稳定

//改进方法：加入一个标记位 用来标记此趟排序是否有交换，如果有则说明整体数据未必有序；如果 没有则说明数据已经有序了，直接退出
void BubbleSort(int*ar, int left, int right)
{
	int n = right - left;
	bool is_swap = false;
	for (int i = left; i < n-1; i++)
	{
		for (int j = i; j < n - i - 1; j++)
		{
			if (ar[j]>ar[j + 1])
			{
				Swap(&ar[j], &ar[j + 1]);
				is_swap = true;
			}
		}
		if (!is_swap)
		{
			break;//为假时
		}
		else{
			is_swap = false;
		}
	}
}

2.快速排序（重要）

（1）思想：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应的位置上为止。

（2）时间复杂度：O(N*logN)  空间复杂度O(logN) 稳定性：不稳定

（3）hoare版本 找到分割位置 递归的方式

int _Partition_1(int *ar, int left, int right)
{
	int key = ar[left];
	while (left < right)
	{
		while (left < right&&ar[right] >= key)
			right--;
		Swap(&ar[left], &ar[right]);
		while (left < right&&ar[left] < key)
			left++;
		Swap(&ar[left], &ar[right]);
	}
	//left==right
	return left;
}
void QuickSort(int *ar, int left, int right)
{
	if (left >= right - 1)
		return;
	int pos = _Partition_1(ar, left, right - 1);//用于分割
	QuickSort(ar, left, pos);
	QuickSort(ar, pos + 1, right);
}

（4）挖坑法 

int _Partition_2(int *ar, int left, int right)
{
	int key = ar[left];
	while (left < right)
	{
		while (left < right&&key <= ar[right])
			right--;
		ar[left] = ar[right];
		while (left<right&&key>ar[left])
			left++;
		ar[right] = ar[left];//没明白这里 需要画图
	}
	ar[left] = key;
	return left;
}
void QuickSort_1(int *ar, int left, int right)
{
	if (left >= right - 1)
		return;
	int pos = _Partition_2(ar, left, right - 1);
	QuickSort_1(ar, left, pos);
	QuickSort_1(ar, pos + 1, right);
}

（5）前后指针法

两个指针一快一慢 当前一个指针位置的值小于key时，后一个指针向前走，走到它的位置，两者相等；当前一个指针走的位置的值大于key时，后一个指针不动，前一个指针一直向前走，直到找到小于key的位置，两个指针不相等 进行交换；前一个找比key大的，后一个找比key小的 当后面的都是大值时，key和慢指针进行交换

int _Partition_3(int *ar, int left, int right)
{
	int key = ar[left];
	int pos = left;
	for (int i = left + 1; i <=right; i++)
	{
		if (ar[i] < key)
		{
			pos++;
			if (pos != i)
				Swap(&ar[pos], &ar[i]);
		}
	}
	Swap(&ar[left], &ar[pos]);
	return pos;
}
void QuickSort(int *ar, int left, int right)
{
	if (left >= right - 1)
		return;
	int pos = _Partition_2(ar, left, right - 1);
	QuickSort_1(ar, left, pos);
	QuickSort_1(ar, pos + 1, right);
}

（6）改进快排 

  •   数据量小时用直接插入排序，反之用快排
#define M 25
int _Partition_1(int *ar, int left, int right)
{
	int key = ar[left];
	while (left < right)
	{
		while (left < right&&ar[right] >= key)
			right--;
		Swap(&ar[left], &ar[right]);
		while (left < right&&ar[left] < key)
			left++;
		Swap(&ar[left], &ar[right]);
	}
	//left==right
	return left;
}
void QuickSort_2(int *ar, int left, int right)
{
	if (left >= right)
		return;

	if (left - right <= M)
	{
		//直接插入排序
		//1.需要插入多少元素
		//2.找到插入位置
		for (int i = left + 1; i < right; i++)
		{
			int end = i;
			while (end>left&&ar[end] < ar[end - 1])
			{
				Swap(&ar[end], &ar[end - 1]);
				end--;
			}
		}
	}
	else{
		int pos = _Partition_1(ar, left, right - 1);
		QuickSort(ar, left, pos);
		QuickSort(ar, pos + 1, right);
	}
}
  • 三者取中算法 left right mid 三者找第二大 解决最坏情况
int GetIndexMidVal(int *ar, int left, int right)
{
	int mid = (left + right) / 2;
	if (ar[left] > ar[mid] && ar[left] <ar[right])
		return left;
	if (ar[mid]>ar[left] && ar[mid] < ar[right])
		return mid;
	return right;
}
int _Partition_4(int *ar, int left, int right)
{
	int index = GetIndexMidVal(ar, left, right);
	//为了匹配下面的代码 必须在第一个位置
	if (index != left)
		Swap(&ar[index], &left);


	int key = ar[left];
	int pos = left;
	for (int i = left + 1; i <= right; i++)
	{
		if (ar[i] < key)
		{
			pos++;
			if (pos != i)
				Swap(&ar[pos], &ar[i]);
		}
	}
	Swap(&ar[left], &ar[pos]);
	return pos;
}

 

归并排序

（1）思想：分治法，将序列分成多个子序列，即先使每个子序列有序，再使子序列段间有序。

（2）时间复杂度： O(NlogN)  空间复杂度：O(N)  稳定性：稳定

每次按一半分解，直到只剩下一个元素，再进行合并（顺序表的合并），两两合并

void _MergeSort(int* ar, int left, int right, int *tmp)
{
	if (left >= right)
		return;
//1.先分解
	int mid = (left+right) / 2;
	_MergeSort(ar, left, mid, tmp);
	_MergeSort(ar, mid + 1, right, tmp);
//2.后归并
	int begin1, end1, begin2, end2, i;
	begin1 = left, end1 = mid;
	begin2 - mid + 1, end2 = right;

	i = 0;
	while (begin1<=end1&&begin2<=end2)
	{
		if (ar[begin1] < ar[begin2])
		{
			tmp[i++] = ar[begin1++];
		}
		else{
			tmp[i++] = ar[begin2++];
		}
	}
	while (begin1 <= end1)
		tmp[i++] = ar[begin1++];
	while (begin2 <= end2)
		tmp[i++] = ar[begin2++];

	//拷贝到原空间
	memcpy(ar + left, tmp, sizeof(int)*(left - right));
}
void MergeSort(int *ar, int left, int right)
{
	int n = right - left;
	int* tmp = (int*)malloc(sizeof(int)*n);
	assert(tmp != NULL);
	//归并排序
	_MergeSort(ar, left, right - 1, tmp);

	free(tmp);
	tmp = NULL;
}

计数排序

（1）思想：统计相同元素出现次数 根据统计的结果将序列回收到原来的序列当中

（2）时间复杂度：O(MAX(N,范围)) 空间复杂度O(N) 稳定性：稳定

#include "slist.h"
#define RADIX 10
SList list[RADIX];
#define K 2
int GetKey(int value, int k)
{
	int key;
	while (k >= 0)
	{
		key = value%10;
		value /= 10;
		k--;
	}
	return key;
}
void Distribute(int* ar, int left, int right, int i)
{
	for (int i = left; i < right; i++)
	{
		int key = GetKey(ar[i], k);
		SListPushBack(&list[key], ar[i]);
	}
}
void Collect(int *ar)
{
	int k = 0;
	for (int i = 0; i < RADIX; ++i)
	{
		while (!SListEmpty(&list[i]))
		{
			ar[k++] = SListFront(list[i]);
			SListPopFront(&list[i]);
		}
	}
}
void RadixSort(int *ar, int left, int right)
{
	for (int i = 0; i < RADIX; ++i)
		SListInit(&list[i]);

	for (int i = 0; i < K; i++)
	{
		//1.分发
		Distribute(ar, left, right, i);
		//2.回收
		Collect(ar);
	}
}

总结

冒泡排序、直接选择排序、直接插入排序------时间复杂度都为O(N^2) 

希尔排序 -----时间复杂度为 O(NlogN)~O(N^2)

堆排序、归并排序、快速排序-----时间复杂度为 O(NlogN) 

稳定：冒泡排序、直接选择排序、直接插入排序、归并排序

不稳定：希尔排序、堆排序、快速排序 

冒泡排序、直接选择排序、直接插入排序、希尔排序、堆排序-----空间复杂度都为O(1)

归并排序-----空间复杂度为O(N)

快速排序-----空间复杂度为O(logN)~O(N)

azure°
关注
专栏目录
交通报警数据标准化排序
浮生辞
08-27 338
交通报警数据标准化处理并生成排序列表。标准化方法通常有标准化法、极值处理法、功效系数法，这里是用标准化法进行处理。 标题 #coding=gbk ''' Created on 2019年7月25日 @author: lenovo ''' import pandas as pd from audioop import avg class MyClass: ''' ...
数据结构--排序之快速排序
qq_52363432的博客
02-08 7650
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。快排每一趟都会有一个元素回到它真正的位置。
数据结构基础7.4：归并排序
u010815257的博客
11-30 361
一.定义 归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的，然后再把有序子序列合并为整体 有序序列。 二.算法描述（递归实现）： 递归过程是将待排序集合一分为二，直至排序集合就剩下一个元素为止，然后不断的合并两个排好序的数组。 三.代码实现（递归实现）： #include #include #include
七大基本排序算法(升序排列)
weixin_72076848的博客
07-13 4618
基本排序算法
sort() 对数值数组进行升序排序
xu776061375的专栏
06-18 1383
实例 对数组 $cars 中的元素按字母进行升序排序： <?php $cars=array("Volvo","BMW","Toyota"); sort($cars); ?> 运行实例 » 定义和用法 sort() 函数对数值数组进行升序排序。 提示：请使用rsort()函数对数值数组进行降序排序。 语法 sort(array,sortingtype); 参数 描述 array 必需。规定要进行排序的数组。 sortingtype 可选。规定如...
用数据标准化算法做文章推荐排序
weixin_30911451的博客
02-19 168
1.前言一直想给自己的网站文章做个排行功能，比如按热门排序，或者按某种推荐算法的计算结果来排，怎么做呢？考虑了下有可以以从这么几个关联的纬度来计算，发布时间，点击率，评论数，文章类型等等。那么发布时间越近，点击评论越高，有深度的文章应该排前面。 2.原始数据假设有这么三篇文章A，发表于2014年7月，点击400，评论0，类型为随笔B，发表于2015年7月，点击200，评论5，类型为技术C，发表于2...
数据结构--九种排序算法 --排序001.cpp
11-22
此文件为数据结构中的九种排序算法，包含一些排序方法的过程，其九种排序包括：直接插入排序，折半插入排序，希尔排序，冒泡排序，快速排序，选择排序，堆排序，归并排序，基数排序！
华中科技大学数据结构试验-排序实验
05-08
华中科技大学数据结构试验——排序实验
数据结构课程设计---排序算法比较
05-20
数据结构课程设计，C语言，七大排序算法比较
数据结构实验报告-内部排序-多种排序算法的实现-(含希尔排序!)-代码及运行截图
12-30
输入n个整数，分别用希尔排序、快速排序、堆排序和归并排序实现由小到大排序并输出排序结果。要求n=10，15，20进行三组排序实验。 实验目的：掌握希尔排序、快速排序、堆排序、归并排序算法。 (zip中含代码及运行...
归一化VS标准化
cz的博客
12-01 3138
简介 归一化（normalization） 标准化（standardization） 其中μ和 σ 代表样本的均值和标准差，X(max)为最大值， X(min)为最小值。 本质 经过数学公式推导，其本质就是一种线性变换 由于线性变化不会改变原始数据的排序，所以这也是归一化或者标准化work的一个重要的点。 区别 转换范围 归一化（Normalization）：把数据转换到(0,1)的数据范围 标准化（Standardization）：把数据转换到均值为0，标准差为1的数据映射方式 数据分布 归
数据预处理（上）之离群值处理、标准化
纸上得来终觉浅
04-30 2万+
https://www.ricequant.com/community/topic/4271/ 一般的数据预处理中常提及到三类处理：去极值、标准化、中性化。这几个词想必大家都不陌生，也许存在疑问或有自己的一番见解，本文将先对前两个进行解释和总结，欢迎讨论和指正~一、离群值处理    因为过大或过小的数据可能会影响到分析结果，尤其是在做回归的时候，我们需要对那些离群值进行处理。实际上离群值和极值是有...
三种常用数据标准化方法
热门推荐
chenpe32cp的博客
08-17 10万+
转载自：https://blog.csdn.net/bbbeoy/article/details/70185798 评价是现代社会各领域的一项经常性的工作，是科学做出管理决策的重要依据。随着人们研究领域的不断扩大，所面临的评价对象日趋复杂，如果仅依据单一指标对事物进行评价往往不尽合理，必须全面地从整体的角度考虑问题，多指标综合评价方法应运而生。所谓多指标综合评价方法，就是把描述评价对象不同方面的...
金融学习之十三——数据去极值和标准化处理
ryo007gnnu的博客
07-07 5681
拿到数据后，数据中可能会存在一些超大或极小的值，这些值与其他的值离得较远，显得格格不入，我们称其为离群点，有时也称为异常点。对于这些值，它的存在会导致影响最终的分析结果，带偏我们的分析。举个简单的例子，10个人的收入分别为2000，2500，2300，2425，2512，2375，2700，2265，2345，10000000，只算前9个，平均值就是2380，但加上最后一个，平均值就是1002144.2，就可能严重带偏最后分析的结果。因此，对于这样的数据，我们需要将其去除或修改。 （一）数据去极值 数据去极
归一化(normalization)/标准化(standardization) 方法汇总
一花一世界 一叶一菩提
05-07 1万+
参考网址：https://www.douban.com/note/292590773/ 使用sklearn处理数据：http://www.cnblogs.com/chaosimple/p/4153167.html 归一化方法（normalization） 归一化是为了加快训练网络的收敛性，可以不进行归一化处理 归一化的具体作用是归纳统一样本的统计分布性。归一化在0-1之间是统计的概率分
标准化和归一化 超全详解
weixin_41888257的博客
09-03 2万+
一、标准化 / 归一化定义 归一化和标准化经常被搞混，程度还比较严重，非常干扰大家的理解。为了方便后续的讨论，必须先明确二者的定义。 首先定义常见的结构化数据表格，第一行的表头是表示各种特征，而后每一列表示某种特征的所有数值。 无论标准化还是归一化都是针对某个特征（某一列）进行操作的。 1. 归一化 就是将训练集中某一列数值特征（假设是第 iii 列）的值缩放到0和1之间。方法如下所示： xi−min⁡(xi)max⁡(xi)−min⁡(xi)\frac{x_{i}-\min \left(x_{i}\rig
【01课_初识算法与数据结构】
最新发布
weixin_42333261的博客
11-10 980
算法，个人理解就是计算一段逻辑，最简化，最快速的方式、方法每个函数，就包含了一定的算法，执行一定的计算逻辑。
数据结构：顺序表（动态顺序表）
小黄鸭的博客
11-09 778
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存。动态顺序表：使用动态开辟的数组存储。静态顺序表：使用定长数组存储元素。在数组上完成数据的增删查改。
数据结构小项目
sinat_28344841的博客
11-10 330
3、界面功能包含：录入学生信息，输出学生信息，任意位置删除学生信息，任意位置插入学生信息，任意位置修改学生信息，任意位置查找学生信息，表头插入一个学生，表尾插入一个学生信息，按照姓名查找学生并删除，按照年龄查找学生并修改其学号为10086。1、使用fscanf和fprintf实现登录注册界面，登录成功显示学生管理系统菜单界面。4、可以使用单链表或者双链表完成，所有功能都需要人为输入，不能写死参数。2、学生信息结构体（学号，姓名，年龄）单链表或者双链表完成学生管理系统。
数据结构-严蔚敏-堆排序算法详解
"这篇资源主要讨论的是数据结构中的堆排序算法，引用了严蔚敏、吴伟民编著的《数据结构(C语言版)》教材，并提到了其他相关参考文献，包括数据结构与算法的学习资料。堆排序是一种基于比较的排序算法，通过构建和调整...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值