数据结构【顺序表】

已于 2024-05-22 15:53:23 修改
阅读量1k 收藏 17
点赞数 32
分类专栏： #数据结构 文章标签： 数据结构 c语言
于 2024-05-15 10:37:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80216111/article/details/138896804
版权

文章目录

1.顺序表的概念

在认识顺序表之前，让我们先认识下线性表。

线性表

线性表是由n个相同类型的数据所组成的有限序列，线性表是一种在现实里被广泛使用的，常见的线性表有：顺序表、链表、栈、队列等等。
线性表在逻辑结构一定连续，但在物理结构中并不一定是连续的。

物理结构

物理结构就是数据存储于内存的结构，就那数组来说，数组开辟的空间是连续的，第x个数据的空间的下一块空间就是第x+1个数据，这就是物理结构连续。
在这里插入图片描述
如果我在设计表的时候，专门设计一个指针用来存放下一个数据的地址。
如下图：
在这里插入图片描述

第x数据和第x+1数据的空间并不是连续的，而是被指针位连接的，是像一个绳子，每个数据位就相当于绳结，指针位相当于绳结后面的绳子，这就是物理结构不连续。

逻辑结构

逻辑结构是我们自己抽象出来的，对于线性表来说，它的逻辑结构我们就可以把他想象成直线的线性结构，就拿上面物理结构不连续的例子来说，尽管它第一个数据和第二个数据在空间上并不是连续，但是我们可以把它们想象是连续的。
就类似于下图：
在这里插入图片描述
顺序表是线性表的一种，顺序表的特点就是物理层面和逻辑层面都连续，数据与数据之间都是相邻的
顺序表的底层是数组!!!

2.顺序表的分类

顺序表可以分为静态和动态两种

2.1静态顺序表

在创建之前将大小固定，这样虽然很简单，但是有局限性；如果给定的数据多了，就无法完整的存储数据；如果给定的数据少了，就会造成空间的浪费

typedef int SQLDATATYPE;
typedef struct SQList
{
	SQLDATATYPE a[100];//给定了100个数据，后续无法改动大小
	int size;//当前数据的个数
}SQList;

哪有什么方法可以解决呢？

2.2动态顺序表

内存大小是不固定的，需要使用时再进行动态开辟，如果后面有多的数据要存储，就可以使用realloc函数来进行增容，所以就更加的灵活

typedef int SQLDATATYPE;
typedef struct SQList
{
	SQLDATATYPE* a;
	int size;//当前数据的个数
	int capacity;//当前顺序表的容量
}SQList;

我们本章讲解的是动态顺序表

3.顺序表接口的实现

首先我们需要一个头文件和一个源文件；
头文件是用来声明顺序表函数的，源文件是用来实现顺序表函数的实现

头文件(SQList.h)如下

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

//typedef int SQLDATATYPE;
//typedef struct SQList
//{
//	SQLDATATYPE a[100];//给定了100个数据，后续无法改动大小
//	int size;//当前数据的个数
//}SQList;

typedef int SQLDATATYPE;
typedef struct SQList
{
	SQLDATATYPE* a;
	int size;//当前数据的个数
	int capacity;//当前顺序表的容量
}SQList;

//初始化顺序表
void SQListInit(SQList* plist);
//销毁顺序表
void SQListDestroy(SQList* plist);

//插入(尾部)
void SQListPushBack(SQList* plist, SQLDATATYPE x);
//删除(尾部)
void SQListPopBack(SQList* plist);

//插入(头部)
void SQListPushFront(SQList* plist, SQLDATATYPE x);
//删除(头部)
void SQListPopFront(SQList* plist);

//查找元素
int SQListFind(SQList* plist, SQLDATATYPE x);

//插入(指定位置前)
void SQListInsect(SQList* plist, int pst, SQLDATATYPE x);
//删除(指定位置)
void SQListDelete(SQList* plist, int pst);


//打印顺序表
void SQListPrint(SQList* plist);

源文件

记住要包含头文件

#include"SQList.h"

初始化顺序表

