【C语言】用纯C来创建顺序表

已于 2023-02-04 12:54:39 修改
阅读量1.4k 收藏 15
点赞数 22
分类专栏： C的数据结构 文章标签： c语言 数据结构
于 2022-11-06 14:28:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wutongguo/article/details/127701063
版权

🐖前言

⭐什么是顺序表？
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般情况下采用数组存储,在数组上完成数据的增删查改。
其实顺序表就是数组，要求数据连续存储的

🐖顺序表的创建

需要创建一个小项目工程
创建三个文件
⭐seqlist.h放顺序表的头文件，函数声明
⭐seqlist.c放顺序表的函数
⭐test.c是主函数。存放框架

(1)🐕创建一个静态顺序表

对于这个来说，顺序表就是一个数组，但是我们需要记录顺序表的有效数据，所以我们就用结构体创建一个顺序表，为了让后续用顺序表的时候更加的方便，我们可以typedef一下让我的代码看起来更加简洁。

#define N 10
//静态顺序表
typedef struct Seqlist
{
	int a[N];
	int size;//记录存储多少个有效数据
}SL;//重新命名一下让后面的操作更加方便

但是呢我们再用的时候是不是只能用int型的数据了，所以我们可以将数据类型直接typedef改个名字，当我们想改数据类型的时候就可以直接再typedef上改。

#define N 10

//将数据类型重定义一下
typedef int DataType;
//静态顺序表
typedef struct Seqlist
{
	DataType a[N];
	int size;//记录存储多少个有效数据
}SL;//重新命名一下让后面的操作更加方便

但是呢对于静态的顺序表，他是不是有点太死板了，我们开辟多了空间，用不完怎么办，开辟少了空间，不够用这么办这都是需要我们考虑的东西。所以开一个动态的就好了呀。

(1.2)🐕创建一个动态的顺序表

为了合理安排我们的需求，我们就可以动态开辟空间，我们需要多少空间就开辟多少空间，请看下面的代码

//动态顺序表---按照需求扩空间
typedef struct Seqlist
{
	DataType *a;//动态开辟数组的指针
	int size;//记录存储多少个有效数据
	int capacity;//空间容量，当sz大于他的时候再扩容
}SL;//重新命名一下让后面的操作更加方便

(2)🐕初始化顺序表

将数据都设为0，并且这是用指针的，这样才能改变原数据。

//初始化顺序表将数据都设为0
void SLInit(SL* ps)
{
	ps->a = NULL;
	ps->sz = 0;
	ps->capacity = 0;
}

(3)🐕销毁顺序表

再用动态内存开辟玩空间，我们需要销毁开辟的空间，将其free掉，为什们要现在写呢 ，就是为了一会测试我们写的函数的时候，不会报错。并且顺便把顺序表中的sz,capacity置为0.

//销毁顺序表
void SLDistory(SL* ps)
{
	//防止他是空指针
	if (ps->a != NULL)
	{
		free(ps->a);
		ps->a = NULL;
		ps->capacity = 0;
		ps->sz = 0;
	}

}

(4)🐕顺序表的尾插

如果你认为就是再顺序表的结尾插入数据，那你就想简单了，我们在上面还没有动态开辟空间呢，并且如果当你开辟的空间用完了，怎么办，这都是我们需要考虑的

我们这样想，顺序表是空的，我们刚开始肯定要插入空间，所以我们可以在顺序表的尾插中开辟空间，就不用再初始化的时候开辟空间，并且我们通过C语言中动态内存的知识,我们知道realloc当他用NULL的时候，功能相当于malloc,所以我们可以利用这个特点来写。
其他细节就看代码吧。

