顺序表的实现超详细

已于 2023-03-27 16:28:10 修改
阅读量1.3k 收藏 18
点赞数 6
分类专栏： 数据结构 文章标签： 算法 数据结构 c语言
于 2023-02-24 23:54:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65245159/article/details/129203423
版权

顺序表的基本操作

一、顺序表的概念

● 顺序表是一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。
在这里插入图片描述
顺序表一般可以分为：

  1. 静态顺序表：使用定长数组存储元素。
//把 int 重命名为SLDataType,方便后期数据类型的修改
typedef int SLDataType; 
//capacity初始大小为3个(int)
#define N 50 

typedef struct SeqList
{
	SLDataType data[N]; //用来存放数据的数组指针
	int size; //当前顺序表中有效数据的个数
}SeqList;
  1. 动态顺序表：使用动态开辟的数组存储。
//把 int 重命名为SLDataType,方便后期数据类型的修改
typedef int SLDataType; 
//capacity初始大小为3个(int)
#define INIT_CAPACITY 3 

typedef struct SeqList
{
	SLDataType* data; //用来存放数据的数组指针
	int size; //当前顺序表中有效数据的个数
	int capacity; //顺序表的总大小
}SeqList;
二、顺序表的基本实现
1.顺序表的定义

使用结构体来创建一个顺序表

//把 int 重命名为SLDataType,方便后期数据类型的修改
typedef int SLDataType; 
//capacity初始大小为3个(int)
#define INIT_CAPACITY 3 

typedef struct SeqList
{
	SLDataType* data; //用来存放数据的数组指针
	int size; //当前顺序表中有效数据的个数
	int capacity; //顺序表的总大小
}SeqList;
2.顺序表的初始化

初始化顺序表为3个空间大小

void SeqListInit(SeqList* ps)
{
	//使用malloc为data初始化为3个空间
	ps->data = (SLDataType*)malloc(sizeof(SLDataType) * INIT_CAPACITY);
	//如果开辟失败则打印字符串和错信息
	if (ps->data == NULL)
	{
		perror("SeqListInit");
		return;
	}
	ps->size = 0; //size是顺序表的有效数据，初始为0
	//上面为顺序表开辟了3个空间，所以这里capacity初始为3个空间大小
	ps->capacity = INIT_CAPACITY; 
}
3.顺序表的销毁

动态开辟的空间都需要销毁

void SeqListDestroy(SeqList* ps)
{
	free(ps->data);
	ps->data = NULL;
	ps->capacity = ps->size = 0;
}
4.顺序表的打印
void SeqListPint(SeqList* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->data[i]);
	}
	printf("\n");
}
5.增加容量（空间不够则增容）

如果已经插入了3个数据，则空间已经满了，继续增加会非法访问内存，这时我们需要增加容量，我们是按照总容量大小的2倍来增加容量的，因为使用realloc开辟的空间，如果要增加的这个空间太大，realloc可能会异地扩容，realloc异地扩容的消耗大，所以我们每次增加总容量的2倍。

void check_capacity(SeqList* ps)
{
	//当size==capacity时，则代表顺序表的空间满了，需要扩容
	if (ps->size == ps->capacity)
	{
		//每次开辟的空间都是总空间的2倍
		SLDataType* tmp = (SLDataType*)realloc(ps->data, sizeof(SLDataType) * ps->capacity * 2);
		//如果开辟失败则打印字符串和错信息
		if (tmp == NULL)
		{
			perror("check_capacity");
			return;
		}
		
		ps->data = tmp; //把tmp开辟的空间给data
		ps->capacity *= 2;  //扩完容，把capacity的容量也修改成总空间大小的2倍
		printf("增容成功\n");
	}
}
6.查找指定位置

给定一个要查找的值，返回这个值下标就行了

int SeqListFind(SeqList* ps, SLDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->data[i] == x)
		{
			return i;
		}
	}
	return -1;
}
7.任意位置插入

给定一个下标，在下标位置插入一个新的值，下标的值和下标后的值都要往后移动一个位置