//初始化顺序表
void SQListInit(SQList* plist)
{
	plist->a = NULL;
	//其实也可以在初始化的时候就给a开辟空间(看个人喜好)
	plist->size = plist->capacity = 0;
}

一定要传址调用，这样才能真正的改变到顺序表

销毁顺序表

//销毁顺序表
void SQListDestroy(SQList* plist)
{
	assert(plist);
	free(plist->a);
	plist->a = NULL;//这一步是为了让a不会野指针
					//也可以避免a被重复释放(free函数不会对NULL进行操作)
	plist->size = plist->capacity = 0;
}

插入

插入就意味这内容的增加，就必然会导致内容空间的不足，这时候我们就需要进行扩容。

扩容

我们在插入之前要看，内部是否还有空间可以让我们插入，当size==capacity时，就代表表内已经填满数据了，我们就需要进行扩容
扩容用到的是realloc函数，我们扩容是默认是以两倍来扩容

尾插
void SQListPushBack(SQList* plist, SQLDATATYPE x)
{
	assert(plist);//检查plist是否为空指针
	if (plist->size == plist->capacity)//判断空间是否满了
	{
		int NewCapacity = plist->capacity == 0 ? 4 : 2 * plist->capacity;//此处为一个三目表达式
		//如果plist->capacity==0为真，将4赋给NewCapacity;反之则赋值2*plist->capacity

		SQLDATATYPE* tmp = (SQLDATATYPE*)realloc(plist->a, NewCapacity * sizeof(SQLDATATYPE));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(1);
		}
		plist->a = tmp;//将调整的空间赋给顺序表
		plist->capacity = NewCapacity;//调整容量
	}
	plist->a[plist->size] = x;
	plist->size++;
}
头插

头插我们就会遇到一个问题。
我们不能直接在顺序表的头部进行插入，这样会覆盖掉顺序表原来的数据，会造成数据的丢失。在这里插入图片描述

解决方法也很简单
我们将整个顺序表往后挪动一位，让下标为x的数据等于下标为x-1的数据。
因为我们size处是一个待插入数据的空间，所以这样并不会造成数据的丢失。在这里插入图片描述

代码如下：

void SQListPushFront(SQList* plist, SQLDATATYPE x)
{
	assert(plist);//检查plist是否为空指针
	if (plist->size == plist->capacity)
	{
		int NewCapacity = plist->capacity == 0 ? 4 : 2 * plist->capacity;//此处为一个三目表达式
		//如果plist->capacity==0为真，将4赋给NewCapacity;反之则赋值2*plist->capacity

		SQLDATATYPE* tmp = (SQLDATATYPE*)realloc(plist->a, NewCapacity * sizeof(SQLDATATYPE));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(1);
		}
		plist->a = tmp;//将调整的空间赋给顺序表
		plist->capacity = NewCapacity;//调整容量
	}

	for (int i = plist->size; i > 0; i--)//将整个顺序表往后挪动一位
	{
		plist->a[i] = plist->a[i - 1];
	}

	plist->a[0] = x;
	plist->size++;
}

封装扩容函数

这时候我们看到，尾插函数和头插函数有一段代码是一模一样的，我们接下来还有个指定位置前的插入，它也是可能会进行扩容函数的，如果这三个函数都使用一段相同的代码，就会显得代码很冗余。

我们就可以将这段代码抽离出来，封装成一个独立的函数，需要扩容的时候调用该函数就可以了。

代码如下：

//扩容函数
//因为扩容函数是在源代码运行的，所以可以不用在头文件进行声明(当然你也可以在头文件进行声明  看个人喜好)
void SQListAdd(SQList* plist)
{
	int NewCapacity = plist->capacity == 0 ? 4 : 2 * plist->capacity;//此处为一个三目表达式
	//如果plist->capacity==0为真，将4赋给NewCapacity;反之则赋值2*plist->capacity

	SQLDATATYPE* tmp = (SQLDATATYPE*)realloc(plist->a, NewCapacity * sizeof(SQLDATATYPE));
	if (tmp == NULL)
	{
		perror("realloc fail");
		exit(1);
	}
	plist->a = tmp;//将调整的空间赋给顺序表
	plist->capacity = NewCapacity;//调整容量
}

