【数据结构】第一站：C语言--顺序表（附完整源码和注释）

已于 2023-11-13 15:42:53 修改
阅读量3k 收藏 35
点赞数 4
分类专栏： 初阶数据结构 文章标签： 数据结构 c语言 学习 链表
于 2023-04-14 23:38:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/White_popalr/article/details/130160692
版权

文章目录

前言

顺序表是数据结构学习所接触的第一个数据存储结构，对顺序表的结构有清楚的了解，将对后面的学习大有帮助。（本文章默认读者c语言有一定了解）还需要注意的是：数据结构的学习，我们亲自画图（理解逻辑的过程）十分重要，如果顺序表不好好画图，相信链表的实现时会让你头疼一阵。

一、顺序表的结构

在这里插入图片描述

typedef int SLDateType;
typedef struct SeqList
{
	SLDateType* a;
	int size;
	int capacity;
}SeqList;

顺序表的载体是一个结构体，它实际的数据将储存在指针a所指向的一片空间中
（我们用malloc开辟）。而size和capacity同样作为顺序表的属性成为顺序表结构体中的成员，这样可以方便我们随时获取顺序表的状态。

二、顺序表增删改查的实现

1.顺序表实现各函数

// SeqList.h
#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include<assert.h>
#define INIT_CAPACITY 3

typedef int SLDateType;
typedef struct SeqList
{
	SLDateType* a;
	int size;
	int capacity;
}SeqList;

// 对数据的管理:增删查改 
//初始化
void SeqListInit(SeqList* ps);
//销毁
void SeqListDestroy(SeqList* ps);
//打印查看
void SeqListPrint(SeqList* ps);
//尾插
void SeqListPushBack(SeqList* ps, SLDateType x);
//头插
void SeqListPushFront(SeqList* ps, SLDateType x);
//头删
void SeqListPopFront(SeqList* ps);
//尾删
void SeqListPopBack(SeqList* ps);
//检查容量大小/并扩容
void SeqListCheckCapacity(SeqList* ps);

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

2.顺序表的初始化（SeqListInit）

顺序表结构体中的成员a指针在结构体变量刚被创建时是一个野指针（我们没有给予初始化，它是随机的，也无法得知该指针指向哪里），如果这时对该指针进行解引用，就会非法访问内存空间。
所以我们用malloc函数对成员指针a进行空间开辟（在堆上），malloc开辟的空间将在内存中具有连续性（和数组一样），也可解引用找到顺序表的各个数据。
在这里插入图片描述

错误代码示例

void SeqListInit(SeqList* ps)
{
	ps->capacity = INIT_CAPACITY;
	for (int i = 0; i < ps->capacity; i++)
	{
		*(ps->a + i)=0;
	}
	ps->size = 0;
}

在这里插入图片描述
这是新手常见的初始化错误，对野指针解引用！
正确的初始化（如下）