在这里插入图片描述

void SeqListInsert(SeqList* ps, int pos, SLDataType x)
{
	//当pos=0时，相当于头插，当下标为size时，相当于尾插
	assert(pos>=0 && pos<=ps->size);
	check_capacity(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->data[end + 1] = ps->data[end];
		end--;
	}
	ps->data[pos] = x;
	ps->size++;
}
8.任意位置删除

给定一个下标，从pos下标开始，把后面的元素向前覆盖一个位置
在这里插入图片描述

void SeqListErase(SeqList* ps, int pos)
{
	assert(pos>=0 && pos < ps->size);
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->data[begin-1] = ps->data[begin];
		begin++;
	}
	ps->size--;
}
9.尾部插入

1.尾部插入比较简单，我们只需要找到有效元素最后一个位置+1就可以插入了
2.也可以调用SeqListInsert任意位置插入函数
在这里插入图片描述

void SeqListPushBack(SeqList* ps, SLDataType x)
{
	//方法1：
	//assert(ps);
	//check_capacity(ps);
	//ps->data[ps->size] = x;
	//ps->size++;

	//方法2：调用SeqListInsert任意位置插入函数
	SeqListInsert(ps, ps->size , x);
}
10.尾部删除

1.尾部删除也比较简单，只需要找到size位置然后减1
2.也可以调用SeqListInsert任意位置删除函数

void SeqListPopBack(SeqList* ps)
{
	//方法1：
	//断言size不能为空，为空则会报错，不为空则什么也不做
	//assert(ps->size > 0);
	//ps->size--;

	//方法2：调用SeqListErase任意位置删除函数
	SeqListErase(ps, ps->size-1);
}
11.头部插入

1.把顺序表中所有数据向后移动，然后把data[0]首元素位置插入新值
2.也可以调用SeqListErase任意位置删除函数
在这里插入图片描述

void SeqListPushFront(SeqList* ps, SLDataType x)
{
	//方法一：
	//check_capacity(ps);
	//int end = ps->size - 1;
	//while (end >= 0)
	//{
	//	ps->data[end + 1] = ps->data[end];
	//	end--;
	//}
	//ps->data[0] = x;
	//ps->size++;


	//方法2：调用SeqListInsert任意位置插入函数
	SeqListInsert(ps, 0, x);
}
12.头部删除

1.头部删除就是把顺序表中所有元素向前移动一个位置
2.也可以调用SeqListErase任意位置插入函数

void SeqListPopFront(SeqList* ps)
{
	//方法1：
	//assert(ps->size > 0);
	//int begin = 1;
	//while (begin < ps->size-1)
	//{
	//	ps->data[begin - 1] = ps->data[begin];
	//	begin++;
	//}
	//ps->size--;

	//方法2：调用SeqListErase任意位置删除函数
	SeqListErase(ps,0);
}
13.整体代码

SeqList.h

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<string.h>

//把 int 重命名为SLDataType,方便后期数据类型的修改
typedef int SLDataType; 
//capacity初始大小为3个(int)
#define INIT_CAPACITY 3 

typedef struct SeqList
{
	SLDataType* data; //用来存放数据的数组指针
	int size; //当前顺序表中有效数据的个数
	int capacity; //顺序表的总大小
}SeqList;

void SeqListInit(SeqList* ps);

void SeqListDestroy(SeqList* ps);

void SeqListPint(SeqList* ps);

void SeqListPushBack(SeqList* ps, SLDataType x);
void SeqListPopBack(SeqList* ps);

void SeqListPushFront(SeqList* ps, SLDataType x);
void SeqListPopFront(SeqList* ps);

// 顺序表查找
int SeqListFind(SeqList* ps, SLDataType x);
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDataType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos);

SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"

