数据结构之九大排序算法C++

最新推荐文章于 2023-05-18 22:06:55 发布
最新推荐文章于 2023-05-18 22:06:55 发布
阅读量2.1k 收藏 8
点赞数
分类专栏： C++学习之路 数据结构 数据结构基础算法 文章标签： 数据结构 C++ 九大排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/J_Anson/article/details/50532942
版权

  九大数据结构排序算法的实现

targetver.h

#pragma once

// 包括 SDKDDKVer.h 将定义可用的最高版本的 Windows 平台。

// 如果要为以前的 Windows 平台生成应用程序，请包括 WinSDKVer.h，并将
// WIN32_WINNT 宏设置为要支持的平台，然后再包括 SDKDDKVer.h。

#include <SDKDDKVer.h>


stdafx.h

// stdafx.h : 标准系统包含文件的包含文件，
// 或是经常使用但不常更改的
// 特定于项目的包含文件
//
#define _AFXDLL
#pragma once

#include "targetver.h"

#include <stdio.h>
#include <tchar.h>



// TODO:  在此处引用程序需要的其他头文件
#include<iostream>
#include<fstream>
#include<string>
#include<afxwin.h>

using namespace std;

static const int CMAX_N = 100;

//剩余排序
class CData
{
public:
	int CKey_1;//使用该关键字
	int CKey_2;//未使用
	int CKey_3;//未使用
};

//基数排序数据节点
class _CList
{
public:
	char CData[2];//各个位置
	int CDataNum;//数据位数
	class _CList *next;
};

//排序
class CSortFunction
{
public:
	//构造
	CSortFunction(string CReadName, string CWriteName);
	//析构
	~CSortFunction();
	//警告信息
	inline void CWarnings();
	//获取文件数据
	void CGetArray();
	//获取文件数据
	void CGetFileData(string CRadixFileName,string CWriteRadixFileName);
	//基数排序写入
	bool CWriteRadix();	
	//写入排序后数据
	bool CWriteArray();
	//直接插入排序
	void CInsertSort();
	//折半插入排序
	void CHalfInsertSort();
	//希尔排序
	void CShellSort();
	//冒泡排序
	void CBubbleSort();
	//快速排序
	void CQuickSort();
	//选择排序
	void CSelectSort();
	//堆排序
	void CHeapSort();
	//归并排序
	void CMergeSort();
	//基数排序
	void CRadixSort();
private:
	CData *CArray;
	int CLength;
	string CReadName;
	string CWriteName;
	ifstream CReadFile;
	ofstream CWriteFile;
	_CList *list;
	_CList *CTmp = nullptr;

	//快速排序
	void PriCQuickSort(CData* CArray, int CStart, int CEnd);

	//堆重构
	void CSift(CData* CArray, int low, int high);

	//归并子表
	void CMerge(CData* CArray, int low, int mid, int high);

	//归并整张表
	void CMergePass(CData* CArray, int CChildLength, int CLength);
};


stdafx.cpp

// stdafx.cpp : 只包括标准包含文件的源文件
// AllSortFunction.pch 将作为预编译头
// stdafx.obj 将包含预编译类型信息

#include "stdafx.h"

// TODO:  在 STDAFX.H 中
// 引用任何所需的附加头文件，而不是在此文件中引用

//构造
CSortFunction::CSortFunction(string CReadName, string CWriteName)
{
	this->CReadName = CReadName;//读取文件名
	this->CWriteName = CWriteName;//写入文件名
	CArray = (CData *)malloc(sizeof(CData)*CMAX_N);//申请空间
	CLength = 0;//数组长度
}

//析构
CSortFunction::~CSortFunction()
{
	//释放基数排序所用空间
	_CList *CTmpList_r = list, *CTmpList_p = CTmpList_r->next;
	while (CTmpList_p != NULL)
	{
		free(CTmpList_r);
		CTmpList_r = CTmpList_p;
		CTmpList_p = CTmpList_p->next;
	}
	free(CTmpList_p);
	//释放其他排序所用空间
	free(CArray);
}