//顺序表的尾插
void SLPushBack(SL* ps,DataType n)
{
	
	//当空间不够的时候扩容
	if (ps->sz == ps->capacity)
	{
		//这时候就将capacity改变为新的大小
		//但是刚开始的时候capacity等于0，就算×2他还是0.
		//所以我们用一个三目表达式
		int newcapacity = ps->capacity == 0 ? 4: ps->capacity * 2;

		//当我知道开辟多少空间我们就可以用realloc
		//刚开始ps->a,是空指针，所以他这时就相当于malloc
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(DataType));
		//防止realloc开辟一个空指针。
		if (tmp == NULL)
		{
			perror("realloc");
			exit(-1);
		}
		//将开辟空间的指针传给ps->a
		ps->a = tmp;
		//将容量也改变
		ps->capacity = newcapacity;
	}
	ps->a[ps->sz] = n;
	ps->sz++;
}

(4)🐕打印顺序表

该操作就是简单打印一下，我们每写一个部分，我们就检查一部分，打印就是为了看我们写的最后的效果达到了没有，这个非常简单，大家直接看代码。
⭐对于这个部分，我们需要提醒一下大家，不要等我们将全部代码写完在进行调试，我们写一个部分就测试一部分，看看这个部分有没有问题，没有问题我们再进行下一部分。

//打印顺序表
void SLPrint(SL* ps)
{
	int i = 0;
	for (i = 0; i < ps-> sz; i++)
	{
		printf("%d ", ps->a[i]);
	}
}

(5)🐕尾删

有同学可能想能不能直接将最后一个数据直接变成0，是不是将相当于将最后一个数据删除了呢
但是同学们可以这也想，本来人家原本的数据就是0，那你再改成0，好像什么都没做，
其实可以直接将sz–，不就巧妙的将最后一个数据删掉了吗，有的人想不明白的，他明明还在哪呀，怎么叫删掉了呢，其实你sz–，你不用他了，下一回插入的时候不就直接覆盖掉了吗？

//尾删顺序表
void SLPopBack(SL* ps)
{
	//检查顺序表是否为空
	//温柔的检查
	/*if (ps->sz == 0)
	{
		printf("顺序表为空\n");
		return;
	}*/

	//暴力的检查
	//断言看他是否空了
	assert(ps->sz > 0);

	//将sz的值直接减一就相当于删除了
	ps->sz--;
}

(6)🐕头插

我们在想一下，在进行头插的时候我们需要从第一个位置开始依次向后移一个位置，如果我们从sz=1的时候向后移。我们会将后面的东西覆盖掉，说明从前到后是不可取的，我们应该从sz最大的时候向后移动一位，再将前面的依次向后退一个。

我们还需要注意一点，我们再插入的时候还需要检查一下，顺序表的容量是不是满了，因为我们再尾插中用过这个，所以我们可以将这个封装一个检查容量函数

(7)🐕检查容量函数

: 代码如下

//检查顺序表容量
void SLCheckCapacity(SL* ps)
{
	assert(ps);
	//当空间不够的时候扩容
	if (ps->sz == ps->capacity)
	{
		//这时候就将capacity改变为新的大小
		//但是刚开始的时候capacity等于0，就算×2他还是0.
		//所以我们用一个三目表达式
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;

		//当我知道开辟多少空间我们就可以用realloc
		//刚开始ps->a,是空指针，所以他这时就相当于malloc
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));
		//防止realloc开辟一个空指针。
		if (tmp == NULL)
		{
			perror("realloc");
			exit(-1);
		}
		//将开辟空间的指针传给ps->a
		ps->a = tmp;
		//将容量也改变
		ps->capacity = newcapacity;
	}
}
头插函数
代码 
//头插顺序表
void SLPushFront(SL* ps, SLDataType n)
{
	//检查容量是否满了
	SLCheckCapacity(ps);
	int i = 0;
	//下面这个大家画图自己看看，肯定能弄出来
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = n;
	ps->sz++;
}
在这里提一个问题
头插和尾插的时间复杂度是多少
我们可以清楚的看到尾插的时间复杂度是O(1),直接动最后一个就行了
而头插需要从最后一个开始挪，所以他的时间复杂度是O(N).
所以我们再用的时候一般都用尾插