void SeqListInit(SeqList* ps)
{
	//使用malloc为data初始化为3个空间
	ps->data = (SLDataType*)malloc(sizeof(SLDataType) * INIT_CAPACITY);
	//如果开辟失败则打印字符串和错信息
	if (ps->data == NULL)
	{
		perror("SeqListInit");
		return;
	}
	ps->size = 0; //size是顺序表的有效数据，初始为0
	//上面为顺序表开辟了3个空间，所以这里capacity初始为3个空间大小
	ps->capacity = INIT_CAPACITY; 
}


void SeqListDestroy(SeqList* ps)
{
	free(ps->data);
	ps->data = NULL;
	ps->capacity = ps->size = 0;
}

void SeqListPint(SeqList* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->data[i]);
	}
	printf("\n");
}

void check_capacity(SeqList* ps)
{
	//当size==capacity时，则代表顺序表的空间满了，需要扩容
	if (ps->size == ps->capacity)
	{
		//每次开辟的空间都是总空间的2倍
		SLDataType* tmp = (SLDataType*)realloc(ps->data, sizeof(SLDataType) * ps->capacity * 2);
		//如果开辟失败则打印字符串和错信息
		if (tmp == NULL)
		{
			perror("check_capacity");
			return;
		}
		
		ps->data = tmp; //把tmp开辟的空间给data
		ps->capacity *= 2;  //扩完容，把capacity的容量也修改成总空间大小的2倍
		printf("增容成功\n");
	}
}

void SeqListPushBack(SeqList* ps, SLDataType x)
{
	//方法1：
	//assert(ps);
	//check_capacity(ps);
	//ps->data[ps->size] = x;
	//ps->size++;


	//方法2：调用SeqListInsert任意插入函数
	SeqListInsert(ps, ps->size , x);
}


void SeqListPopBack(SeqList* ps)
{
	//方法1：
	//断言size不能为空，为空则会报错，不为空则什么也不做
	//assert(ps->size > 0);
	//ps->size--;


	//方法2：调用SeqListInsert任意位置删除函数
	SeqListErase(ps, ps->size-1);
}


void SeqListPushFront(SeqList* ps, SLDataType x)
{
	//方法一：
	//check_capacity(ps);
	//int end = ps->size - 1;
	//while (end >= 0)
	//{
	//	ps->data[end + 1] = ps->data[end];
	//	end--;
	//}
	//ps->data[0] = x;
	//ps->size++;


	//方法2：调用SeqListErase任意位置插入函数
	SeqListInsert(ps, 0, x);
}


void SeqListPopFront(SeqList* ps)
{
	//方法1：
	//assert(ps->size > 0);
	//int begin = 1;
	//while (begin < ps->size-1)
	//{
	//	ps->data[begin - 1] = ps->data[begin];
	//	begin++;
	//}
	//ps->size--;

	//方法2：调用SeqListErase任意位置删除函数
	SeqListErase(ps,0);
}

// 顺序表查找
int SeqListFind(SeqList* ps, SLDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->data[i] == x)
		{
			return i;
		}
	}
	return -1;
}
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDataType x)
{
	//当pos=0时，相当于头插，当下标为size时，相当于尾插
	assert(pos>=0 && pos<=ps->size);
	check_capacity(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->data[end + 1] = ps->data[end];
		end--;
	}
	ps->data[pos] = x;
	ps->size++;
}
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos)
{
	assert(pos>=0 && pos < ps->size);
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->data[begin-1] = ps->data[begin];
		begin++;
	}
	ps->size--;
}

test.c

enum Optin
{
	EXIT,
	SLBACKPUSH,
	SLBACKPOP,
	SLFRONTPUSH,
	SLFRONTPOP,
	SLINSERT,
	SLERASE,
	SLEFIND,
	SLPRINT
};



void menu()
{
	printf("**************************************************************\n");
	printf("*********      1.尾插            2.尾删             ***********\n");
	printf("*********      3.头插            4.头删             ***********\n");
	printf("*********      5.任意位置插入     6.任意位置删除      ***********\n");
	printf("*********      7.查找元素的下标   8.打印             ***********\n");
	printf("*********      0/-1.退出                           ***********\n");
	printf("*************************************************************\n");
}


