【排序】快速排序

已于 2024-02-20 12:15:45 修改
阅读量863 收藏 19
点赞数 20
分类专栏： 数据结构 文章标签： 排序算法 数据结构 算法
于 2024-02-13 13:20:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JX_BC/article/details/136106149
版权

基本思想

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

快速排序分为三种方法：

  • hoare法
  • 挖坑法
  • 前后指针法

而其又可以使用递归和非递归来实现，接下来将依次演示每种方法：

hoare法

单趟动图演示：

在这里插入图片描述

hoare法的快排分为以下步骤：

  1. 选出一个key，一般是第一个数，或者是最后一个数。
  2. 定义变量L和R，L从左走，R从右走。
  3. R先向前走，找到比key小的位置停下，再让L向后走，找到比key大的值停下。
  4. 交换L和R代表的数值。
  5. 继续遍历，同样让R先走，L后走，同上规则。
  6. 当L和R相遇的时候，把相遇位置的值与key位置的值交换，结束。

排完一趟要求（数据特点）如下：

  • 左边的值都比key小。
  • 右边的值都比key大。

那我们在排序过程中如何保证相遇位置的值比key小呢？

  • 不需要保证，此算法思想（右边先走）足矣解决。注意看本算法思想，它明确了每次让R先走，R找到比key小的值之后才会停下来，这时候才轮到L走，L要么找不到比key大的值就一直走直至相遇R，此时正好满足小于key，要么L找到比key大，交换L和R的值，但随后，R又会继续向前走，一直走，最坏刚好遇到L，因为L先前和R已经换过一次，也就是说这个L的值一定是比key小的，那么同样交换key的值，综上，此算法思想足矣解决。

如若key为最右边的值呢？排完一趟如何？

  • 思想和上面一样，唯一要改变的是此时是L先走，R后走，其余没有变。

动图演示：

在这里插入图片描述

  • 接下来，就先写下单趟排序：
//快排单趟排序
int PartSort(int* a, int left, int right)
{
	int keyi = left; //选左边作key
	while (left < right)
	{
		//右边先走，找小
		while (left < right && a[right] >= a[keyi]) //防止right找不到比keyi小的值直接飙出去，要加上left < right
		{
			right--;
		}
		//右边找到后，左边再走，找大
		while (left < right && a[left] <= a[keyi]) //同上，也要加上left < right
		{
			left++;
		}
		//右边找到小，左边找到大，就交换
		Swap(&a[left], &a[right]);
	}
	//此时left和right相遇，交换与key的值
	Swap(a[keyi], &a[left]);
	return left;
}
  • 写好了单趟排序，就要进行整体排序：

仔细观察上述单趟排序，有没有发现排完后，key已经排到了正确的位置，因为其左边的值均小于key，而右边的值均大于key，此时key的位置就是最终排序好后应该在的位置。那么如果左边有序，右边有序，那么整体就有序了，只需要用到递归+分治的思想即可。

  • 画图演示：

在这里插入图片描述

  • 总代码如下：
//hoare
//快排单趟排序
int PartSort(int* a, int left, int right)
{
	int keyi = left; //选左边作key
	while (left < right)
	{
		//右边先走，找小
		while (left < right && a[right] >= a[keyi]) //防止right找不到比keyi小的值直接飙出去，要加上left < right
		{
			right--;
		}
		//右边找到后，左边再走，找大
		while (left < right && a[left] <= a[keyi]) //同上，也要加上left < right
		{
			left++;
		}
		//右边找到小，左边找到大，就交换
		Swap(&a[left], &a[right]);
	}
	//此时left和right相遇，交换与key的值
	Swap(&a[keyi], &a[left]);
	return left;
}
 