删除

尾删
//删除(尾部)
void SQListPopBack(SQList* plist)
{
	assert(plist);
	assert(plist->size > 0);//如果为0了，我还删什么呢？

	plist->size--;//这里很简单，就是将他的size进行--
	//size指向的是尾数据的下一块空间，也就是待插入的空间
	//我们--size，就相当于把尾数据的空间变成了待插入的空间
	//我们新增数据的时候，会把原来的值覆盖掉的
}
头删

这里有个问题

因为是删除头元素，我们不能直接将size–。

解决方法也很简单

将整个顺序表往前挪动一位，原理和头插的解决方法是类似的。
在这里插入图片描述
代码如下：

//删除(头部)
void SQListPopFront(SQList* plist)
{
	assert(plist);
	assert(plist->size > 0);//如果为0了，我还删什么呢？

	for (int i = 0; i < plist->size - 1; i++)//将整个顺序表往前挪动一位
	{
		plist->a[i] = plist->a[i + 1];
	}

	plist->size--;
}

查找元素

//查找元素
int SQListFind(SQList* plist, SQLDATATYPE x)
{
	assert(plist);
	int i = 0;
	while (i < plist->size)//size-1处就是最后一个数据
	{
		if (plist->a[i] == x)//找到了
			return i;//返回的是下标
		i++;
	}
	//i=size 跳出循环
	//找不到
	return EOF;//EOF(-1)
}

在指定位置前插入数据

情况一(指定的位置不是首元素)

我们就将指定位置及以后的数据往后挪一位;，再将数据插入到指定位置的下标。
在这里插入图片描述

情况二(指定的位置是首元素)

那么是首元素了，我们在首元素前进行插入，这是什么？
这不就是头插吗
所以我们可以直接调用我们已经写好的头插函数

//插入(指定位置前)
void SQListInsect(SQList* plist, int pst, SQLDATATYPE x)
{
	assert(plist);
	if (plist->size == plist->capacity)
	{
		SQListAdd(plist);//这里就直接调用了增容函数
	}

	//这里有两种情况
	//第一种当pst不是首元素
	if (pst != 0)
	{
		for (int i = plist->size; i > pst; i--)//将顺序表pst后面的数据往后挪动一位
		{
			plist->a[i] = plist->a[i - 1];
		}
		plist->a[pst] = x;
	}

	//第二种:当pst是首元素
	//那么是首元素了，我们在首元素前进行插入，这是什么？
	//这不就是头插吗
	//所以我们可以直接调用我们已经写好的头插函数
	else
	{
		SQListPushFront(plist, x);
	}
}

删除指定位置

我们只要将指定位置后面的数据往前挪动一位

//删除(指定位置)
void SQListDelete(SQList* plist, int pst)
{
	assert(plist);
	assert(plist->size > 0);//如果为0了，我还删什么呢

	for (int i = pst; i < plist->size - 1; i++)//将pst后面的数据往前挪动一位
	{
		plist->a[i] = plist->a[i + 1];
	}
	plist->size--;
}

打印顺序表

//打印顺序表
void SQListPrint(SQList* plist)
{
	assert(plist);
	if (plist->size == 0)
		printf(NULL);
	for (int i = 0; i < plist->size; i++)
	{
		printf("%d ", plist->a[i]);
	}
	printf("\n");
}

完整代码

SQList.h

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

//typedef int SQLDATATYPE;
//typedef struct SQList
//{
//	SQLDATATYPE a[100];//给定了100个数据，后续无法改动大小
//	int size;//当前数据的个数
//}SQList;

typedef int SQLDATATYPE;
typedef struct SQList
{
	SQLDATATYPE* a;
	int size;//当前数据的个数
	int capacity;//当前顺序表的容量
}SQList;

//初始化顺序表
void SQListInit(SQList* plist);
//销毁顺序表
void SQListDestroy(SQList* plist);