//警告
inline void CSortFunction::CWarnings()
{
	MessageBox(NULL, _T("No Data Found!"), _T("Warning"), 1);//无原始数据文件
	exit(0);
}


//获取数据
void CSortFunction::CGetArray()
{
	CReadFile.open(CReadName, ios::in);
	if (CReadFile.is_open())
	{
		int CfData, i = 0;
		while (!CReadFile.eof() && (CReadFile >> CfData).good())
		{
			CArray[i].CKey_1 = CfData;//读入数据
			i++;
		}
		CLength = i;//数组长度
	}
	else
	{
		CSortFunction::CWarnings();//警告，无原始数据文件
	}
	CReadFile.close();
}

//写入排序数据

bool CSortFunction::CWriteArray()
{
	CWriteFile.open(CWriteName, ios::out|ios::app);
	CWriteFile << "----------" << endl;
	for (int i = 0; i < CLength; i++)
	{
		CWriteFile << CArray[i].CKey_1 << endl;
	}
	CWriteFile.close();
	return true;
}


//直接插入排序
void CSortFunction::CInsertSort()
{
	for (int i = 1; i < CLength; i++)
	{
		CData tmp = CArray[i];
		int j = i - 1;
		//从有序序列末尾开始，若小于末尾，则后移覆盖
		while (j >= 0 && tmp.CKey_1 < CArray[j].CKey_1)
		{
			CArray[j + 1] = CArray[j];
			j--;
		}
		//正确位置
		CArray[j + 1] = tmp;
	}
}

//折半插入排序
void CSortFunction::CHalfInsertSort()
{
	int low, high, mid;
	for (int i = 1; i < CLength; i++)
	{
		CData tmp = CArray[i];
		low = 0; high = i - 1;
		//折半查找
		while (low <= high)
		{
			mid = (low + high) / 2;
			if (tmp.CKey_1 < CArray[mid].CKey_1)
			{
				high = mid - 1;
			}
			else
			{
				low = mid + 1;
			}
		}
		//后移插入正确位置
		for (int j = i - 1; j>high; j--)
		{
			CArray[j + 1] = CArray[j];
		}
		CArray[high + 1] = tmp;
	}
}

//希尔排序
void CSortFunction::CShellSort()
{
	//直接插入排序间隔为1，希尔排序间隔增大
	int gap = CLength / 2;//分割标志
	while (gap > 0)
	{
		for (int i = gap; i < CLength; i++)
		{
			CData tmp = CArray[i];
			int j = i - gap;
			while (j >= 0 && tmp.CKey_1 < CArray[j].CKey_1)
			{
				CArray[j + gap] = CArray[j];
				j -= gap;
			}
			CArray[j + gap] = tmp;
		}
		gap /= 2;
	}
}

//冒泡排序
void CSortFunction::CBubbleSort()
{
	bool CExchange;//优化判断是否有数据交换
	for (int i = 0; i < CLength - 1; i++)
	{
		CExchange = false;
		for (int j = CLength - 1; j>i; j--)
		{
			//后一位小于前一位，交换位置
			if (CArray[j].CKey_1 < CArray[j - 1].CKey_1)
			{
				CData tmp = CArray[j];
				CArray[j] = CArray[j - 1];
				CArray[j - 1] = tmp;
				CExchange = true;
			}
		}
		//若某一趟没有发生交换，排序结束
		if (!CExchange)
		{
			return;
		}
	}
}

//快速排序
void CSortFunction::PriCQuickSort(CData* CArray,int CStart,int CEnd)
{
	int i = CStart, j = CEnd;
	CData tmp;
	if (CStart < CEnd)
	{
		tmp = CArray[CStart];
		while (i != j)
		{
			//从右到左
			while (j>i&&CArray[j].CKey_1 >= tmp.CKey_1)
			{
				j--;
			}
			CArray[i] = CArray[j];
			//从左到右
			while (i<j&&CArray[i].CKey_1 <= tmp.CKey_1)
			{
				i++;
			}
			CArray[j] = CArray[i];
		}
		CArray[i] = tmp;
		//递归左右两侧
		PriCQuickSort(CArray, CStart, i - 1);
		PriCQuickSort(CArray, i + 1, CEnd);
	}
}

