快速排序和归并排序非递归的详解

置顶 已于 2022-11-13 23:52:04 修改
阅读量1.2k 收藏 22
点赞数 26
分类专栏： 数据结构 C语言 算法 文章标签： 数据结构 算法 c语言 c++ 排序算法
于 2022-11-13 23:49:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Miraitowa_GT/article/details/127756923
版权
数据结构 同时被 3 个专栏收录
11 篇文章 2 订阅
订阅专栏
算法
7 篇文章 1 订阅
订阅专栏
C语言
3 篇文章 0 订阅
订阅专栏
本文介绍了如何使用非递归方法实现快速排序和归并排序。对于快速排序，通过栈来模拟递归过程，避免了深度递归可能导致的栈溢出问题；而对于归并排序，直接采用循环处理，避免了递归。两种非递归方法在性能上与递归版本相当，但解决了栈空间限制的问题。文章还详细讨论了在不同情况下如何处理边界条件，确保排序的正确性。
摘要由CSDN通过智能技术生成

在经过主页中《八大排序》（下）的学习，我们了解了快速排序和归并排序且都是递归的思想，但是如果递归的深度很深呢？这一节我们就引出用非递归的思想解决这个问题。😵😵😵

快速排序非递归及归并排序非递归

快速排序非递归

大家都知道递归是在栈帧上建立空间（Windows默认1兆，Linux默认8兆），如果递归的深度太深，建立的栈帧过大呢？
在这里插入图片描述
**递归的缺陷：**如果栈帧的深度太深，栈空间不够用，就会导致栈溢出。

思想

既然递归有一定的缺陷，那么我们怎么确定非递归的思路呢？

  • 1.直接改循环（但是只能针对比较简单的）；
  • 2.借助数据结构的栈来模拟递归过程（针对复杂情况）。

针对快排我们就用第二种思路。第二种非递归思想中用到的栈是我们malloc出来的，是在堆上申请的，堆上的空间很大，和操作系统的栈并 不是一样的。😋😋😋

步骤：

  • 单趟和挖坑法一样，既然是模拟递归，那么和递归是很相似的
  • 1.先在序列中选出一个基准值keyIndex，并将这个keyIndex放到相应地位置上，使左边比keyIndex小，右边比keyIndex大；
  • 2.将整个区间划分三个区间：[left,keyIndex-1] keyIndex [keyIndex+1,right]，由于栈是先进后出的原则，先把右区间压栈到下面，左区间压栈到上面；
  • 3.如果左半区间内有多个数据，重复步骤1和步骤2，直到左半区间全部处理完了，再去处理右区间；
  • 4.如果右半区间内有多个数据，重复步骤1和步骤2，当右半区间有序后，整个序列就就是有序的。
    在这里插入图片描述

代码