void SeqListInit(SeqList* ps)
{
	assert(ps);
	//开辟空间
	ps->a = (SLDateType*)malloc(sizeof(SLDateType) * INIT_CAPACITY);
	//开辟失败报错
	if (ps->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->size = 0;
	ps->capacity = INIT_CAPACITY;
}

这里注意的是：1.对参数ps进行断言（我们无法对空的结构体指针进行成员访问）
2.当malloc开辟失败时我们打印错误信息并结束该函数。（一般不会失败）
（后面的数据结构学习我将逐渐减少强调）

3.顺序表的尾插尾删（SeqListPushBack/SeqListPopBack）

（1）尾插

尾插时结构体中size的大小刚好是a指向的下一个位置下标的位置，且尾插不需要移动数组中其他值的位置，所以尾插是顺序表中比较推荐的数据插入方式。
在这里插入图片描述
值得注意的是：当size的大小等于capacity时，我们需要对顺序表进行扩容操作！！(我们选择给顺序表扩容2倍）

void SeqListPushBack(SeqList* ps, SLDateType x)
{
	assert(ps);
	//扩容
	if (ps->size == ps->capacity)
	{
		SLDateType* tmp = (SLDateType*)realloc(ps->a,sizeof(SLDateType) * 2 * ps->capacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		else
		{
			ps->a = tmp;
		}
		ps->capacity *= 2;
	}
	 //SeqListCheckCapacity(ps);
	//开始尾插
	ps->a[ps->size] = x;
	ps->size++;

对已经申请的内存空间扩容时，要使用realloc函数，它两个参数分别是原地址和希望扩容的内存大小（单位是也是字节）， 注意realloc也有可能开辟失败（当需要的内存太大时），所以要做好报错准备，因为它需要保持像数组那样的顺序连贯的结构，所以当其指针所指空间的后面内存空间不足时，它会另寻足够空间的位置开辟，也就是所谓的异地扩容，此时realloc返回的指向开辟空间的指针的位置改变，需要另外一个临时指针变量做过渡。

（2）尾删

尾删就更简单了，我们只需要对size进行减一，无需担心没有删除已存的值，新的值插入时会将它替换。
在这里插入图片描述
不过空的顺序表无法删除，我们最好断言它，同时不要忘记对函数的参数指针进行断言。

void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
//	if (ps->size == 0)
//	{
//		return;
//	}
	ps->a[ps->size - 1] = 0;
	ps->size--;
}
//虽然注释里的报错也可以，但是最好使用暴力一点的报错assert。

4.顺序表的头插头删和扩容（SeqListPushFront/SeqListPopFront/SeqListCheckCapacity）

（1）头插

在顺序表里我们头插头删时，最差需要调整表中每个值的位置，所以时间复杂度是O(N),不高效。

在这里插入图片描述

void SeqListPushFront(SeqList* ps, SLDateType x)
{
	assert(ps);
	//扩容
	SeqListCheckCapacity(ps);
	int end=ps->size-1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}

注意上动图的size已经等于capacity了，所以在下次进入插入相关的函数时，我们需要对顺序表进行扩容，既然已经或者将要扩容多次，那么不如将扩容操作封装成一个函数 SeqListCheckCapacity。

void SeqListCheckCapacity(SeqList* ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		SLDateType* tmp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * 2 * ps->capacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
			ps->a = tmp;
		
		ps->capacity *= 2;
		printf("扩容成功！");
	}

}

（2）头删

void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
	for (int i = 0; i < ps->size-1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}

5.对顺序表进行打印

其实对于一个程序员而言，写一个程序，自己代码占3成，另外7成靠copy，，，，，，，，
开玩笑的O(∩_∩)O~，另外7成是调试，有时候虽然我们的代码能跑（没有报错），但是储存效果却不尽人意，所以数据结构学习中，我们最方便的调试方法就是在各函数正常运作的情况下尽快的、正确的写出一个打印函数（如果你不会调试的话），以便我们检查结构中的储存情况。

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

->操作符和[]的优先级一致，所以遵循从左到右的计算顺序。
注意：这里的参数结构体指针ps不能为空（不能对空的结构体指针进行成员访问），但是ps成员中的指针a可以为空（空顺序表也可以打印），这里看着简单，可是请你格外记忆理解，不要对它嗤之以鼻，如果不想被链表的断言扇巴掌的话。

6.顺序表指定值位置查找（SeqListFind）

根据参数值查找顺序表中对应值得位置并返回。
在这里插入图片描述

int SeqListFind(SeqList* ps, SLDateType x)
{
	assert(ps);
	int pos=-1;
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			pos = i;
			return pos;
		}
	}
	return pos;
}

7.顺序表在pos位置插入x/顺序表删除pos位置的值（SeqListInsert/SeqListErase）

这里的指定位置的插入删除和头插头删逻辑差不多，而且不知道你们有没有发现 ，其实只要完成了对指定位置pos位置的插入和删除的函数，我们的所有插入删除函数都可以用这两个函数实现（头插不就是指定下标为0的位置插入吗？尾删不就是指定下标为size-1的位置删除吗？）这样我们不就可以轻松解锁成就：15分钟写完一个顺序表~~~了吗。O(∩_∩)O

（1）指定位置插入

void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size - 1);
	SeqListCheckCapacity(ps);
	for (int i = ps->size - 1; i >= pos; i--)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->size++;
	ps->a[pos] = x;
}

（2）指定位置删除

void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size - 1);
	for (int i = pos; i <= ps->size - 1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}

8.顺序表的销毁

销毁也是代码新手容易常错的地方。
错误代码如下

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