//插入(尾部)
void SQListPushBack(SQList* plist, SQLDATATYPE x);
//删除(尾部)
void SQListPopBack(SQList* plist);

//插入(头部)
void SQListPushFront(SQList* plist, SQLDATATYPE x);
//删除(头部)
void SQListPopFront(SQList* plist);

//查找元素
int SQListFind(SQList* plist, SQLDATATYPE x);

//插入(指定位置前)
void SQListInsect(SQList* plist, int pst, SQLDATATYPE x);
//删除(指定位置)
void SQListDelete(SQList* plist, int pst);


//打印顺序表
void SQListPrint(SQList* plist);

SQList.c

#include"SQList.h"

//初始化顺序表
void SQListInit(SQList* plist)
{
	plist->a = NULL;
	//其实也可以在初始化的时候就给a开辟空间(看个人喜好)
	plist->size = plist->capacity = 0;
}

//销毁顺序表
void SQListDestroy(SQList* plist)
{
	assert(plist);
	free(plist->a);
	plist->a = NULL;//这一步是为了让a不会野指针
					//也可以避免a被重复释放(free函数不会对NULL进行操作)
	plist->size = plist->capacity = 0;
}

//扩容函数
//因为扩容函数是在源代码运行的，所以可以不用在头文件进行声明(当然你也可以在头文件进行声明  看个人喜好)
void SQListAdd(SQList* plist)
{
	int NewCapacity = plist->capacity == 0 ? 4 : 2 * plist->capacity;//此处为一个三目表达式
	//如果plist->capacity==0为真，将4赋给NewCapacity;反之则赋值2*plist->capacity

	SQLDATATYPE* tmp = (SQLDATATYPE*)realloc(plist->a, NewCapacity * sizeof(SQLDATATYPE));
	if (tmp == NULL)
	{
		perror("realloc fail");
		exit(1);
	}
	plist->a = tmp;//将调整的空间赋给顺序表
	plist->capacity = NewCapacity;//调整容量
}

//插入(尾部)
void SQListPushBack(SQList* plist, SQLDATATYPE x)
{
	assert(plist);//检查plist是否为空指针
	if (plist->size == plist->capacity)
	{
		SQListAdd(plist);
	}
	plist->a[plist->size] = x;
	plist->size++;
}

//删除(尾部)
void SQListPopBack(SQList* plist)
{
	assert(plist);
	assert(plist->size > 0);//如果为0了，我还删什么呢？

	plist->size--;//这里很简单，就是将他的size进行--
	//size指向的是尾数据的下一块空间，也就是待插入的空间
	//我们--size，就相当于把尾数据的空间变成了待插入的空间
	//我们新增数据的时候，会把原来的值覆盖掉的
}

//插入(头部)
void SQListPushFront(SQList* plist, SQLDATATYPE x)
{
	assert(plist);//检查plist是否为空指针
	if (plist->size == plist->capacity)
	{
		SQListAdd(plist);
	}

	for (int i = plist->size; i > 0; i--)//将整个顺序表往后挪动一位
	{
		plist->a[i] = plist->a[i - 1];
	}

	plist->a[0] = x;
	plist->size++;
}

//删除(头部)
void SQListPopFront(SQList* plist)
{
	assert(plist);
	assert(plist->size > 0);//如果为0了，我还删什么呢？

	for (int i = 0; i < plist->size - 1; i++)//将整个顺序表往前挪动一位
	{
		plist->a[i] = plist->a[i + 1];
	}

	plist->size--;
}

//查找元素
int SQListFind(SQList* plist, SQLDATATYPE x)
{
	assert(plist);
	int i = 0;
	while (i < plist->size)//size-1处就是最后一个数据
	{
		if (plist->a[i] == x)//找到了
			return i;//返回的是下标
		i++;
	}
	//i=size 跳出循环
	//找不到
	return EOF;//EOF(-1)
}