//快排
void CSortFunction::CQuickSort()
{
	PriCQuickSort(CArray, 0, CLength-1);
}

//选择排序
void CSortFunction::CSelectSort()
{
	for (int i = 0; i < CLength - 1; i++)
	{
		int k = i;
		//后i后存在更小值，则改变k值为该值下标
		for (int j = i + 1; j<CLength; j++)
		{
			if (CArray[j].CKey_1 < CArray[k].CKey_1)
			{
				k = j;
			}
		}
		//若发生改变，则交换
		if (k != i)
		{
			CData tmp = CArray[i];
			CArray[i] = CArray[k];
			CArray[k] = tmp;
		}
	}
}

//堆重构
void CSortFunction::CSift(CData* CArray, int low, int high)
{
	//位置i所在为双亲节点，j为左节点，j+1为右节点
	int i = low, j = 2 * i;
	CData tmp = CArray[i];
	while (j <= high)
	{
		//若右节点大于左节点，j指向右节点
		if (j < high&&CArray[j].CKey_1 < CArray[j + 1].CKey_1)
		{
			j++;
		}
		//若左右节点中较大值大于双钱节点，交换值和下标
		if (tmp.CKey_1 < CArray[j].CKey_1)
		{
			CArray[i] = CArray[j];
			i = j;
			j = 2 * i;
		}
		else
		{
			break;
		}
	}
	CArray[i] = tmp;
}

//堆排序
void CSortFunction::CHeapSort()
{
	//初始化堆
	for (int i = (CLength) / 2; i >= 0; i--)
	{
		CSift(CArray, i, CLength-1);
	}
	//排序
	for (int i = CLength-1; i >= 1; i--)
	{
		CData tmp = CArray[0];
		CArray[0] = CArray[i];
		CArray[i] = tmp;
		CSift(CArray, 0, i-1);//重构堆
	}
}

//归并子表
void CSortFunction::CMerge(CData* CArray, int low, int mid, int high)
{
	CData *CTmpArray;
	int i = low, j = mid + 1, k = 0;
	CTmpArray = (CData *)malloc(sizeof(CData)*(high - low + 1));
	while (i <= mid&&j <= high)
	{
		//向CTmpArray中存入第一段
		if (CArray[i].CKey_1 <= CArray[j].CKey_1)
		{
			CTmpArray[k] = CArray[i];
			i++; k++;
		}
		else//存第二段
		{
			CTmpArray[k] = CArray[j];
			j++; k++;
		}
	}
	//复制第一段余下部分
	while (i <= mid)
	{
		CTmpArray[k] = CArray[i];
		i++; k++;
	}
	//复制第二段余下部分
	while (j <= high)
	{
		CTmpArray[k] = CArray[j];
		j++; k++;
	}
	//拷贝回原数组
	for (k = 0, i = low; i <= high; k++, i++)
	{
		CArray[i] = CTmpArray[k];
	}
	free(CTmpArray);
}

//归并整张表
void CSortFunction::CMergePass(CData* CArray, int CChildLength, int CLength)
{
	int i;
	//归并CChildLength长的相邻子表
	for (i = 0; i + 2 * CChildLength - 1 < CLength; i = i + 2 * CChildLength)
	{
		CMerge(CArray, i, i + CChildLength - 1, i + 2 * CChildLength - 1);
	}
	//归并子表
	if (i + CChildLength - 1 < CLength)
	{
		CMerge(CArray, i, i + CChildLength - 1, CLength - 1);
	}
}

//归并排序
void CSortFunction::CMergeSort()
{
	for (int length = 1; length < CLength; length = length * 2)
	{
		CMergePass(CArray, length, CLength);
	}
}