错误：1.释放了结构体指针所指向的位置却又访问它的内存（非法访问）。
2.释放了成员a的内存却不置空（容易再次访问a，可是内存已经释放，所以依旧是非法访问）
（虽然有了错误1错误2就不会发生）
3.对函数中的形式参数进行改值（我们无法在函数中改变一个形式参数的值，除非传它的指针给函数，解引用访问，这里就是传指针的指针<二级指针>）。

正确代码如下

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

正如错误3中所言，我们只能将结构体指针的置空交给函数的使用者!(也就是进行对实参的置空）
注意：1.断言ps不为空指针
2.断言pos的位置为顺序表中有效位置

三、完整源码

1.SeqList.h

#define _CRT_SECURE_NO_WARNINGS 1

// SeqList.h
#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include<assert.h>
#define INIT_CAPACITY 3

typedef int SLDateType;
typedef struct SeqList
{
	SLDateType* a;
	int size;
	int capacity;
}SeqList;

// 对数据的管理:增删查改 
void SeqListInit(SeqList* ps);
void SeqListDestroy(SeqList* ps);
void SeqListPrint(SeqList* ps);
void SeqListPushBack(SeqList* ps, SLDateType x);
void SeqListPushFront(SeqList* ps, SLDateType x);
void SeqListPopFront(SeqList* ps);
void SeqListPopBack(SeqList* ps);
void SeqListCheckCapacity(SeqList* ps);

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

2.SeqList.c

//标准初始化
void SeqListInit(SeqList* ps)
{
	ps->a = (SLDateType*)malloc(sizeof(SLDateType) * INIT_CAPACITY);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->size = 0;
	ps->capacity = INIT_CAPACITY;
}
//顺序表结构体里，SLDateType*只是一个指针，为它在内存堆区里自定义开辟内存区域（使其自定义指向想要的内存大小）。

//标准顺序表销毁
void SeqListDestroy(SeqList* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}
//对malloc开辟（借用）的内存空间用完记得释放（还给操作系统）
//而对指向该空间的指针记得置空，以防意外非法访问已经释放的空间。


//标准顺序表打印
void SeqListPrint(SeqList* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
//->操作符和[]的优先级一致，所以遵循从左到右的计算顺序。

//标准顺序表尾插
void SeqListPushBack(SeqList* ps, SLDateType x)
{
	assert(ps);
	扩容
	//if (ps->size == ps->capacity)
	//{
	//	SLDateType* tmp = (SLDateType*)realloc(ps->a,sizeof(SLDateType) * 2 * ps->capacity);
	//	if (tmp == NULL)
	//	{
	//		perror("realloc fail");
	//		return;
	//	}
	//	else
	//	{
	//		ps->a = tmp;
	//	}
	//}
	 SeqListCheckCapacity(ps);
	//开始尾插
	ps->a[ps->size] = x;
	ps->size++;
}
//对已经申请的内存空间扩容时，要使用realloc函数，它两个参数分别是原地址和希望扩容的内存大小（单位是字节），
// 注意realloc也有可能开辟失败（当需要的内存太大时），所以要做好报错准备
//因为它需要保持像数组那样的顺序连贯的结构，所以当其指针所指空间的后面内存空间不足时，它会另寻
//足够空间的位置开辟，也就是所谓的异地扩容，此时指针的位置改变，需要另外一个临时指针变量做过渡。



//标准顺序表尾删
void SeqListPopBack(SeqList* ps)
{
	assert(ps->size > 0);
//	if (ps->size == 0)
//	{
//		return;
//	}
	ps->a[ps->size - 1] = 0;
	ps->size--;
}
//虽然注释里的报错也可以，但是最好使用暴力一点的报错assert，
//它会使程序直接弹出报错窗口，更容易找到程序的错误所在。

// 标准的顺序表头插
//头插头删在顺序表里时间复杂度是O(N),不高效。
void SeqListPushFront(SeqList* ps, SLDateType x)
{
	assert(ps);
	//扩容
	SeqListCheckCapacity(ps);
	int end=ps->size-1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}
//头插也需要扩容，既然已经或者将要扩容多次，那么不如将扩容操作封装成一个函数SeqListCheckCapacity。


void SeqListCheckCapacity(SeqList* ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		SLDateType* tmp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * 2 * ps->capacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
			ps->a = tmp;
		
		ps->capacity *= 2;
		printf("扩容成功！");
	}

}

//标准的顺序表头删
void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
	for (int i = 0; i < ps->size-1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}


//标准顺序表查找
int SeqListFind(SeqList* ps, SLDateType x)
{
	assert(ps);
	int pos=-1;
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			pos = i;
			return pos;
		}
	}
	return pos;
}