(8)🐕头删

头删和尾删基本相同，最关键的问题就是越界问题，
我们需要知道，越界不一定会报错，但是后续的操作一定会受影响
越界读，不一定会报错。
越界写，可能会被检查出来，他是一种抽查。不会一个一个查。

//头删顺序表
void SLPopFront(SL* ps)
{
	assert(ps);
	int i = 0;
	//他删除可能会越界，因为删除次数大于sz的时候
	assert(ps->sz > 0);
	//画图确认逻辑很简单的
	int begin = 1;
	while (begin < ps->sz)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->sz--;
}

(9)🐕从中间插入数据

我们想一个问题，对于我们这从中间插入的数据，是不是包括头插和尾插呀，直接将参数改一下是不是能轻松的，所以我们头插尾插可以直接调用这个函数，就变得很简单。

//中间的插入
//在pos位置插入数据n
void SLInsert(SL* ps, int pos, SLDataType n)
{
	assert(ps);
	//pos也需要检查一下，防止pos不在范围内
	assert(pos >= 0);
	assert(pos <= ps->sz);

	//挪动数据
	//先检查容量
	SLCheckCapacity(ps);
	int end = ps->sz - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}

	ps->a[pos] = n;
	ps->sz++;
}

(10)🐕从中间删除数据

我们想一个问题，对于我们这从中间删除的数据，是不是包括头删和尾删呀，直接将参数改一下是不是能轻松的，所以我们头删尾删可以直接调用这个函数，就变得很简单。

//删除pos位置的数据
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos < ps->sz);
	
	//挪动数据覆盖
	int begin = pos + 1;
	while (begin < ps->sz)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->sz--;
}

(11)🐕查找数据

我们如果想通过找到数据，然后再做删除插入操作，那么我们需要在封装一层函数，找到数据对应的下标，然后我在进行插入删除操作。

//查找数据的位置
int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->sz; i++)
	{
		if (ps->a[i] == x)
		{
			return i ;
		}
	}
	return -1;
}

(12)写菜单

对于数据结构来说，我们的菜单其实就是起一个交互作用，对于我们学习知识来说没有太大的影响，并且对于调试我们每写一个功能来说也是不方便的，所以我们就简单做一个框架，大家把前面的东西弄明白就行。

#define _CRT_SECURE_NO_WARNINGS 1
#include"seqlist.h"
void menu()
{
	printf("**************************************\n");
	printf("****1.尾插数据   2.尾删数据      *****\n");
	printf("****3.头插数据   4 头删数据      *****\n");
	printf("****5.插入数据   6.删除指定数据  *****\n");
	printf("****7.查找数据   8.打印数据      *****\n");
	printf("****0.退出                       *****\n");
	printf("**************************************\n");
}
int main()
{
	SL sl;
	SLInit(&sl);
	int option = 0;
	int tmp = 0;
	do 
	{
		printf("请输入操作数\n");
		scanf("%d", &option);
		switch(option)
		{
		case 1:
			printf("请输入尾插的数据以-1结束\n");
			while (tmp!=-1)
			{
				scanf("%d", &tmp);
			}
			SLPushBack(&sl,tmp);
			break;
		case 2:
			break; 
		case 3:
			break; 
		case 4:
			break; 
		case 5:
			break; 
		case 6:
			break; 
		case 7:
			break;
		case 8:
			printf("打印数据\n");
			SLPrint(&sl);
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("输入错误请重新输入\n");
			break;
		}
		menu();

	} while (option);
	SLDistory(&sl);
	return 0;
}

seqlist.c的内容

我们在这里存放，函数的内部是实现

#define _CRT_SECURE_NO_WARNINGS 1

#include "seqlist.h"

//初始化顺序表将数据都设为0
void SLInit(SL* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->sz = 0;
	ps->capacity = 0;
}