//获取文件数据
void CSortFunction::CGetFileData(string CRadixFileName, string CWriteRadixFileName)
{
	CReadName = CRadixFileName;//读入数据文件名
	CWriteName = CWriteRadixFileName;//写入数据文件名

	//尾插法构造链表
	_CList *CTmpList_r, *CTmpList_p;
	list = (_CList *)malloc(sizeof(_CList));
	CTmpList_r = list;

	string CfData;
	CReadFile.open(CReadName, ios::in);
	if (CReadFile.is_open())
	{
		while (!CReadFile.eof() && (CReadFile >> CfData).good())
		{
			int j = 0;
			CTmpList_p = (_CList *)malloc(sizeof(_CList));
			CTmpList_p->CDataNum = CfData.length();//获取数据位数
			while (CfData.length())
			{
				CTmpList_p->CData[j] = CfData[CfData.length()-1];//倒叙写入数据
				CfData.assign(CfData.substr(0, CfData.length() - 1));//重构数据串
				j++;
			}
			CTmpList_r->next = CTmpList_p;
			CTmpList_r = CTmpList_p;
		}
		CTmpList_r->next = nullptr;
		CReadFile.close();
	}
	else
	{
		CWarnings();
	}
}


//基数排序
void CSortFunction::CRadixSort()
{
	_CList *CHead[10], *CTail[10], *CTmp_r = nullptr;
	CTmp = list->next;
	//分散遍历排序
	for (int i = 0; i < CTmp->CDataNum; i++)
	{
		//初始化为空
		for (int j = 0; j < 10; j++)
		{
			CHead[j] = CTail[j] = nullptr;
		}
		//按个位/十位/百位...依次排序，循环次数定位数据位数次
		while (CTmp!=NULL)
		{
			int k = CTmp->CData[i] - '0';
			if (CHead[k] == NULL)
			{
				CHead[k] = CTail[k] = CTmp;
			}
			else
			{
				CTail[k]->next = CTmp;
				CTail[k] = CTmp;
			}
			CTmp = CTmp->next;
		}
		//收集排序后序列
		CTmp = NULL;
		for (int j = 0; j < 10; j++)
		{
			if (CHead[j] != NULL)
			{
				if (CTmp == NULL)
				{
					CTmp = CHead[j];
					CTmp_r = CTail[j];
					
				}
				else
				{
					CTmp_r->next = CHead[j];
					CTmp_r = CTail[j];
					
				}
			}
		}
		CTmp_r->next = NULL;
	}
}

//基数排序写入
bool CSortFunction::CWriteRadix()
{
	CWriteFile.open(CWriteName, ios::out);
	_CList *CTmpList_r = CTmp;
	while (CTmpList_r != NULL)
	{
		//倒叙写入，获取正序数
		CWriteFile << CTmpList_r->CData[1] << CTmpList_r->CData[0] << endl;
		CTmpList_r = CTmpList_r->next;
	}
	CWriteFile.close();
	return true;
}

AllSortFunction.cpp（main文件） 

// AllSortFunction.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"


int _tmain(int argc, _TCHAR* argv[])
{
	CSortFunction sort("read.txt", "sort.txt");
	sort.CGetArray();//读数据
	sort.CInsertSort();//直接插入排序
	if (sort.CWriteArray())//写数据
	{
		cout << "直接插入排序 OK." << endl;
	}
	sort.CHalfInsertSort();//折半插入排序
	if (sort.CWriteArray())//写数据
	{
		cout << "折半插入排序 OK." << endl;
	}
	sort.CShellSort();//希尔排序
	if (sort.CWriteArray())//写数据
	{
		cout << "希尔排序 OK." << endl;
	}
	sort.CBubbleSort();//冒泡排序
	if (sort.CWriteArray())//写数据
	{
		cout << "冒泡排序 OK." << endl;
	}
	sort.CQuickSort();//快速排序
	if (sort.CWriteArray())//写数据
	{
		cout << "快速排序 OK." << endl;
	}
	sort.CSelectSort();//选择排序
	if (sort.CWriteArray())//写数据
	{
		cout << "选择排序 OK." << endl;
	}
	sort.CHeapSort();//堆排序
	if (sort.CWriteArray())//写数据
	{
		cout << "堆排序 OK." << endl;
	}
	sort.CMergeSort();//归并排序
	if (sort.CWriteArray())//写数据
	{
		cout << "归并排序 OK." << endl;
	}
	sort.CGetFileData("radix.txt", "solveRadix.txt");//获取基数排序数据
	sort.CRadixSort();//基数排序
	//写入文件
	if (sort.CWriteRadix())
	{
		cout << "基数排序 OK." << endl;
	}
	return 0;
}