int main()
{
	int option = 0;
	SeqList p;
	SeqListInit(&p);
	while (option != -1)
	{
		menu();
		printf("请输入要选择的选项：");
		scanf("%d", &option);
		if (option == EXIT)
		{
			printf("请依次输入要尾插的数据，以-1结束：");
			int x = 0;
			while (x != -1)
			{
				scanf("%d", &x);
				SeqListPushBack(&p, x);
			}
			SeqListPint(&p);
		}
		else if (option == SLBACKPUSH)
		{
			int x = 0;
			printf("请输入要尾删的个数：");
			scanf("%d", &x);
			while (x--)
			{
				SeqListPopBack(&p);
			}
			SeqListPint(&p);
		}
		else if (option == SLBACKPOP)
		{
			int x = 0;
			printf("请依次输入要头插的数据，以-1结束：");
			while (x != -1)
			{
				scanf("%d", &x);
				SeqListPushFront(&p, x);
			}
			SeqListPint(&p);
		}
		else if (option == SLFRONTPOP)
		{
			int x = 0;
			printf("请输入要头删的个数：");
			scanf("%d", &x);
			while (x--)
			{
				SeqListPopFront(&p);
			}
			SeqListPint(&p);
		}
		else if (option == SLINSERT)
		{
			int x = 0;
			int y = 0;
			printf("请输入要任意插入位置的下标：");
			scanf("%d", &x);
			printf("请依次输入你要插入的数据：");
			scanf("%d", &y);
			SeqListInsert(&p, x, y);
			SeqListPint(&p);
		}
		else if (option == SLERASE)
		{
			int x = 0;
			printf("请输入你要任意删除位置的下标：");
			scanf("%d", &x);
			SeqListErase(&p, x);
			SeqListPint(&p);
		}
		else if (option == SLEFIND)
		{
			int x = 0, y = 0;
			printf("请输入你要查找下标的个数：");
			scanf("%d", &x);
			printf("请依次输入你要查找下标的数字：");
			while (x--)
			{
				scanf("%d", &y);
				int ret = SeqListFind(&p, y);
				printf("%d ", ret);
			}
			printf("\n");
		}
		else if (option == SLPRINT)
		{
			SeqListPint(&p);
		}
		else if (option == -1)
		{
			printf("退出顺序表\n");
		}
		else
		{
			printf("无此选项，请重新输入\n");
		}
	}
}

打印结果：
在这里插入图片描述

14.顺序表的优缺点

优点：
1.支持随机访问（用下标访问），需要随机访问结构支持算法可以很好的适用；
2.cpu高速缓存命中率更高；

缺点：
1.头部中部插入删除时间效率低O(N);
2.连续的物理空间，空间不够了以后需要增容；
a.增容有一定程度的消耗；
b.为了避免频繁增容，我们一般按照2倍去增加，用不完会存在一定空间的浪费；

这篇文章到这就结束啦，不管你喜不喜欢，都看到这了，点完赞再走吧🤭