//销毁顺序表
void SLDistory(SL* ps)
{
	assert(ps);
	//防止他是空指针
	if (ps->a != NULL)
	{
		free(ps->a);
		ps->a = NULL;
		ps->capacity = 0;
		ps->sz = 0;
	}

}
//检查顺序表容量
void SLCheckCapacity(SL* ps)
{
	assert(ps);
	//当空间不够的时候扩容
	if (ps->sz == ps->capacity)
	{
		//这时候就将capacity改变为新的大小
		//但是刚开始的时候capacity等于0，就算×2他还是0.
		//所以我们用一个三目表达式
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;

		//当我知道开辟多少空间我们就可以用realloc
		//刚开始ps->a,是空指针，所以他这时就相当于malloc
		SL* tmp = (SL*)realloc(ps->a, newcapacity * sizeof(SLDataType));
		//防止realloc开辟一个空指针。
		if (tmp == NULL)
		{
			perror("realloc");
			exit(-1);
		}
		//将开辟空间的指针传给ps->a
		ps->a = tmp;
		//将容量也改变
		ps->capacity = newcapacity;
	}
}

//顺序表的尾插
void SLPushBack(SL* ps,SLDataType n)
{
	assert(ps);
	//SLCheckCapacity(ps);
	//ps->a[ps->sz] = n;
	//ps->sz++;
	SLInsert(ps, ps->sz, n);
}
//打印顺序表
void SLPrint(SL* ps)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps-> sz; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

//尾删顺序表
void SLPopBack(SL* ps)
{
	//检查顺序表是否为空
	//温柔的检查
	/*if (ps->sz == 0)
	{
		printf("顺序表为空\n");
		return;
	}*/

	//暴力的检查
	//断言看他是否空了
	assert(ps->sz > 0);

	//将sz的值直接减一就相当于删除了
	/*ps->sz--;*/
	SLErase(ps, ps->sz-1);
}

//头插顺序表
void SLPushFront(SL* ps, SLDataType n)
{
	assert(ps);
	//检查容量是否满了
	//SLCheckCapacity(ps);
	//int end = ps->size - 1;
	//while (end >= 0)
	//{
	//	ps->a[end + 1] = ps->a[end];
	//	end--;
	//}
	//ps->a[0] = n;
	//ps->sz++;
	SLInsert(ps, 0, n);
}
//头删顺序表
void SLPopFront(SL* ps)
{
	assert(ps);
	//int i = 0;
	他删除可能会越界，因为删除次数大于sz的时候
	//assert(ps->sz > 0);
	画图确认逻辑很简单的
	//int begin = 1;
	//while (begin < ps->sz)
	//{
	//	ps->a[begin - 1] = ps->a[begin];
	//	begin++;
	//}
	//ps->sz--;
	SLErase(ps, 1);
}

//中间的插入
//在pos位置插入数据n
void SLInsert(SL* ps, int pos, SLDataType n)
{
	assert(ps);
	//pos也需要检查一下，防止pos不在范围内
	assert(pos >= 0);
	assert(pos <= ps->sz);

	//挪动数据
	//先检查容量
	SLCheckCapacity(ps);
	int end = ps->sz - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}

	ps->a[pos] = n;
	ps->sz++;
}
//删除pos位置的数据
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos < ps->sz);
	
	//挪动数据覆盖
	int begin = pos + 1;
	while (begin < ps->sz)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}

	ps->sz--;
}


//查找数据的位置
int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->sz; i++)
	{
		if (ps->a[i] == x)
		{
			return i ;
		}
	}
	return -1;
}

seqlist,.h的内容

我们在这里放函数的声明

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#define N 10

//将数据类型重定义一下
typedef int SLDataType;


静态顺序表
// 
//typedef struct Seqlist
//{
//	DataType a[N];
//	int size;//记录存储多少个有效数据
//}SL;//重新命名一下让后面的操作更加方便