//插入(指定位置前)
void SQListInsect(SQList* plist, int pst, SQLDATATYPE x)
{
	assert(plist);
	if (plist->size == plist->capacity)
	{
		SQListAdd(plist);
	}

	//这里有两种情况
	//第一种当pst不是首元素
	if (pst != 0)
	{
		for (int i = plist->size; i > pst; i--)//将顺序表pst后面的数据往后挪动一位
		{
			plist->a[i] = plist->a[i - 1];
		}
		plist->a[pst] = x;
	}

	//第二种:当pst是首元素
	//那么是首元素了，我们在首元素前进行插入，这是什么？
	//这不就是头插吗
	//所以我们可以直接调用我们已经写好的头插函数
	else
	{
		SQListPushFront(plist, x);
	}
}

//删除(指定位置)
void SQListDelete(SQList* plist, int pst)
{
	assert(plist);
	assert(plist->size > 0);//如果为0了，我还删什么呢

	for (int i = pst; i < plist->size - 1; i++)//将pst后面的数据往前挪动一位
	{
		plist->a[i] = plist->a[i + 1];
	}
	plist->size--;
}

//打印顺序表
void SQListPrint(SQList* plist)
{
	assert(plist);
	if (plist->size == 0)
		printf(NULL);
	for (int i = 0; i < plist->size; i++)
	{
		printf("%d ", plist->a[i]);
	}
	printf("\n");
}

test.c (测试部分)

#include"SQList.h"

void TestSQL()
{
	SQList sq;
	SQListInit(&sq);

	SQListPushBack(&sq, 1);
	SQListPushBack(&sq, 2);
	SQListPushBack(&sq, 3);
	SQListPushBack(&sq, 4);
	SQListPushBack(&sq, 5);
	SQListPushBack(&sq, 6);

	SQListPushFront(&sq, 0);

	SQListPopBack(&sq);
	SQListPushBack(&sq, 128);
	//SQListPrint(&sq);
	//SQListPopFront(&sq);
	//SQListPrint(&sq);

	int flag = SQListFind(&sq, 3);
	//if (flag != EOF)
	//{
	//	printf("找到了 下标为%d\n", flag);
	//}
	//else
	//{
	//	printf("找不到\n");
	//}

	SQListInsect(&sq, flag, 255);

	//SQListDelete(&sq, flag);

	SQListPrint(&sq);

	SQListDestroy(&sq);
}

int main()
{
	TestSQL();
	return 0;
}

结语

最后感谢您能阅读完此片文章，如果有任何建议或纠正欢迎在评论区留言。

如果您认为这篇文章对您有所收获，点一个小小的赞就是我创作的巨大动力，谢谢！！！