//快速排序
void QuickSort(int* a, int begin, int end)
{
	//子区间相等只有一个值或者不存在那么就是递归结束的子问题
	if (begin >= end)
	{
		return;
	}
	int keyi = PartSort(a, begin, end);
	//分成左右两段区间递归
	// [begin, keyi-1] 和 [keyi+1, end]
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

挖坑法

  • 动图演示单趟挖坑：

在这里插入图片描述

挖坑法的步骤如下：

  1. 把最左边的位置用key保存起来，此位置形成坑位。
  2. 定义变量L和R分别置于最左和最右。
  3. 让R先向前走，找到比key小的位置停下。
  4. 找到后，将该值放入坑位，自己形成新的坑位。
  5. 再让L向后走，找比key大的位置停下。
  6. 找到后，将该值放入坑位，自己形成新的坑位。
  7. 再让R走……。
  8. 当L和R相遇时，把key的值放到坑位，结束。

挖坑法相较于上面的hoare法并没有优化，本质上也没有区别，但是其思想更好理解：

  1. 不需要理解为什么最终相遇位置比key小。
  2. 不需要理解为什么左边做key，右边先走。
  • 总代码如下：
//挖坑法
int PartSort2(int* a, int left, int right)
{
	//把最左边的值用key保存起来
	int key = a[left]; 
	//把left位置设为坑位pit
	int pit = left;
	while (left < right) //当left小于right时就继续
	{
		//右边先走，找小于key的值
		while (left < right && a[right] >= key)
		{
			right--; //如若right的值>=key的值就继续
		}
		//找到小于key的值时就把此位置赋到坑位，并把自己置为新的坑位
		a[pit] = a[right];
		pit = right;
 
		//左边走，找大于key的值
		while (left < right && a[left] <= key)
		{
			left++;
		}
		//找到大于key的值就把此位置赋到坑位，并把自己置为新的坑位
		a[pit] = a[left];
		pit = left;
	}
	//此时L和R相遇，将key赋到坑位
	a[pit] = key;
	return pit;
}
 
//快速排序
void QuickSort(int* a, int begin, int end)
{
	//子区间相等只有一个值或者不存在那么就是递归结束的子问题
	if (begin >= end)
	{
		return;
	}
	int keyi = PartSort2(a, begin, end);
	//分成左右两段区间递归
	// [begin, keyi-1] 和 [keyi+1, end]
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

前后指针法

  • 动图演示：

在这里插入图片描述

前后指针法的步骤如下：

  1. 把第一个位置的值设为key保存起来。
  2. 定义prev指针指向第一个位置，cur指向prev后一个位置。
  3. 若cur指向的数值小于key，prev和cur均后移。
  4. 当cur指向的数据大于key时，prev不动，cur继续后移。
  5. 当cur的值小于key时，prev后移一位，交换与cur的值，cur再++。
  6. 重复上述操作，当cur越界时，交换此时的prev和key的值，结束。

总的来说，cur是在找小，找到后就++prev，prev的值无论怎么走都是小于key的值的，当cur找到大与key时，cur的后面紧挨着的prev是小于key的，接下来让cur++到小于key的值，此过程间prev始终不动，唯有cur找到了小于key的值时，让prev再++，此时的prev就是大于key的值了，仔细揣摩这句话，随后交换cur和prev的值，上述操作相当于是把小于key的值甩在左边，大于key的值甩在右边。

  • 总代码如下：
//前后指针法
int PartSort3(int* a, int left, int right)
{
	int key = left;//注意不能写成 int key = a[left]
	int prev = left;
	int cur = prev + 1;
	while (cur <= right)
	{
		if (a[cur] < a[key] && a[++prev] != a[cur]) 
		{
			Swap(&a[prev], &a[cur]);//在cur的值小于key的值的前提下，并且prev后一个值不等于cur的值时交换，避免了交换两个小的（虽然也可以，但是没有意义）
		}
		cur++; //如若cur的值大于key，则cur++
	}
	Swap(&a[prev], &a[key]); //此时cur越界，直接交换key与prev位置的值
	return prev;
}
 
//快速排序
void QuickSort(int* a, int begin, int end)
{
	//子区间相等只有一个值或者不存在那么就是递归结束的子问题
	if (begin >= end)
	{
		return;
	}
	int keyi = PartSort2(a, begin, end);
	//分成左右两段区间递归
	// [begin, keyi-1] 和 [keyi+1, end]
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

如若把key设定为最后一个数据呢？该如何控制？

  • 总的来说有三处发生变动：
  1. cur和prev初始时的位置：先前定义的prev是第一个数据，cur是prev的后一个，而现在，cur是第一个位置，而prev是cur的前一个，相当于是初始时整体后移一位。
  2. 停止的条件： 原先的cur有效范围是整个数组，现在的cur有效范围是前n-1个数组，省去最后一个定为key的值。
  3. 交换与key的值的条件： 先前是cur越界时，直接交换prev与key的值，现在是先++prev，再交换与key的值，（因为此时的prev值依旧小于key，要++后才大于key）。

除了这三处有所变动外，别的没有什么变动，交换的过程步骤都是一样的。

  • 动图演示：

在这里插入图片描述

  • 代码如下：
//前后指针法key在右边
int PartSort3(int* a, int left, int right)
{
	int key = right;
//变动1：	int prev = left - 1;  //先前 int prev =left;   int cur = left + 1;
	int cur = left;
//变动2：	while (cur < right)  //先前 while (cur <= right) 
	{
		if (a[cur] < a[key] && a[++prev] != a[cur]) 
		{
			Swap(&a[prev], &a[cur]); 
		}
		cur++;  
	}
//变动3：	Swap(&a[++prev], &a[key]); //先前Swap(&a[prev], &a[key]);
	return prev;
}
 
//快速排序
void QuickSort(int* a, int begin, int end)
{
	//子区间相等只有一个值或者不存在那么就是递归结束的子问题
	if (begin >= end)
	{
		return;
	}
	int keyi = PartSort3(a, begin, end);
	//分成左右两段区间递归
	// [begin, keyi-1] 和 [keyi+1, end]
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

快排特性总结

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序。
  2. 稳定性：不稳定。
  3. 空间复杂度：O(logN)。
  4. 时间复杂度：O(N*logN)。

快排的时间复杂度分两种情况讨论：

  1. 最好：每次选key都是中位数，通俗讲是左边一半右边一半，具体看是key的左序列长度和右序列长度相同。时间复杂度O(N*logN)
  2. 最坏：每次选出最小的或者最大的作为key。时间复杂度O(N^2)

画图分析：

在这里插入图片描述

可能有人会觉着正常的数组怎么会次次都会选出最小的或者最大的作为key呢？这也太巧合了，但是仔细想想，当数组是有序或者接近有序时，不就是最坏的情况吗？更何况如若数据量再大一点，程序很有可能会因为数据量过多而递归次数过多以至于栈溢出，

综上我们需要深思：能否针对快排最坏的情况进行优化？看下文：

快排优化

就以最坏的情况为例：

在这里插入图片描述

三数取中

对于我们自己来说，是很清楚其是有序的，可计算机并不清楚，它依旧是选取最左边或者最右边作为key，如果key不是取最小或者最大的，取出的值是介于之间的，那么情况也会好很多，至此：引出三数取中

  • 规则：

取第一个数，最后一个数，中间那个数，在这三个数中选不是最大也不是最小的那个数作为key。此法针对有序瞬间从最坏变成最好，针对随机数，那么选出来的数也同样不是最大也不是最小，同样进行了优化。
三数取中其实针对hoare法，挖坑法，前后指针法都适用，这里我们就以前后指针法示例：

  • 总代码如下：
//快排
//三数曲中优化
int GetMidIndex(int* a, int left, int right)
{
	int mid = (left + right) / 2; // int mid = left + (right - left) / 2
	// left  mid  right
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right]) // left < mid < right
			return mid;
		else if (a[left] < a[right]) // left < right <mid
			return right;
		else  // right < left < mid
			return left; 
	}
	else // left > mid
	{
		if (a[right] > a[left]) // right > left > mid
			return left;
		else if (a[mid] > a[right])// left > mid > right
			return mid;
		else // left > right > mid
			return right;
	}
}
 
//前后指针法
int PartSort3(int* a, int left, int right)
{
	//三数取中优化
	int midi = GetMidIndex(a, left, right);
	Swap(&a[midi], &a[left]);
 
	int key = left;//注意不能写成 int key = a[left]
	int prev = left;
	int cur = prev + 1;
	while (cur <= right)
	{
		if (a[cur] < a[key] && a[++prev] != a[cur]) 
		{
			Swap(&a[prev], &a[cur]); 
		}
		cur++;  
	}
	Swap(&a[prev], &a[key]);  
	return prev;
}
 
//快速排序
void QuickSort(int* a, int begin, int end)
{
	//子区间相等只有一个值或者不存在那么就是递归结束的子问题
	if (begin >= end)
	{
		return;
	}
	int keyi = PartSort3(a, begin, end);
	//分成左右两段区间递归
	// [begin, keyi-1] 和 [keyi+1, end]
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

小区间优化

假设快排每次递归的过程中，选出key，然后递归分成左边和右边，并且都是均匀的，如果是有序，每次选中间值，这个过程就像是二分，跟二叉树的样子差不多，正如上述画过的图：

在这里插入图片描述

快排递归调用的简化图其实就类似于一个二叉树，假设长度N为1000，那么递归调用就要走logN层也就是10层，假设其中一个递归到只有5个数了，那么还要递归3次，当然这只是左边的，右边还要递归3次，这么小的一块区间还要递归这么多次，小区间优化就是为了解决这一问题，针对最后的小区间进行其它的算法排序，就比如插入就很可以。

当递归到越小的区间时，递归次数就会越多，针对这一小区间采取插入排序更优，减少了大量的递归次数。

  • 代码如下：
//三数取中优化
int GetMidIndex(int* a, int left, int right)
{
    //……
}
 
//前后指针法
int PartSort3(int* a, int left, int right)
{
	//三数取中优化
	int midi = GetMidIndex(a, left, right);
	Swap(&a[midi], &a[left]);
    //……
}
 
//小区间优化
void QuickSort2(int* a, int begin, int end)
{
	//子区间相等只有一个值或者不存在那么就是递归结束的子问题
	if (begin >= end)
	{
		return;
	}
	//小区间直接插入排序控制有序
	if (end - begin + 1 <= 10)
	{
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		int keyi = PartSort3(a, begin, end);
		// [begin, keyi-1] 和 [keyi+1, end]
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
}

快排非递归

先前的学习中，我们的快排都是用递归来实现的，但是要知道：递归也是有缺陷的。如果深度过大，可能会导致栈溢出，即使你用了快排优化可能也无法解决此问题，所以我们引出非递归的版本来解决栈溢出问题。

  • 规则：

在快排递归的过程中是要建立栈帧的，仔细看看每次递归时传的参数，有begin和end，其递归过程存储的是排序过程中要控制的区间，那我们用非递归模拟递归的过程中也要按照它这个存储方式进行，这就需要借助栈了，跟上篇博文的层序遍历一样利用到了栈。

在这里插入图片描述

  • 代码如下：
//快排非递归
void QuickSort3(int* a, int begin, int end)
{
	ST st;
	StackInit(&st);
	//先把第一块区间入栈
	StackPush(&st, begin);
	StackPush(&st, end);
	while (!StackEmpty(&st)) //栈不为空就继续
	{
		int right = StackTop(&st);
		StackPop(&st);
		int left = StackTop(&st);
		StackPop(&st);
 
		//使用前后指针法进行排序
		int keyi = PartSort3(a, left, right); // keyi已经到了正确位置
 
		// [left, kryi-1]  [keyi+1, right]
		if (left < keyi - 1)//如若左区间不只一个数就入栈
		{
			StackPush(&st, left);
			StackPush(&st, keyi - 1);
		}
		if (keyi + 1 < right)//若右区间不只一个就入栈
		{
			StackPush(&st, keyi + 1);
			StackPush(&st, right);
		}
	}
	StackDestory(&st);
}

上述代码恰好巧妙的实现了递归的过程，仔细观察上述代码，一开始我们入栈了下标为begin和end的值，如下：

在这里插入图片描述

随后，取出这两个值，并用right和left分别保存起来，随后对区间[left，right]这块区间进行单趟排序，取出keyi的值为5，此时a[keyi]也就排到了正确的位置了，接下来就是效仿递归的关键了，以keyi为分界线，将数组分为两块区间：【left，keyi-1】和【keyi+1，right】，此时再把这两块区间的入栈：

在这里插入图片描述

接下来进入第二趟while循环，同样是再次出栈里的两个数据6和9，并再次传入单趟排序，算出keyi的值为8，也就意味着a[keyi]到了正确的位置，再以keyi为分界线，将右区间的数组分为【6，7】和【9，8】以此类推……一直排下去。

.滄海难为水
关注
专栏目录
基础排序 冒泡排序 插入排序 快速排序 双路快速排序 三路快速排序 堆排序.zip
03-20
快速排序 基础排序 冒泡排序 插入排序 快速排序 双路快速排序 三路快速排序 堆排序.zip
快速排序（过程图解）
热门推荐
第一楼主的博客
07-02 41万+
假设我们现在对“612 79345 108”这个10个数进行排序。首先在这个序列中随便找一个数作为基准数（不要被这个名词吓到了，就是一个用来参照的数，待会你就知道它用来做啥的了）。为了方便，就让第一个数6作为基准数吧。接下来，需要将这个序列中所有比基准数大的数放在6的右边，比基准数小的数放在6的左边，类似下面这种排列。 312 5469 ...
简述冒泡排序与快速排序
一恍过去
05-01 2万+
简述冒泡排序与快速排序
冒泡排序快速排序
qq_45896330的博客
12-11 8675
冒泡排序 int a[] = {-2,10, 5,1,9,-8,4,6,7,8,2,3}; //冒泡排序 for (int i = 0; i < a.length-1; i++) { for (int j = 0; j < a.length-i; j++) { if (a[j]>a[j+1]){ int temp = a[j];
快速排序详解
LiangXiay的博客
11-19 11万+
1.什么是快速排序 我们知道排序有很多种，常见的如希尔排序，插入排序，选择排序，堆排序等等，而快速排序也是排序家族中的一员。因为其在大多数情况下有着优秀的综合性能，快速排序的快速也算是实至名归，接下来就为大家讲解快速排序的思想与实现。 2.快速排序的核心思想 快速排序通过多次比较与交换来完成排序。而这个过程又被分为了多次重复单趟排序，接下来我们先从每一趟的排序讲起。 快速排序的单趟排序思想是： 在一个无序数组中取一个数key，每一趟排序的最终目的是：让key的左边的所有数小于key，key的右边都
分治法快速排序
qq_45908718的博客
05-23 4888
快速排序 快速排序是按照元素的值对他们进行划分。划分是对给定数组中的元素的重新排列,使得A[s]左边的元素都小于等于A[s],而所有A[s]右边的元素都大于等于A[s]。 A[0]…A[s-1] A[s] A[s+1]…A[n-1] 建立了一个划分后，A[s]已经位于它在有序数组中的最终位置，接下来我们对A[s]前和A[s]后的子数组分别进行排序（使用同样的方法），注意在快速排序中，算法的主要工作在于划分阶段，而不需要再去合并子问题的解了 快速排序的划分算法 QuickSort(A[l…r]) //用Qu
python冒泡排序 快速排序算法.zip
03-28
python冒泡排序
随机快速排序
01-08
* 快速排序3.0 —— 随机快排，时间复杂度收敛于 O(NlogN) */ public class QuickSort { /** * * @param arr 需要排序的数组 * @param L 需要排序部分的左边界 * @param R 需要排序部分的右边界 */ public ...
递归实现快速排序
12-21
以前学习数据结构的时候写快排用的循环都是双重for循环，今天偶尔看到了运用递归来实现快速排序，所以突发想记录一下。由于我以前学过c和java,现在在自学python，所以一下代码均为python。但基本思想是一样的。 1....
c++ 快速排序
04-09
快速排序c++实现代码 它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归...
希尔排序算法（经典常见）
m0_70437378的博客
05-14 254
接着第二层循环是 j 每次都会减去gap，此时若 j 位置是负数就比较 j 与tmp 的值。首先第一个循环是遍历数组，i 从gap开始，j 从 i - gap开始。1、前面部分是设置循环 获取每次的gap的值，同时调用对应的排序方法。
[数据结构——Java]包装类&简单认识泛型
qq_63492484的博客
05-17 845
一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。通俗讲就是：返回的Object数组里面，可能存放的是任何的数据类型，可能是String，可能是Person，运行的时 候，直接转给Integer类型的数组，编译器认为是不安全的。我们不要自己去使用裸类型，裸类型是为了兼容老版本的 API 保留的机制 下面的类型擦除部分，我们也会讲到编译器是如何使用裸类型的。（5）注释4处，代码编译报错，此时因为在注释2处指定类当前的类型，此时在注释4处，编译器会在存放元素的时 候帮助我们进行类型检查。
数据结构——堆的定义，堆的数据操作函数以及堆对数组的排序知识点详解！！
hu_ju_hong的博客
05-18 804
堆和使用堆进行数组的排序知识详解！
数据结构-堆刷题集
2301_81486828的博客
05-17 281
典型的topK问题,topK问题经常用于这种返回k个极值的问题,比如上面的推送问题,这里的topK我们计数的时候设计了一个类专门用来储存我们的数据,因为(Hash表我们还没学)我们在hash计数的时候,在遇到负数的情况的时候,我们就采用了两个hash来映射计数,一个映射正数,一个映射负数,代码实现如下。同样的,我们依然选择自己写一个类来模拟hash表的作用,代码实现如下。
数据结构 | 详解栈实现队列&队列实现栈
mooridy的博客
05-17 322
step2：此时非空队列中剩下的唯一一个数就是“栈顶”元素，使用QueueFront进行·取值后，直接进行QueuePop删除。step0.先利用假设法假定非空队列notempty和空队列empty，再利用MyStackEmpty函数对进行修正。step1:将notempty队列中的前size-1个元素依次push到empty队列中，再进行删除，实现移动操作。
【数据结构】单链表定义和基本操作（增删查改求长度）|前插 |后插
2301_77611317的博客
05-15 926
单链表的定义和基本操作（增删查改）任意物理位置的存储单元来存放数据元素存储单元可以连续，也可以不连续与顺序表不同，链表元素并不一定按顺序排列；链表是根据结点指针来确定元素位置的本文简单介绍了单链表的定义和基本操作（增删查改）如果文章的论述或代码等出现错误，欢迎前来指正！
数据结构总结与练习题
最新发布
关注收藏，可以私信解决问题！
05-20 189
数据结构：数组、链表、栈、队列、哈希表、树、图。算法：排序（冒泡排序、快速排序、归并排序）、搜索算法、动态规划、贪心算法、图算法。操作系统：进程管理、内存管理、文件系统、输入/输出管理。计算机网络：网络层协议（IP、ICMP）、传输层协议（TCP、UDP）、应用层协议（HTTP、FTP、DNS）。编程语言：基础语法、控制结构、数据类型、面向对象编程、函数式编程。知识点数组：固定大小的连续内存空间。链表：由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。
数据结构2（初）：顺序表和链表
yi_ren_yi_xin的博客
05-17 875
数据结构顺序表和链表
二叉树基础oj练习【11道题】
aaa114514aaaa的博客
05-14 816
有关二叉树的基础oj题（11道题目）的详细解析和代码实现
冒泡排序快速排序优缺点
03-27
冒泡排序和快速排序都是常见的排序算法，它们各自有不同的优缺点。 冒泡排序的基本思想是通过相邻元素的比较和交换来将较大的元素逐渐“冒泡”到数组的末尾。具体步骤如下： 1. 从数组的第一个元素开始，依次比较...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值