//标准顺序表指定位置插入
void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size - 1);
	SeqListCheckCapacity(ps);
	for (int i = ps->size - 1; i >= pos; i--)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->size++;
	ps->a[pos] = x;
}

//标准的顺序表指定位置删除
void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size - 1);
	for (int i = pos; i <= ps->size - 1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}

本文章为作者的笔记和心得记录，顺便进行知识分享，有任何错误请评论指点：）。

_poplar_
关注
  • 4
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构C语言-顺序表PPT课件.ppt
12-27
数据结构C语言-顺序表PPT课件.ppt
【C语言】超详细讲解顺序表的各种操作
云泽野の编程日记
07-02 5042
数据结构在内存中的表示通常有两种形式，一种是顺序存储，另一种是链式存储。线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表的数据元素，我们把这种存储形式存储的线性表称为顺序表。1.顺序表的逻辑结构和物理结构是一致的。2.顺序表中任意一个数据元素都可以随机存取，所以顺序表是一种随机存取的存储结构。 定义MAXLEN为100，表示顺序表最大的存储空间 利用宏方便对顺序表的大小进行修改利用typedef将DataType定义成int类型的数据，如果顺序表存放的数据要修改成其他类型的，可以直接 利用
数据结构_顺序表基本操作代码
QinMou
03-06 557
顺序表是用一段物理地址连续的存储单元依次存储数据元素的结构，一般情况下采用数组存储。在数组上完成数据的增删查改。顺序表的本质就是，动态增长，并且要求里面存储的数据必须是从左往右的。它分为静态顺序表（容量不可修改）和动态顺序表（可修改容量，可任意增删查改数据）
顺序表详解（C语言版）
热门推荐
qq_44075108的博客
09-27 1万+
本文介绍了顺序表的定义和常见操作并使用C语言代码对其进行实现。
顺序表的代码实现
m0_73592835的博客
12-15 880
顺序表的代码实现
【数据结构】C语言实现顺序表（超级详细）
m0_74459723的博客
01-01 1万+
顺序表作为线性表的一种，它是用一段数据元素的线性结构，一般情况下采用。在数组上完成数据的增删查改。顺序表一般分为：1、静态顺序表——使用定长数组进行存储元素。这种存储方式在存储数据时比较有局限性，当数据存储量非常小的时候，数组长度太长，会造成空间的浪费；当数据存储量非常大的时候，数组空间可能会不够，但是这种存储方式不能进行扩容。所以在实现顺序表时，我们通常使用的是动态顺序表。这样能够提高我们的空间利用率。2、动态顺序表——使用动态开辟的数组进行存储元素。
数据结构——顺序表（C语言编写）
新手小白
09-17 7655
数据结构，顺序表应用 插入、删除、合并...
数据结构——顺序表（Ｃ语言版）
weixin_53811859的博客
03-30 5996
室友一把王者的时间，手把手带你拿捏严奶奶数据结构里面的动态顺序表实现（C语言版），纯手工绘画，保证让初学者的xdm也一目了然，精简易懂
数据结构——顺序表的C语言代码实现
AZ10000000的博客
04-01 6599
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、基础知识1.顺序表的概念（Sepential List）2.常用的接口函数3.realloc（）函数使用细节4.assert( )函数二、代码实现1.SepList.h（1）引用函数库（2）定义动态顺序表（3）接口函数声明2.SepList.c（1）引用头文件（2）初始顺序表（3）检测顺序表容量是否足够（4）顺序表的尾插法（5）顺序表的尾删法<1>使用if判断的温和法<2>使用assert（）断言的.
顺序表（C语言版）
m0_64520498的博客
10-13 1576
静态顺序表：以定长数组储存元素 ；动态顺序表：使用动态开辟的数组储存
数据结构-C语言版：DS05-数组和广义表.ppt
06-06
数据结构-C语言版：DS05-数组和广义表.ppt
C语言 数据结构 顺序表的操作.doc
04-08
（1）根据下列程序环境的设置，完成顺序表的初始化函数List ListInit(int size)的编写。typedef int ListItem; /* 表元素类型 int */ （2）在第（1）题的基础上，void ListInsert(int k,ListItem x,List L)，实现在表L的第k 个位置插入 x。 （3）编写函数void PrintList(List L)实现输出顺序表中的元素。 （4）编写删除函数ListItem ListDelete(int k,List L)，实现在表L中删除位置k处的元素。 （5）编写查找函数ListItem ListRetrieve(int k,List L)，实现返回线性表中第k处的元素。 （6）编写顺序表L的判空函数int ListEmpty(List L)和求顺序表长度的函数int ListLength(List L)。 （7）编写函数int ListLocate(ListItem x,List L)，判断x位置。 （8）输入主函数对上面各个函数实现调用，并记录程序的运行结果。
c语言数据结构顺序表学习
03-27
本项目中包括线性表的建立，查找，插入，删除，合并操作，适用于初学者。主要用于数据表建立的入门
c语言数据结构顺序表合并
12-01
1.建立两个顺序表（通过随机函数生成）； 2.排序（升序），输出合并前的结果； 3.对这两个顺序表进行合并（保持升序）； 4.输出合并结果
严蔚敏数据结构C语言版本-可运行源码-完全C语言代码实现.zip
08-17
严蔚敏数据结构C语言版本_可运行源码_完全C语言代码实现 ----- 毕业设计，课程设计，项目源码均经过助教老师测试，运行无误，欢迎下载交流 ----- 下载后请首先打开README.md文件（如有），某些链接可能需要魔法打开...
数据结构-C语言描述（顺序表、链表）
04-01
水一下学校的实验报告，注释没有认真写，勿喷。
PTA—C语言数据结构：顺序表.ppt
10-11
PTA平台数据结构课程顺序表参考答案
数据结构——树和二叉树的基本概念
最新发布
qq_67693066的博客
04-24 1073
数据结构——树和二叉树的基本概念
数据结构c语言-顺序栈
10-05
顺序栈是一种基于数组实现的栈，它的特点是具有随机存取的特性。顺序栈的基本运算包括进栈、出栈和查看栈顶元素。进栈操作将元素插入到栈顶，出栈操作将栈顶元素删除并返回，查看栈顶元素操作返回栈顶的元素值，但不修改栈的状态。 在C语言中，顺序栈的存储结构可以使用一个一维数组来存放栈中的元素，同时使用一个指示器top来指示栈顶的位置。在进行进栈和出栈操作时，需要更新top的值，使其指向栈顶元素。 下面是一种常见的顺序栈的定义和基本操作的示例代码： ```c // 定义栈中元素的数据类型 typedef int StackElementType; // 定义顺序栈的存储结构 #define Stack_Size 100 // 栈的最大容量 typedef struct { StackElementType elem[Stack_Size]; // 用数组存放栈中元素 int top; // 栈顶指针 } SeqStack; // 初始化顺序栈 void Init_SeqStack(SeqStack *S) { S->top = -1; // 初始时栈为空，栈顶指针置为-1 } // 进栈操作 void Push_SeqStack(SeqStack *S, StackElementType x) { if (S->top == Stack_Size - 1) { printf("栈已满，无法进栈"); return; } S->top++; // 栈顶指针加1 S->elem[S->top] = x; // 将新元素放入栈顶位置 } // 出栈操作 StackElementType Pop_SeqStack(SeqStack *S) { if (S->top == -1) { printf("栈为空，无法出栈"); return -1; // 返回一个特殊值表示出错 } StackElementType x = S->elem[S->top]; // 获取栈顶元素的值 S->top--; // 栈顶指针减1 return x; // 返回栈顶元素的值 } // 查看栈顶元素 StackElementType GetTop_SeqStack(SeqStack *S) { if (S->top == -1) { printf("栈为空"); return -1; // 返回一个特殊值表示出错 } return S->elem[S->top]; // 返回栈顶元素的值 } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值