void QuickSortNonR(int* a,int n)
{
	ST st;
	StackInit(&st);//初始化一个栈
	StackPush(&st, n - 1);//把数组中最后一个元素入进去
	StackPush(&st, 0);//把数组中第一个元素入进去
	while (!StackEmpty(&st))
	{
		int left = StackTop(&st);//取栈顶数据
		StackPop(&st);//出栈

		int right = StackTop(&st);
		StackPop(&st);

		//单趟排选谁无所谓
		int keyIndex = PartSort1(a, left, right);//这里单趟排序用的是挖坑法，前后指针和左右指针都可以。
		//[left,keyIndex-1] keyIndex [keyIndex+1,right]此时数组被分为了三个区间
		//入栈先入右区间，再入左区间，这样就可以先处理左区间，再处理右区间
		if (keyIndex + 1 < right)//表示右区间内还有多个数据，无序就入栈
		{
			StackPush(&st, right);
			StackPush(&st, keyIndex + 1);
		}
		if (left < keyIndex - 1)//表示左区间内还有多个数据，无序就入栈
		{
			StackPush(&st, keyIndex - 1);
			StackPush(&st, left);
		}
	}

	StackDestory(&st);
}
void TestQuickSort()
{
	int a[] = { 49, 38, 65, 97, 76, 13, 27, 49 };
	QuickSortNonR(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

快排非递归总结

快排非递归思想性能和递归思想两者性能几乎没有差距，但是非递归很好的解决了栈溢出问题。

归并排序非递归

思想

在上文中我们了解到递归改非递归有两种，一种是循环解决，另一种是用栈模拟递归😊😊😊
这里我们使用循环就完全可以了。归并排序递归思想和非递归思想恰恰相反，递归思想是将序列分解为不可再分的子序列再进行归并，而非递归是将序列直接以不可再分的子序列进行归并。如图：
在这里插入图片描述

代码

void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);

	int gap = 1;//每组数据个数
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			//[i,i+gap-1] [i+gap,i+2*gap-1]
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			int index = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[index++] = a[begin1++];
				}
				else
				{
					tmp[index++] = a[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				tmp[index++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[index++] = a[begin2++];
			}
			//拷贝回去--把临时数组内的元素拷贝到原数组中
			
		}
		for (int j = 0; j < n; ++j)
		{
			a[j] = tmp[j];
		}
		gap *= 2;//刚才是11一组归并，*=2让2倍归并
	}

	free(tmp);
}
void TestMergeSort()
{
	int a[] = { 10, 6, 7, 1, 3, 9, 4, 2 };
	MergeSortNonR(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}
int main()
{
	printf("归并排序-非递归：");
	TestMergeSort();
	return 0;
}

问题：😧😧😧

上面是我们理想的状态，就像满二叉树一样，数组长度不是2的整数次方的话，就会存在数组越界的情况，总结一下有以下三种情况：
在这里插入图片描述

  • 1.归并过程中左区间存在，但是右半区间不存在；
  • 2.归并过程中左区间存在，但是右半区间有且只有一部分；
  • 3.归并过程中左半区间有且只有一部分，右半区间不存在。

问题处理：😖😖😖

对上面三个问题的解决：

  • 1.那就不需要归并了
    if (begin2 >= n) break;
  • 2.将end2修正一下
    if (end2 >= n) { end2 = n - 1; }
  • 3.不对左半区间进行处理，将拷贝回去的代码放到for循环里，归并一部分拷贝一部分
    for (int j = i; j <= end2; ++j) { a[j] = tmp[j]; }
//归并排序——非递归
//时间复杂度是O(N*logN)
void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int)*n);

	int gap = 1;//每组数据个数
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2*gap)
		{
			//[i,i+gap-1] [i+gap,i+2*gap-1]
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			//归并过程中右半区间可能不存在
			if (begin2 >= n)
				break;
			//归并过程中右半区间有且不多（算多了）修正一下
			if (end2 >= n)
			{
				end2 = n - 1;
			}
			int index = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[index++] = a[begin1++];
				}
				else
				{
					tmp[index++] = a[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				tmp[index++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[index++] = a[begin2++];
			}
			//拷贝回去--把临时数组内的元素拷贝到原数组中
			for (int j = i; j <= end2; ++j)
			{
				a[j] = tmp[j];
			}
		}
		gap *= 2;//刚才是11一组归并，*=2让2倍归并
	}

	free(tmp);
}
void TestMergeSort()
{
	int a[] = { 10, 6, 7, 1, 3, 9, 4, 2 };
	MergeSortNonR(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

归并非递归总结

时间复杂度还是不错的和归并排序递归是一样的都是O(N*logN)。

总代码

Stack.h

#include <stdio.h>
#include <stdbool.h>
#include <assert.h>
#include <stdlib.h>
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;//是一个指针指向这个数组
	int top;//栈顶
	int capacity;//容量
}ST;

//栈需要的接口
// 初始化栈
void StackInit(ST* ps);
// 销毁栈
void StackDestory(ST* ps);
//入栈
void StackPush(ST* ps, STDataType x);
//出栈
void StackPop(ST* ps);
//取栈顶的数据
STDataType StackTop(ST* ps);
//栈的数据个数
int StackSize(ST* ps);
//检测栈是否为空，如果为空返回非零结果，如果非空返回0 
bool StackEmpty(ST* ps);//用布尔来判断真假更好用，但是注意引用头文件

Stack.c

#include"Stack.h"

void StackInit(ST* ps)
{
	assert(ps);
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	ps->capacity = 4;
	ps->top = 0;
}

void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

void StackPush(ST* ps, STDataType x)
{
	assert(ps);

	//满了怎么办？---增容
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity *= 2;//乘等2才会变成它的二倍
		}
	}

	ps->a[ps->top] = x;
	ps->top++;
}