向上爬的卓卓卓
关注
  • 32
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
合工大数据结构顺序表实验
04-14
18级合工大数据结构实验
C++数据结构顺序表删除操作
08-26
C++数据结构顺序表删除操作..................................................................................................................................................................................
数据结构-顺序表基本操作的实现（含全部代码）
热门推荐
关注网络安全、云原生安全
09-13 21万+
今天起开始编写数据结构中的各种数据结构及其算法的实现。 主要依据严蔚敏版数据结构教材以及王道数据结构考研辅导书。 今天是线性表中的顺序表的实现，主要实现函数如下，读者有需要可以评论，我可以适当加几个。 CreatList(SqList &L,int n) 参数：顺序表L，顺序表长度n 功能：创建长度为的顺序表 时间复杂度：O(n) InitList(SqList &...
C语言数据结构 顺序表的输入与输出
qq_60649317的博客
12-03 2195
大学新手
数据结构 顺序表实现手机通讯录
taotu_tao的博客
03-29 5764
代码 #include <stdio.h> #include <malloc.h> #include <string.h> #include <stdlib.h> #include <windows.h> #include <conio.h> //#include <stack> typedef struct { char name[10]; char tel[12]; }ElemType; typedef s
数据结构 顺序表的查找
weixin_57500505的博客
12-09 2576
按值查找顺序表。请在程序中建立一个含有10个元素，分别是1,2,3,4,5,6,7,8,9,10的顺序表。然后等候用户输入要查找的元素值，如顺序表中有该元素，则输出该元素位序，否则输出查找失败。 【输入】要查找的元素值 【输出】该元素位序 或查找失败 代码 #include<iostream> using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int ElemType.
数据结构：顺序表详解
Zhenyu_Coder的博客
07-30 5462
顺序表作为一种基本的数据结构，在许多应用场景中具有重要的意义和作用，可以提高数据的访问和操作效率，简化算法设计，提高内存利用率。本篇博客将向你详细介绍其模拟过程及全代码
Educoder头歌数据结构顺序表及其应用
qq_50848214的博客
11-05 1万+
头歌实践平台答案 数据结构-顺序表及其应用 第1关：顺序表的实现之查找功能 /************************************************************* 顺序表的实现之查找功能 实现文件 更新于2020年4月13日 **************************************************************/ void SL_GetAt(SqList L, int i, ElemType &e)
＜数据结构＞ 顺序表
bit_zyx的博客
03-13 9277
目录 一、顺序表介绍 二、准备工作 1、创建顺序表 2、初始化顺序表 3、检测是否需要扩容 4、销毁顺序表 5、打印顺序表 三、四大功能 1、增加数据 头插 尾插 指定下标插入 2、删除数据 头删 ...
数据结构（顺序表）
小马同学的博客
11-07 2277
数据机构的顺序表实现
【数据结构】顺序表
East-sunrise的博客
08-15 4232
顺序表带你走进数据结构世界🎈
数据结构——顺序表
2301_77179941的博客
04-17 6329
​ 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 ​
头歌数据结构顺序表的基本操作1-6关
05-18
头歌数据结构顺序表的基本操作1-6关 第1关：顺序表的插入操作 第2关：顺序表的删除操作 第3关：顺序表的按照序号查找值操作 第4关：顺序表的按照值查找序号操作 第5关：顺序表的逆置操作 第6关：两个有序顺序表的...
数据结构顺序表操作示例
09-04
主要介绍了数据结构顺序表操作示例,其中有在第I个元素前插入数据x，元素从0开始计数、删除第i个元素，元素从0开始计数的方法,需要的朋友可以参考下
c语言数据结构顺序表合并
12-01
1.建立两个顺序表（通过随机函数生成）； 2.排序（升序），输出合并前的结果； 3.对这两个顺序表进行合并（保持升序）； 4.输出合并结果
考研系列-数据结构第二章、线性表
Nelson_hehe的博客
06-09 1790
本文是408考研付费专栏系列-数据结构线性表章节，本文章详细地总结了线性表的相关知识，其中包括：顺序表、链表（单链表、双链表、循环链表、静态链表等）的细节和重要知识点汇总。考研听课、复习的好帮手。
【算法与数据结构】【数组篇】【题11-题15】
最新发布
handsomethefirst的博客
06-13 1179
本人系列文章-CSDN博客。
如何使用Python中的collections模块提供的数据结构，如deque、Counter、OrderedDict等
2402_84885073的博客
06-09 507
Python 的模块提供了一些额外的数据结构，这些数据结构在内置的数据类型（如列表、字典、集合等）的基础上，增加了额外的功能或优化了性能。下面是如何使用模块中的dequeCounter和这三种数据结构的简单示例。
Go语言设计与实现 学习笔记 第三章 数据结构（1）
tus00000的博客
06-09 1204
3.1 数组 数组和切片是Go语言中常见的数据结构，很多刚刚使用Go的开发者往往会混淆这两个概念，数组作为最常见的集合在编程语言中是非常重要的，除了数组之外，Go语言引入了另一个概念——切片，切片与数组有一些类似，但是它们的不同之处导致使用上会产生巨大的差别。我们在这一节中会从Go语言的编译期间和运行时来介绍数组的底层实现原理，其中会包括数组的初始化、访问和赋值几种常见操作。 3.1.1 概述 数组是由相同类型元素的集合组成的数据结构，计算机会为数组分配一块连续的内存来保存其中的元素，我们可以利用数组中元素
数据结构顺序表C++
09-06
- *1* [数据结构顺序表c++代码](https://download.csdn.net/download/qq_46546083/13458006)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值