测试运行



read.txt



radix.txt



sort.txt



solveradix.txt



注释：上面提供的基数排序仅能对相同位数的十进制数序列排序。


J_Anson
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 数据结构与算法 排序算法
08-17
本文件将四大排序算法通过“「程序算法之排序」冒泡排序、插入排序、选择排序与快速排序”一文编写出,欢迎下载学习(文章链接:https://blog.csdn.net/Pomelo_ABC/article/details/126015013)
数据结构——排序
m0_51530927的博客
01-07 3864
数据结构Java 排序简单排序（冒泡、插入、选择），高级排序（希尔、递归、快速），排序的稳定性
数据结构——【排序】详解
Lucky_mzc的博客
03-14 6458
一. 排序💨 1.1 基本概念 排序（sorting）又称分类，就是将一组任意序列得数据元素按一定得规律进行排列（按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作），使之成为有序序列。 平时的上下文中，如果提到排序，通常指的是排升序（非降序）。 通常意义上的排序，都是指的原地排序(in place sort)。 1.2 稳定性 定义：数组 arr 中有若干元素，其中 A元素和 B元素相等，并且 A元素在 B元素前面，如果使用某种排序算法排序后，能够保证 A元素依然在 B元素的前面，可
数据结构——八大排序（全）
weixin_48560325的博客
02-09 9502
排序的基本概念和分类 排序算法的稳定性 概念：假设 Ki=Kj(1<=i<=n,1<=j<<n,i!=j),且在排序前的序列中Ri领先于Rj（即i<j）。如果排序后Ri仍领先于Rj，则说明所用的排序算法是稳定的；反之，若可能使得排序后的序列中Ri领先于Rj，则称所用的排序算法是不稳定的。 内排序和外排序 根据在排序过程中待排序的记录是否全部被放置在内存中，排序分为：内排序和外排序。 内排序实在排序整个过程中，待排序的所有记录全部被放置在内存中。外排序是由于排序记
数据结构——排序算法总结（八个）
qq_34252068的博客
08-05 6206
内排序：指在排序期间数据对象所有存放在内存的排序。外排序：指在排序期间所有对象太多，不能同一时候存放在内存中，必须依据排序过程的要求，不断在内，外存间移动的排序。
常见的几种排序算法（c++）
low5252的博客
03-12 7998
常见的几种排序算法（c++）一、冒泡排序二、插入排序三、选择排序四、归并排序五、希尔排序六、快速排序七、堆排序八、基数排序1.LSD(低位到高位的排序)2.MSD(高位到低位排序)算法比较 一、冒泡排序 1、算法思想 冒泡排序是一种简单的排序算法，通过循环遍历，将临近的两个元素进行比较，满足排序规则时，进行下一组元素对比，当不满足排序规则时，将两个元素交换位置，再继续进行下一组元素对比，确保最大的...
C++数据结构排序算法
09-13
C++数据结构排序算法总结，包含详细可执行代码以及算法讲解！
快速排序算法C++描述
最新发布
01-02
数据结构快速排序
C++ 冒泡排序数据结构、算法及改进算法
12-31
程序代码如下： 代码如下:// BubbleSort.cpp : 定义控制台应用程序的入口点。//#include “stdafx.h”#include <cmath>#include <iostream>using namespace std;#define MAXNUM 20template<typename>void Swap(T& a...
数据结构课程设计-排序算法的实现.docx
08-10
C++实现各种排序算法
数据结构—八大排序
热门推荐
想要上进的coder的博客
01-09 3万+
一、直接插入排序 void InsertSort(int* a, int n) { assert(a); for (int i = 0; i < n - 1; ++i) { int end = i; int x=a[end+1];//将end后面的值保存到x里面了 //将x插入到[0，end]的有序区间 while (end >= 0) { if (a[end] > x) { a[end + 1] = a[end]; //往后挪动一位
数据结构_排序
light_2025的博客
05-18 1413
排序，就是重新排列表中的元素，使表中的元素满足按关键字有序的过程。为了查找方便，通常希望计算机中的表是按关键字有序的。 算法的稳定性：若待排序表中有两个元素 和 ，其对应的关键字相同即 = ，且在排序前 在 前面，若使用某一排序算法排序后， 仍在 前面，则称这个排序算法是稳定的，否则称这个排序算法是不稳定的。需要注意的是：算法是否具有稳定性并不能衡量一个算法的优劣，它主要是对算法的性质进行描述。如果待排序表中的关键字不允许重复，则排序结果是唯一的，那么选择排序算法时的稳定与否就无
【数据结构】排序算法大总结
大三小白C++进阶之路
12-30 5795
排序算法大总结
C++八种排序算法万字详解
我的博客
06-04 7068
哈喽，今天我来总结一下C++中的8中排序方法，这些排序在实际开发中能起到一些作用，也可以锻炼你的算法头脑。我也好长时间没上热榜了，这次准备做一个非常详细🔎的总结，看看能不能上热榜。既然叫排序算法，肯定要排序。我们要实现的效果是输入几个数，输出升序（或降序）排序后的结果，并找到时间复杂度最低的算法，应用到实际开发中。冒泡排序主要思路就是遍历数组，比较两个相邻的元素，也就是 arr[j] 和 arr[j+1] ，如果顺序错误就用 swap 函数或空杯交换，交换这两个元素。举个例子，数组是 a[5]={2,1,.
【数据结构】七种常见的排序
m0_73067372的博客
04-01 2561
❗❗❗原因在于，如果一个排序算法是稳定的时候，可以实现为不稳定的但是当一个算法是不稳定的，就不可能将其实现为稳定的排序算法。
数据结构初阶 —— 常见排序
NapoleonCoder的博客
09-25 1187
常见排序算法：插入排序/选择排序/交换排序/归并排序/计数排序/基数排序!
经典排序算法C++实现（10种）
weixin_42023936的博客
08-27 1578
C++实现经典排序算法插入排序希尔排序（缩小增量排序）选择排序堆排序冒泡排序冒泡排序的原理：快速排序合并排序折中排序新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章U...
用C++实现十大经典排序算法
billy的博客
01-04 7459
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
C++实现五种常见排序算法
weixin_39318565的博客
06-20 4181
排序算法在工作和面试中都经常用到这里是常见的几种算法的C++实现
数据结构八大排序算法c++
01-01
数据结构中的八大排序算法，是指常见的八种用于对数据进行排序的算法。这八种算法分别是冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序和基数排序。 冒泡排序是一种简单的排序算法，通过不断比较和交换相邻元素的位置，使得最大（或最小）的元素逐渐往后（或往前）移动。 选择排序是一种简单直观的排序算法，每次选择未排序序列中最小（或最大）的元素，放到已排序序列的末尾。 插入排序是一种简单直观的排序算法，将一个待排序的元素插入到已部分排序的数列中的合适位置。 希尔排序是一种改进的插入排序算法，通过将待排序数列分组，并对每个分组进行插入排序，然后逐渐减小分组规模，最后进行一次插入排序。 归并排序是一种分治思想的排序算法，将待排序数列不断分割成较小的数列，然后再将这些较小的数列按照顺序进行合并。 快速排序是一种分治思想的排序算法，通过选择一个中间的基准元素，将数列分割成两部分，然后分别对这两部分进行排序。 堆排序是一种利用堆这种数据结构的排序算法，通过将待排序数列构建成一个大（或小）顶堆，然后逐步将堆顶元素与最后一个元素交换，并调整堆结构。 计数排序是一种非比较型的排序算法，通过统计待排序数列中每个元素出现的次数，然后依次输出即可。 基数排序是一种非比较型的排序算法，通过对待排序数列的每个位进行排序，依次从低位到高位进行。 这里简单介绍了八大排序算法的基本思想和实现方法。在实际应用中，不同的排序算法适用于不同的场景和要求，我们需要根据具体情况选择合适的算法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值