void StackPop(ST* ps)
{
	assert(ps);
	//栈空了，调用pop，直接中止程序并报错
	assert(ps->top > 0);

	ps->top--;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	//栈空了，调用top，直接中止程序并报错
	assert(ps->top > 0);

	return ps->a[ps->top - 1];
}

int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;//top所在数组的下标就是栈的长度
}

bool StackEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;//如果为空返回非零结果，如果不为空返回0
}

Sort.c

这里因为快速排序非递归中用到了单趟排序，所以直接在拷贝了一份挖坑法的单趟排序，不理解的可以去看《八大排序》（下）

#include"Stack.h"
void PrintArray(int* a, int n)
{
	for (int i = 0; i < n; ++i)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}
//交换
void Swap(int* p1, int* p2)
{
	int* tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//三数取中--为了解决我们key选择的数不是最大，也不是最小的
int GetMidIndex(int* a, int left, int right)
{
	int mid = (left + right) >> 1;
	if (a[left] < a[mid])//如果左小于中间
	{
		if (a[mid] > a[right])//如果左小于中间，中间大于右，则返回中间
		{
			return mid;
		}
		else if (a[left] > a[right])//如果左小于中间，左大于右，则返回左
		{
			return left;
		}
		else
		{
			return right;//如果左小于中间，中间大于右，则返回右
		}
	}
	else //a[left] > a[mid]
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}
int PartSort1(int* a, int left, int right)
{
	int index = GetMidIndex(a, left, right);//三数取中
	//Swap(&a[left], &a[index]);
	int begin = left, end = right;
	int pivot = begin;
	int key = a[begin];
	//单趟排序
	//单趟排序时间复杂度是O(N)-begin从左向右走，end从右向左走
	while (begin < end)
	{
		//右边找小，放到左边
		while (begin < end && a[end] >= key)
			--end;
		//小的放到左边的坑里，自己形成新的坑位
		a[pivot] = a[end];
		pivot = end;

		//右边找大
		while (begin < end && a[begin] <= key)
			++begin;
		//大的放到右边的坑里，自己形成新的坑位
		a[pivot] = a[begin];
		pivot = begin;
	}
	//把小的放到pivot的左边，大的放到pivot的右边后，把key的值放到数组pivot的位置
	pivot = begin;
	a[pivot] = key;

	//返回的是坑的位置
	return pivot;
}




//快速排序--非递归
void QuickSortNonR(int* a, int n)
{
	ST st;
	StackInit(&st);//初始化一个栈
	StackPush(&st, n - 1);//把数组中最后一个元素入进去
	StackPush(&st, 0);//把数组中第一个元素入进去
	while (!StackEmpty(&st))//当栈里没有区间的时候就结束
	{
		int left = StackTop(&st);
		StackPop(&st);

		int right = StackTop(&st);
		StackPop(&st);

		//单趟排选谁无所谓
		int keyIndex = PartSort1(a, left, right);//这里单趟排序用的是挖坑法，前后指针和左右指针都可以。
		//[left,keyIndex-1] keyIndex [keyIndex+1,right]此时数组被分为了三个区间
		//入栈先入右区间，再入左区间，这样就可以先处理左区间，再处理右区间
		if (keyIndex + 1 < right)//表示右区间内还有多个数据，无序就入栈
		{
			StackPush(&st, right);
			StackPush(&st, keyIndex + 1);
		}
		if (left < keyIndex - 1)//表示左区间内还有多个数据，无序就入栈
		{
			StackPush(&st, keyIndex - 1);
			StackPush(&st, left);
		}
	}

	StackDestory(&st);//栈销毁
	//非递归中malloc的空间是在操作系统的堆上面的，因为堆很大，所以空间并没有什么影响，
	//malloc的空间是在操作系统上的，与数据结构的栈（栈和队列）和堆（二叉树）没有关系
}
void TestQuickSort()
{
	int a[] = { 49, 38, 65, 97, 76, 13, 27, 49 };
	QuickSortNonR(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

//归并排序——非递归
//时间复杂度是O(N*logN)
void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);

	int gap = 1;//每组数据个数
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			//[i,i+gap-1] [i+gap,i+2*gap-1]
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			//归并过程中右半区间可能不存在
			if (begin2 >= n)
				break;
			//归并过程中右半区间有且不多（算多了）修正一下
			if (end2 >= n)
			{
				end2 = n - 1;
			}
			int index = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[index++] = a[begin1++];
				}
				else
				{
					tmp[index++] = a[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				tmp[index++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[index++] = a[begin2++];
			}
			//拷贝回去--把临时数组内的元素拷贝到原数组中
			for (int j = i; j <= end2; ++j)
			{
				a[j] = tmp[j];
			}
		}
		gap *= 2;//刚才是11一组归并，*=2让2倍归并
	}

	free(tmp);
}
void TestMergeSort()
{
	int a[] = { 10, 6, 7, 1, 3, 9, 4, 2 };
	MergeSortNonR(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

int main()
{
	printf("快速排序-非递归:");
	TestQuickSort();

	printf("归并排序-非递归：");
	TestMergeSort();
	return 0;
}

结语

熬夜写的，写着写着脑子就不太灵光了，懵懵的😩😩😩文章中有错误欢迎大家积极指出哦😚😚😚

#唐解元
关注
专栏目录
排序算法之-快速排序（递归和非递归）
you_never_alone的博客
08-27 945
哭唧唧
JS快速排序详解——递归与非递归
热门推荐
徐杨鑫磊的技术博客
07-17 1万+
基本介绍： 快速排序(quickSort)是基于冒泡排序的一种改进，该排序算法采用了分治的思想，将待排序数组逐步划分两个部分，其中左半部分都要小于右半部分，再将左右部分分别进行快速排序，整个过程可采用递归进行，直到排成一个有序数列。 整体步骤： ① 选取待排序数组中其中一个数作为基数(建议选取第一个数)，使flag等于基数的下标，left等于待排序数组第一个数的下标，right等于待排序数组...
快速排序的递归方式和非递归方式
weixin_30832983的博客
10-01 135
我们知道快递排序大部分的版本都是递归的方式来实现的：通过Pritation来实现划分，并递归实现前后的划分。由于同学上次百度二面面试官问起快速排序的非递归的实现方式，当时同学不会，因为我们大部分看到的都是递归方式来实现快速排序。并没有关注非递归的方式。但是仔细想想也是可以做的，因为递归的本质是栈，因此我们非递归实现的过程中，借助栈来保存中间变量就可以实现非递归了。在这里中间变量也就是通过...
快速排序的递归和非递归分析
脚踏实地，用心编写出客户满意的代码，为公司创造出应有的价值。
08-21 921
1、算法思想     　快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。 （1） 分治法的基本思想     　分治法的基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。 （2）快速排序的
快速排序 递归与非递归
wenzhunpu的专栏
12-25 1451
绪论： 由于平常用c++STL里面的sort习惯了，所以很少用过快速排序，同时也对快速排序有一种恐惧感，一直以为自己不会写，但是仔细想想快排的思想，还是很容易理解的， 只要思维达到一个高度，就都不是问题了。 交换排序：说到快排，就要先说到交换排序，因为快排是交换排序的一种，而说的交换排序，就不得不先说最简单的冒泡排序。因为任何高明的算法都不是一下子就能想出来的，都是在已有的基础上进行不断的优化
快速排序的递归形式和非递归形式
weixin_43850474的博客
05-29 222
图解快速排序 假如有如下所示的一组序列
归并排序详解：递归与非递归实现及复杂度分析
"本文主要介绍了归并排序的原理、递归和非递归实现方法以及算法复杂度分析。归并排序是一种基于分治策略的排序算法，与快速排序类似，但区别在于归并排序的划分基准是数组的中间元素。文章提供了一个递归版本的归并...
【递归在排序算法中的角色】：快速排序与归并排序中的递归应用
[【递归在排序算法中的角色】：快速排序与归并排序中的递归应用](https://img-blog.csdnimg.cn/140a0af84d3049d5bec41d52686e167a.png) # 1. 排序算法概述与递归基础 排序算法作为计算机科学的核心组成部分，其重要...
详解七大基本排序：选择排序、冒泡排序、插入排序、希尔排序、归并排序、快速排序、堆排序
weixin_47270825的博客
03-22 1236
模板前言一、排序1.排序种类二、1.选择排序总结 前言 一、排序 1.排序种类 二、 1.选择排序 每次从无序区间选择一个最大或最小值，存放在无序区间的最前或最后的位置（此位置的元素已经有序），直到所有的数据都排序完成为止 总结 ...
希尔排序、快速排序、归并排序、二分查找
m0_55111053的博客
10-29 331
文章目录希尔排序希尔排序过程时间复杂度快速排序时间复杂度归并排序时间复杂度常见排序算法效率比较搜索二分法查找时间复杂度 希尔排序 希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL．Shell于1959年提出而得名。 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。 希尔排序过程 希尔排序的基本思
详解快速排序（递归）和非递归
qq_45229484的博客
12-29 1335
快排递归 快速排序hearo版(左右指针法)
快速排序详解(递归和非递归实现)
weixin_61488314的博客
03-26 438
排升序时我们的目的就是要让比基准大的值向后走,比基准小的值向前走,在交换前prev的下一个值一定是cur走过的,如果是小值cur就在这里停下来了,就会交换,然而如果在这没停下来就一定是比基准大或等于它的值,所以当cur找到小值时和prev的下一个值交换就保证了一定是大值和小值交换。此外如果是选择最右侧的值作为基准,那么此时prev = -1;因为我们选的最左边的值为基准然后让右边的下标先移动去找比基准小的值,然后才让左边的走去找比基准大的值,也就是说只有找到比基准小的值之后才会去找比基准大的值。
快速排序的递归和非递归实现
【逸辰杳】的博客
06-06 499
快速排序算法的核心思想 --- 将一个完整的，带排序的数列分割成两部分，并分别对每部分按照再分割，再排序的思想。从而实现整个序列上的排序过程。 代码如下： package Sort; /** * QuickSort算法 * @author YHYR * */ public class QuickSort { public static void main(String[] arg
《排序算法篇》快排的递归与非递归
m0_62171658的博客
04-21 9333
快排的思想 实现单趟快排的三种方式（hoare、挖坑、前后指针） 递归实现快排 对快排进行优化（三数取中，小区间优化） 非递归实现快排（栈或队列实现）
快速排序的非递归实现
xx123427的博客
10-07 1522
快速排序的思想是先从一数列中找出一个枢轴点，这个枢轴点左边的数都比它小，右边的数都比它大，也就是说枢轴点的位置已经是有序的了。例如 5 1 7 9  2   3 8   使用一次快速排序后会变成这样· · · 5 · · ·。 1，2，3会在5的左边，7，8，9在5的右边，5在第四个位置，5是枢轴点，且不会再变动了。  如果最终排序完毕，数列会是   1 2 3  5  7 8 9
数据结构（快速排序——非递归实现）
wfea_lff的博客
02-18 939
快速排序 快速排序由C. A. R. Hoare在1962年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 在之前已经说过了快速排序的递归实现 递归实现：https://blog.csdn.net/wfea_lff/arti...
快速排序————非递归实现
最新发布
2201_75943325的博客
06-11 1335
大家有可能会想是不是因为递归非常的占用空间，我们都知道我们的局部变量是保存在栈上的我们的函数参数也是在栈上开辟的，所以说递归是不是会占用我们非常多的栈空间，同时呢我们的递归是一个非常深的一个操作，我们往往会因为一个函数递归出来的结果而去让这个函数重复调用多次去解决我们当前的问题，我们的快速排序非递归就是这样的方式，也包括之前的一个斐波那契数列使用递归去解决都是使用了栈；这样的方法在递归的深度不大的时候不会产生什么问题但是如果我们需要去处理的数据非常多，递归的深度非常深那么我们这个时候递归真的不会出现问题吗。
快速排序（递归+非递归）
Singular__point的博客
12-14 2437
#include #include #include using namespace std; //---------------实现一趟排序------------- int part(int a[],int first,int last) { int key=a[first]; while(first<last) { while(first=key)
评论 24
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

#唐解元

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值