//动态顺序表---按照需求扩空间
typedef struct Seqlist
{
	SLDataType *a;//动态开辟数组的指针
	int sz;//记录存储多少个有效数据
	int capacity;//空间容量，当sz大于他的时候再扩容
}SL;//重新命名一下让后面的操作更加方便

//顺序表的初始化
void SLInit(SL* ps);
//销毁顺序表
void SLDistory(SL* ps);
//打印顺序表
void SLPrint(SL* ps);
//检查顺序表容量
void SLCheckCapacity(SL* ps);

//尾插顺序表
void SLPushBack(SL* ps,SLDataType n);
//尾删顺序表
void SLPopBack(SL* ps);

//头插顺序表
void SLPushFront(SL* ps, SLDataType n);
//头删顺序表
void SLPopFront(SL* ps);

//中间的插入删除
//在pos位置插入数据n
void SLInsert(SL* ps, int pos, SLDataType n);
//在pos位置删除数据n，
void SLErase(SL* ps, int pos);

//查找数据的位置
int SLFind(SL* ps, SLDataType n);

总结

毫不夸张的说，这个其实是数据结构中最简单的部分，大家只有将这个部分弄明白，后面的学习才会更加通顺，大家一起加油。

桐桐超努力
关注
  • 22
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 11
    评论