川子767
关注
  • 6
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【数据结构】顺序表的实现——超级无敌详细
qq_59702185的博客
08-07 2009
在当我们每想插入一个数据的时候，我们都要对顺序表进行判断，容量 capacity 是否和 size 相等，如果相等的话，那么，顺序表的空间就不够我们进行插入数据了。当然我们不能需要插入一个数据就开辟一个数据的大小，这样的话，付出的代价很大，我们可以每次增容 2 倍的capacity大小的容量，或者4倍，2倍是比较好的了。在我们想把顺表表最后一个数据删除时，不能直接赋为0，第一，我们不知道SLDataType到底是什么数据类型，第二，顺序表的最后一个数据有可能就是0，没有意义。遍历一遍顺序表，打印顺序表。..
顺序表的实现
weixin_53316121的博客
03-13 2693
目录 1.顺序表的概念 2.静态顺序表 分析： 3.动态顺序表 分析： 4.顺序表初始化 5.顺序表尾部操作 5.1尾插 空间检查函数实现 分析： 5.2尾删 分析： 6.顺序表的头部操作 6.1头插 分析： 6.2头删 分析： 7.固定位置操作 7.1固定位置插入 分析： 7.2固定位置删除 分析： 8.查找及打印 9.销毁顺序表 10.我的菜单及主函数 直接上代码： 1.顺序表的概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素...
【数据结构】--顺序表的实现
最新发布
2301_78009847的博客
04-15 1023
/动态顺序表//一级指针指向的动态开辟的数组int size;//有效数据个数//数组的容量大小}SL;
简单顺序表实现
行走江湖的少侠哥
06-14 457
#include #include #define MAX_LENGTH 20 typedef struct { char name[20]; double price; }BOOK; typedef struct { BOOK *list; int length; }Sqlist; int InitList(Sqlist *); //初始化顺序表 void PrintLis
顺序表的代码实现
m0_73592835的博客
12-15 908
顺序表的代码实现
【数据结构】C语言实现顺序表（超级详细）
m0_74459723的博客
01-01 1万+
顺序表作为线性表的一种，它是用一段数据元素的线性结构，一般情况下采用。在数组上完成数据的增删查改。顺序表一般分为：1、静态顺序表——使用定长数组进行存储元素。这种存储方式在存储数据时比较有局限性，当数据存储量非常小的时候，数组长度太长，会造成空间的浪费；当数据存储量非常大的时候，数组空间可能会不够，但是这种存储方式不能进行扩容。所以在实现顺序表时，我们通常使用的是动态顺序表。这样能够提高我们的空间利用率。2、动态顺序表——使用动态开辟的数组进行存储元素。
基于C语言的顺序表实现图书管理系统
01-06
1.动态内存管理 2.C语言编写 3.超级人性化，欢迎大家下载查询
数据结构顺序表和链表（超详细）
08-14
此压缩包为1、无头+单向+非循环链表增删查改实现// 动态申请一个结点// 单链表打印// 单链表尾插// 单链表的头插// 单链表的尾删// 单链表头删// 单链表查找// 单链表在pos位置之后插入x// 单链表删除pos位置之后的...
链表（C语言版）超详细讲解
01-04
本篇将对链表进行超详细的讲解，包括链表的概念、类型、操作以及如何在C语言中实现。 1. **链表的概念** 链表是一种线性数据结构，其中的元素在内存中不是顺序排列的。每个元素（节点）包含两部分：数据域（用于...
易语言超级列表框单击表头实现图片转换
07-22
5. **更新界面**：排序完成后，需要更新超级列表框的数据，使其按照新的顺序显示。同时，也要更新其他列头的图片，确保用户能清楚地看到当前的排序状态。 6. **保存状态**：为了在程序重启后还能保持用户的选择，...
易语言超级列表框表头排序
07-23
本篇将详细介绍易语言超级列表框表头排序的相关知识点。 **1. 超级列表框基础** 超级列表框（Super ListBox）是易语言中的一种控件，它能够同时显示多列文本信息，每列可以设置不同的宽度。它常用于数据展示、信息...
顺序表的基本操作及实现
11-22
顺序表的基本操作及实现顺序表的基本操作及实现顺序表的基本操作及实现
顺序表的实现（全代码）
m0_57662538的博客
03-19 4356
先给大家看看我们将会编写的函数，不喜勿喷，在有些细节方面，可以自行修改。程序完整代码我放在最后，大家可以自行下载 seqlist_t *create_seqlist(void); //创建一个空表 void clear_seqlist(seqlist_t *L); //为啥这里传递饿是指针 int is_empty_seqlist(seqlist_t *L); //判断表是否为空 int is_full_seqlist(seqlist_t *L); //判断表
C语言顺序表的12个基本操作(增删改查等)
学习笔记，仅供参考
03-20 1万+
参考严蔚敏数据结构 编译环境：vc++6.0 总共12大操作 初始化InitList(*L)； //构造空线性表L 销毁DestoryList(*L)； //销毁线性表L 清空ClearList(*L)； //清空线性表L 判表空ListEmpty(L)； //判断线性表是否为空 求表长Length(L)； //求线性表元素个数 按位查找Get...
顺序表的12种基本操作
爱码儿的博客
11-09 2365
本文总结了严蔚敏老师数据结构教材种的12种顺序表基本操作，包括新建、插入、删除、判空、求表长等。 ...
顺序表的十个基本操作（全）
热门推荐
兔子王
10-02 1万+
有关顺序表的十个基本操作，包括 1、初始化顺序表 2、插入 3、删除 4、查找 5、修改 6、逆置 7、排序 8、按序插入 9、按序合并 10、最小值
顺序表----12个基本操作实现
69小石头的博客
11-29 5070
顺序表是指线性表的顺序表示，指的是用一组地址连续的存储单元依次存储线性表的数据元素。只要确定了顺序表的起始位置，顺序表的任一数据元素都可以随机存取，线性表的顺序存储结构是一种随机存取的存储结构。在这点上与高级程序设计语言中的数组十分相似，因此通常用数组来描述数据结构中的顺序存储结构。 接下来是顺序表的12个基本操作和这12个操作在主函数中的检验。 #include<stdio.h...
顺序表的操作，你真的学会了吗？
princekin
04-21 5835
编程实现顺序表的以下基本操作：建立顺序表，修改顺序表，插入顺序表，删除顺序表。
【数据结构】顺序表的实现
学了就忘是正常现象
08-01 1075
【数据结构】顺序表的实现及数组相关oj题
点云处理算法整理（超详细教程）
09-14
点云处理算法是计算机视觉和图形学领域中的重要研究方向，它涉及到对三维空间中的点云数据进行处理、分析和应用。下面是一个超详细的教程，介绍了点云处理算法的主要内容。 1. 点云数据表示： - 点云数据的表示方式有两种：有序点云和无序点云。有序点云是指点的顺序与其在物体表面上的位置一一对应，常见的有序点云格式包括PLY和XYZ等。无序点云是指点的顺序与其在物体表面上的位置无关，常见的无序点云格式包括XYZRGB和XYZNormal等。 2. 点云预处理： - 点云预处理包括去噪、滤波和采样等操作。去噪的目标是降低点云中的噪声数据，常见的去噪算法有统计滤波和曲面平滑等。滤波操作可以对点云进行平滑处理，常见的滤波算法有高斯滤波和均值滤波等。采样操作可以减少点云数据量，常见的采样算法有随机采样和体素采样等。 3. 点云配准： - 点云配准是将多个点云数据对齐到同一个坐标系中的过程。常见的配准算法有ICP（Iterative Closest Point）和特征匹配等。ICP算法通过迭代优化点云之间的最小距离来实现配准，而特征匹配算法则是通过提取点云的特征描述子进行匹配。 4. 点云分割： - 点云分割是将点云数据划分为不同的部分或者物体的过程。常见的分割算法有基于几何特征和基于深度学习的方法。基于几何特征的分割算法通常使用平面分割和曲面分割等技术，而基于深度学习的方法则是使用卷积神经网络对点云进行分类。 5. 点云重建： - 点云重建是将离散的点云数据还原为连续的曲面模型的过程。常见的重建算法有基于网格的方法和基于隐式函数的方法。基于网格的方法将点云映射到一个网格结构上，并使用插值技术生成曲面模型，而基于隐式函数的方法则是通过学习一个表示曲面的隐式函数来进行重建。 6. 点云应用： - 点云处理算法在许多应用领域有广泛的应用，包括三维建模、机器人导航、虚拟现实和增强现实等。在三维建模方面，点云处理算法可以从激光扫描数据中提取出物体的几何信息，用于建立三维模型。在机器人导航方面，点云处理算法可以帮助机器人感知周围环境，实现自主导航。在虚拟现实和增强现实方面，点云处理算法可以用于生成真实感的三维场景。 这些是点云处理算法的一些基本内容，希望对你有所帮助！如果还有其他问题，请继续提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

川子767

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

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

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

打赏作者

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

抵扣说明：

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

余额充值