专栏目录
二叉树基本操作
04-30
以二叉链表作存储结构，编写程序，实现如下的功能： 1、根据输入的数据建立一个二叉树； 2、分别采用前序、中序、后序的遍历方式显示输出二叉树的遍历结果 3、采用非递归的编程方法，分别统计二叉树的节点个数、度为1、度为2和叶子节点的个数，以及数据值的最大值和最小值。 4、（选作内容）试编写按层次顺序遍历二叉树的算法。参考算法思想：要采用一个队列q，先将二叉树根结点入队列，然后退队列，输出该结点；若它有左子树，便将左子树根结点入队列；若它有右子树，便将右子树根结点入队列，直到队列空为止。因为队列的特点是先进先出，从而达到按层次顺序遍历二叉树的目的。
C语言创建列表
07-23
题目：创建一个链表。1.程序分析：　　　　　　　　　　　2.程序源代码：/*creat a list*/#include "stdlib.h"#include "stdio.h"struct list{ int data;struct list *next;};typedef struct list node;typedef node *link;void main(){ link ptr,head;int num,i;ptr=(link)malloc(sizeof(node));ptr=head;printf("please input 5 numbers==>\n");for(i=0;idata=num;　 ptr->next=(link)malloc(sizeof(node));　 if(i==4) ptr->next=NULL;　 else ptr=ptr->next;}ptr=head;while(ptr!=NULL){ printf("The value is ==>%d\n",ptr->data);　 ptr=ptr->next;}}
数据结构——顺序表（Ｃ语言版）
weixin_53811859的博客
03-30 6103
室友一把王者的时间，手把手带你拿捏严奶奶数据结构里面的动态顺序表实现（C语言版），纯手工绘画，保证让初学者的xdm也一目了然，精简易懂
【C语言】顺序表的创建
热门推荐
lixxkv的博客
09-11 1万+
顺序表的代码实现
创建列表方法
weixin_43811239的博客
03-02 3324
创建列表
顺序表的实现（C语言）
03-11
C语言实现顺序表的操作，简单参考一下，相互交流学习。使用 C语言的顺序表的实现比较简单，是以前学习数据结构时专门记录的，有点帮助。
顺序表创建·c语言版
m0_60773087的博客
11-14 1120
提到顺序表很多人都会想起数组，但真正的顺序表真的只是一个数组那么简单吗？ 再写一个顺序表前，我们需要想三个问题： 1：如何在插入数据时就调整好数字的顺序 2：如何更新数组对的大小 3：数组如何进行扩容 考虑到上面的因素我们知道单靠一个数组是不够的，我们需要一个size记录数组的当前大小，一个capicity记录最大容量 ...
使用C语言创建顺序表
qq_44871378的博客
09-24 7880
C语言顺序表 C语言顺序表 #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR -1 #define MAXSIZE 5 typedef char ElemType ; //声明顺序表的结构体类型 typedef struct{ ElemType *elem; int length; ...
C语言实现顺序表
Sxy_wspsby的博客
10-30 2073
顺序表的实现与通讯录几乎一模一样，写过通讯录的来看看这篇文章就可以立马搞定顺序表。 首先我们按照惯例创建三个文件，一个里面是本工程所需要的头文件，一个里面是存放测试代码的文件，最后一个是放函数具体实现代码的文件。如图所示： 顺序表实际上是结构体里有一个你要存放数据类型的指针，每次增加数据都是给这个指针开辟空间，所以我们定义一个结构体变量，里面存放要保存什么类型的指针和一个记录位置的变量sz和记录空间容量的变量capcity。将结构体重命名为SeqList是为了后面更简单的使用结构体指针，将int重命
顺序表的建立（C语言）
17的博客
10-08 3527
线性表的顺序储存是指在内存中用一组地址连续的内存单元一次存储线性表的各元素，用这种存储形式存储的线性表成为顺序表。
C语言实现动态顺序表的实现代码
08-29
主要介绍了C语言实现动态顺序表的实现代码的相关资料,动态顺序表在内存中开辟一块空间，可以随我们数据数量的增多来扩容，需要的朋友可以参考下
C语言实现的顺序表功能完整实例
08-27
主要介绍了C语言实现的顺序表功能,结合完整实例形式分析了C语言顺序表的创建、添加、删除、排序、合并等相关操作技巧,需要的朋友可以参考下
C语言使用顺序表实现电话本功能
12-26
用顺序表实现电话本的功能（C语言） 电话本具有如下4个功能： 1.创建一个电话本，电话本里面包含名字和电话号码 2.在指定位置插入一个名字和电话号码 3.在指定位置删除一个名字和电话号码 4.打印电话本 代码...
基于C语言实现的顺序表以及基本接口实现
最新发布
02-14
顺序表是一种线性存储...在C语言中，我们可以使用数组和指针等基本数据结构和算法来实现顺序表的各种操作。通过运用C语言的数据类型和函数库，可以简单实现一个顺序表，并提供常用的接口操作，如插入、删除、查找等。
算法与数据结构 C语言描述 创建顺序表并循环存入数据
06-10
算法与数据结构 C语言描述 创建顺序表并循环存入数据，自己手打的，希望大家支持！
数据结构与算法——顺序表的基本操作（C语言详解版）
Itmastergo的博客
07-17 1712
前面我们学习了顺序表及初始化的过程，这里学习有关顺序表的一些基本操作，以及如何使用 C 语言实现它们。
C语言 创建一个顺序表
ZL_BKPD的博客
08-19 1万+
#include<stdio.h> #include<stdlib.h> #define Size 5 //对Size进行宏定义，表示顺序表申请空间的大小 /* 申请足够大小的物理空间之外，为了方便后期使用表中的数据，顺序表还需要实时记录以下 2 项数据： 顺序表申请的存储容量； 顺序表的长度，也就是表中存储数据元素的个数； */ typedef struct Table{ int *head; //声明了一个名为head的动态数组（不确定大.
顺序表的简单实现(C语言)
文溪山人的博客
03-11 7045
数据结构顺序表静态与动态代码实现
数据结构——顺序表（C语言编写）
新手小白
09-17 7716
数据结构，顺序表应用 插入、删除、合并...
使用c语言创建顺序表
05-25
以下是使用C语言创建顺序表的基本步骤： 1. 定义顺序表结构体 ```c #define MAXSIZE 100 // 定义顺序表的最大长度 typedef struct { int data[MAXSIZE]; // 存储元素的数组 int length; // 当前顺序表的长度 } ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

桐桐超努力

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

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

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

打赏作者

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

抵扣说明：

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

余额充值