数据结构--顺序表的增删查改--动态分配空间

已于 2022-11-07 08:15:29 修改
阅读量598 收藏 4
点赞数 11
分类专栏： #c语言案例及学习过程遇到的问题 文章标签： 数据结构
于 2022-11-06 22:09:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53269843/article/details/127717044
版权

一共有两份代码：

目录

第一份 分为 两个.c文件和一个.h文件

1、定义顺序表结构体和宏定义数据类型

2、顺序表的初始化

3、顺序表的摧毁（使用完需要摧毁顺序表）

4、顺序表元素的查找

5、检查ps的空间是否满了，如果满了则要重新分配空间

6、在pos位置插入数据

7、在pos位置删除数据

8、在头部插入数据

9、在头部删除数据

10、在尾部删除数据

11、在尾部插入数据

12、代码（全）

第二份 一个.c文件就可以运行

第一个分为 两个.c文件和一个.h文件

说明：

assert(ps)表示如果ps为空，会立即报错，使用这个函数一般要加头文件#include<assert.h>

ps表示SL类型的结构体，相当于顺序表

SeqList.h文件（头文件）存放函数的声明
SeqList.c文件(源文件)存放函数的定义
Seqtext.c存放主函数

1、定义顺序表结构体和宏定义数据类型

typedef int SLDateType;    //数据类型
typedef struct SeqList
{
	SLDateType* a;         //数据类型指针，指向动态开辟的数组
	int size;              //顺序表长度
	int capacity;          //顺序表容量
}SL;

2、顺序表的初始化



void SLInsert(SL* ps)     //顺序表的初始化
{
	assert(ps);

	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

3、顺序表的摧毁（使用完需要摧毁顺序表）


void SLDestroy(SL* ps)  //顺序表的摧毁
{
	assert(ps);
	if (ps->a)          //如果ps->a不为空
	{
		free(ps->a);//释放掉pa->a空间
		ps->a = NULL;
		ps->size = ps->capacity = 0;
	}
}

4、顺序表元素的查找

int  SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; ++i)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

如果找到了需要找的值，返回值的下标，否者返回-1;

5、检查ps的空间是否满了，如果满了则要重新分配空间


void SLCheckCapacity(SL*ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType *tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));//把新添加的用量添加到ps->a里面,这里注意tmp是地址空间
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}
}

刚开始初始化顺序表之后，也通过这个函数分配空间；在这里说一下realloc的作用：

 (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType))表示
给指向ps->a的指针分配一个大小为newCapacity * sizeof(SLDataType)大小
的空间，如果在原来指向ps->a的后面的空间被占用了，
则会异地开辟新的空间，
并且会拷贝原来的数据过来，而原来的空间会被释放掉。

6、在pos位置插入数据

//在pos 位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	assert(ps);
	assert(pos>= 0);
	assert(pos <= ps->size);                               //此处可以等于0,因为在插入之前ps->a[size]的值为0

	SeqListCheckCapacity(ps);
	int end = ps->size-1;
	while (end>=pos)
	{
		ps->a[end+1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

在插入数据之前需要考虑顺序表容量有没有满：SEqListCheckCapacity(ps);如果没有满，则将在pos位置往后的数据往后挪，挪完之后再插入数据x;

7、在pos位置删除数据

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

8、在头部插入数据

void SLPushFront(SL* ps, SLDataType x)   //头插
{
	SLInsert(ps, 0, x);
}

9、在头部删除数据

void SLPopFront(SL* ps)   //头删
{
	SLErase(ps, 0);
}

10、在尾部删除数据


void SLPopBack(SL* ps)                   //尾删除
{
	SLErase(ps, ps->size-1);
}

11、在尾部插入数据

void SLPushBack(SL* ps, SLDataType x)           //尾插入
{
	SLInsert(ps, ps->size, x);
}

12、代码（全）

这个是.h文件(头文件)，用来存放函数的声明和顺序表结构体的定义，引用头文件的时候记得加上#include"SeqList.h"

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

//静态顺序表---不太实用
//N太小了不够用，N大了可能浪费
//#define  N 1000
//动态顺序表---按需扩空间
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* a;
	int size;            //记录存储多少个有效数据
	int capacity;        //空间容量大小
}SL;

void SLInsert(SL* ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);

void SLPrint(SL* ps);
void SLInit(SL* ps);
void SLDestroy(SL* ps);
void SLCheckCapacity(SL* ps);    //检查容量

//尾插尾删
void SLPushBack(SL* ps, SLDataType x);
void SLPopBack(SL* ps);

//头插头删
void SLPushFront(SL* ps, SLDataType x);
void SLPopFront(SL* ps);

void menu();
int SLFind(SL* ps, SLDataType x, int begin);

 以下是SeqLIst.c文件，存放函数的定义

//SeqList.c
#define  _CRT_SECURE_NO_WARNINGS
#pragma once
#include"SeqList.h"

void SLCheckCapacity(SL*ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType *tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));//把新添加的用量添加到ps->a里面,这里注意tmp是地址空间
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}
}

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

void SLInit(SL* ps)     //顺序表的初始化
{
	assert(ps);

	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

void SLDestroy(SL* ps)  //顺序表的摧毁
{
	assert(ps);
	if (ps->a)          //如果ps->a有值在里面
	{
		free(ps->a);//释放掉pa->a空间
		ps->a = NULL;
		ps->size = ps->capacity = 0;
	}
}

//在pos位置插入数据
void SLInsert(SL *ps,int pos,SLDataType x)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos <= ps->size);

	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

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

void SLPushBack(SL* ps, SLDataType x)           //尾插入
{
	SLInsert(ps, ps->size, x);
}

void SLPopBack(SL* ps)                   //尾删除
{
	SLErase(ps, ps->size-1);
}
void SLPushFront(SL* ps, SLDataType x)   //头插
{
	SLInsert(ps, 0, x);
}

void SLPopFront(SL* ps)   //头删
{
	SLErase(ps, 0);
}

int  SLFind(SL* ps, SLDataType x, int begin)
{
	assert(ps);
	for (int i = begin; i < ps->size; ++i)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

 以下是用来存放主函数的文件，以及一些函数的调用

//SLtest.c
#define  _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"
void menu()
{
	printf("***********************************************************\n");
	printf("1、尾插数据 2、尾删数据\n");
	printf("3、头插数据 4、头删数据\n");
	printf("5打印数据  -1退出\n");
	printf("***********************************************************\n");
}
int main()
{
	SL ps;
	SLInit(&ps);             //顺序表的初始化
	//SLInsert(&ps,0,1);
	//SLPrint(&ps);
	int n=0;
	int option=0;
	do
	{
		menu();
		printf("输入操作\n");
		scanf("%d", &option);
		switch (option)
		{
		case 1: 
				printf("请输入你尾插的数据，以-1结束");
				scanf("%d",&n);
				while (n != -1)
				{
				SLPushBack(&ps,n);
				scanf("%d",&n);
				}
				break;
		case 2:
				SLPopBack(&ps);
				break;
		case 3:
				printf("请输入你头插入的数据，以-1结束\n");
				scanf("%d", &n);
				while (n != -1)
				{
				SLPushFront(&ps,n);
				scanf("%d", &n);
				}
				break;
		case 4:
				SLPopFront(&ps);
				break;
		case 5:
				SLPrint(&ps);
				break;
		default:
				break;
		}
	} while (option != -1);
	printf("????\n");
	SLDestroy(&ps);
	return 0;
}

第二份 一个.c文件就可以运行

(将代码复制到.c文件就可以运行)

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

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);

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

void SeqListInit(SeqList* ps)//初始化
{
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

void SeqListDestroy(SeqList* ps)
{
	assert(ps);
	if (ps->a)
	{
		free(ps->a);
		ps->a = NULL;               //指针制空，释放
		ps->size = ps->capacity = 0;
	}
}

void SeqPrint(SeqList* ps)          //打印
{
	int i;
	assert(ps);
	for (i = 0; i < ps->size; i++)
	{
		printf(" %d", ps->a[i]);
	}
}
void SeqListCheckCapacity(SeqList* ps)          //给ps->a 分配空间或者添加空间
{
	assert(ps);
	if (ps->size == ps->capacity)              //当顺序表长度等于顺序表的容量的时候
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDateType* temp = (SLDateType*)realloc(ps->a, newCapacity * sizeof(SLDateType));
		if (temp == NULL)                       //if里面用的是"=="
		{
			printf("realloc failed");
			exit(-1);
		}
		ps->a = temp;
		ps->capacity = newCapacity;
	}

}

//在pos位置删除数据
void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);
	assert(pos >= 0);
	assert(pos < ps->size);

	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin--] = ps->a[begin];        //pos位置的数据被它后一位的数据覆盖
		begin++;
	}
	ps->size--;
}
//在pos 位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	assert(ps);
	assert(pos>= 0);
	assert(pos <= ps->size);                               //此处可以等于0,因为在插入之前ps->a[size]的值为0

	SeqListCheckCapacity(ps);
	int end = ps->size-1;
	while (end>=pos)
	{
		ps->a[end+1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}
void SeqListPushBack(SeqList* ps,SLDateType x)       //尾插
{
	SeqListInsert(ps, ps->size, x); //相当于在位置ps->a[size]处插入值x
}
void SeqListPopBack(SeqList* ps)                    //尾删
{
	SeqListErase(ps, ps->size - 1);//相当于在位置ps->a[size-1]处删除数据
}
void SeqListPushFront(SeqList* ps, SLDateType x)   //头插
{
	SeqListInsert(ps, 0, x);
}
void SeqListPopFront(SeqList* ps)                  //头删
{
	SeqListErase(ps, 0);
}
int SeqListFind(SeqList* ps, SLDateType x)         //查找元素
{
	assert(ps);
	for (int i = 0; i < ps->size; ++i)
	{
		if (ps->a[i] == x)
		{
			return i;   //返回下标
		}
	}
	return -1; //若返回-1则找不到
}

int main()
{
	SeqList ps;
	int op;
	int x;
	int find;
	SeqListInit(&ps);                             //初始化
	do
	{
		printf("\n1、尾插 2、尾删 3、头插 4、头删 5、查找元素下标 6、打印 -1、退出\n");
		printf("输入你的操作:\n");
		scanf("%d", &op);
		switch (op)
		{
		case 1:
			printf("请输入你尾删的数据，以-1结束\n");
			scanf("%d", &x);
			while (x != -1)
			{
				SeqListPushBack(&ps, x);
				scanf("%d", &x);
			}
			break;
		case 2:
			SeqListPopBack(&ps); break;
		case 3:
			printf("请输入你头插的数据，以-1结束\n");
			scanf("%d", &x);
			while (x != -1)
			{
				SeqListPushFront(&ps, x);
				scanf("%d", &x);
			}
			break;
		case 4:
			SeqListPopFront(&ps); break;
		case 5:
			printf("请输入你要查找的元素x=");
			scanf("%d", &x);
			if ((find = SeqListFind(&ps, x)) == -1)
			{
				printf("没有该元素\n");
			}
			else
				printf("下标为%d", SeqListFind(&ps,x));
			break;
		case 6:
			SeqPrint(&ps); break;
		default:
			break;
		}
	} while (op != -1);
	
	SeqListDestroy(&ps);
	return 0;
}

@简单就好
关注
  • 11
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 12
    评论
专栏目录
数据结构C语言-顺序表PPT课件.ppt
12-27
数据结构C语言顺序表知识点 根据提供的PPT课件，以下是相关的知识点： 1. 线性表的逻辑结构 * 线性表是由n（n≥0）个类型相同的数据元素组成的有限序列。 * 线性表的逻辑结构可以用以下形式表示：L=(a1, a2,...,...
数据结构 - 顺序表(Contiguous-List)
10-23
在计算机内部存储一张线性表（线性结构的数表），最为方便简单的就是用一组连续的地址的内存单元来存储整张线性表。这种存储结构称为顺序存储结构。这种存储结构下的线性表就称为顺序表。
数据结构中动态分配空间
qq_43776124的博客
05-02 1372
1：就链式而言（我个人比较喜欢链式因为链式缺少空间可以以加结点的形式来进行增加比较方便） #include <iostream> #include <stdlib.h> using namespace std; void dongtaifenpei(){ int *p; p=new int; //申请了一个int类型的空间用new方法这时候p指向的地 /...
数据结构动态分配空间 c++_数据结构与算法系列二十七（图的基本 概念与存储）...
weixin_39882394的博客
11-23 91
1.考考你说起图这种数据结构，你可能不一定知道；但是我们日常生活中与图相关的应用，你一定都非常熟悉。比如说第一次去一个陌生的地方，你是不是会先看一下地图，然后通过导航到达目标地点；比如说你每天都会打开微信、或者QQ刷朋友圈，看好友动态等。那么图究竟是一种什么样的数据结构呢？图是一种非线性表的数据结构。说到非线性表的数据结构，还有线性表的数据结构：数组、链表、栈、队列。不知道你都还记得吗？...
数据结构动态分配空间 c++_备战秋招——算法与数据结构（2）
weixin_39998906的博客
11-23 65
● 请说一说你理解的stack overflow，并举个简单例子导致栈溢出参考回答：栈溢出概念：栈溢出指的是程序向栈中某个变量中写入的字节数超过了这个变量本身所申请的字节数，因而导致栈中与其相邻的变量的值被改变。栈溢出的原因：1. 局部数组过大。当函数内部的数组过大时，有可能导致堆栈溢出。局部变量是存储在栈中的，因此这个很好理解。解决这类问题的办法有两个，一是增大栈空间,二是改用动态分配，使用堆(...
数据结构：结构体的动态分配空间与回收
SYF_wdnmd的博客
04-17 115
1>if(条件)条件是价格的比较(p+j)->price (p+j+1)->price2>交换的是整个车的信息。交换的是*(p+j)和(pj+1)对应的整体信息3>注意中间变量t的类型，应该是结构体类型。在堆区申请5个连续的存储空间，实现车辆信息的输入 品牌，颜色，价格)例如:(p+j)表示整个车的地址。*(ptj)表示整个车的信息。1>调用函数在堆区申请空间。思路:和正常的冒泡是一样的。3>调用函数对价格排序。2>调用函数实现输入。
「数据结构」动态内存分配
Higomoro_Hibiki的博客
02-11 262
「数据结构」动态内存分配 动态内存分配是在问题大小未知的情况下，对于输入数据灵活地调整所需空间的一种方法。
顺序表C++_数据结构实验--顺序表；C++语言_
09-30
采用C++语言实现数据结构中顺序表的基本运算与操作
JavaScript数据结构-2-顺序表
01-20
class SqList {  //2020/1/10  //python有可变参数，js没有。。。  //js也没有重载  //我又想到JAVA里有构造函数，我设想的js的构造函数应该跟java类似，在构造函数里初始化  //找了半天，没找到，还是慢慢找吧...
数据结构-C语言描述（顺序表、链表）
最新发布
04-01
水一下学校的实验报告，注释没有认真写，勿喷。
数据结构（四）C++动态存储分配
Misslay's
10-19 1089
1.运算符new要为一个整数动态分配存储空间，可以用下面的语句说明一个整型指针变量int *x;当需要使用该整型时，可用下面的语句为它分配存储空间：y=new int; 为了在刚分配的空间中存储一个整数值10，*y=10;int *y y=new int(10);2.动态一维数组float x=new float[n]创造一个大小为n的一维浮点数组，运算浮new分配n个浮点数所需的空间，并返回指向第
数据结构线性表的动态分配空间要怎么增加（附代码）
ningdjdj的博客
03-22 1776
一、动态分配空间增加 我们这次说的内容是基于上次的线性表空间的动态和静态分配，（点击这里复习—>超级详细之数据结构线性表的静态和动态分配_易烊千玺编外老婆的博客-CSDN博客） 说是线性表的动态分配可以根据内容大小来分配，但是当分配完成之后，要怎么实现动态空间的增加呢？ 我们用个流程图来说明 假设我们分配一个只能容纳10个人的房间A，每个人都有对应的小空位。 现在房间A中都有人，那么当第11个人要进来时，空间不够，需要需要一片更大的房间B来存放这些人，并且需要把原来的那些人调到新的房间B里面去 .
数据结构——线性表（王道顺序表动态分配的顺序表增加空间）
weixin_43040618的博客
07-02 545
#include <stdio.h> #include <stdlib.h> #define Initsize 10 #define Elemtype int typedef struct{ Elemtype *data; int Maxsize; int length; }Seqlist; void InitLiner(Seqlist *list){ //初始化函数 list->data = (Elemtype *)malloc(Initsize *sizeof
【数据结构与算法 C/C++】顺序表实现与动态分配空间
qq_45596525的博客
04-01 1325
文章目录一、顺序表的特点二、顺序表实现1.数据结构2.数据结构操作实现3.动态扩容 一、顺序表的特点 随机访问,通过首地址和元素序号就能在时间**O(1)**内找到元素 存储密度高,每个结点只能存数据元素 (链表还要在结点存下一个元素地址) 逻辑上相邻的元素在 物理上也相邻 线性表的元素位序(序号)是从1开始的,数组的序号才是从0开始的 二、顺序表实现 1.数据结构 动态分配实现 代码如下（示例）： #define MAXSIZE 50 typedef struct Vector{ //
顺序表（动态扩容）
m0_69886881的博客
09-01 332
含：顺序表的实现代码C语言版，每个相关函数的介绍
【C语言基础】关于数据结构顺序表动态内存开辟的介绍
Qregi的博客
12-13 807
数据结构中，线性表的顺序存储结构就是，把线性表中的所有元素按照其逻辑顺序依次存储在计算机存储器中指定存储位置开始的一块连续的存储空间中。 因此，线性表的顺序存储结构是利用数组来实现的，数组的基本类型就是线性表中元素的类型。 顺序表的实现可以是静态的也可以是动态的，不过静态比较浪费内存，所以采用动态内存分配来实现顺序表。 maloc函数: 　void *malloc(int size);
线性表——顺序表
weixin_46640900的博客
06-29 820
顺序表 顺序表特点 顺序表主要特点是随机访问，即通过首地址和元素序号可在时间O(1)内找到指定元素 顺序表的存储密度高，每个节点只存储数据元素 顺序表逻辑上相邻的元素物理上也相邻，所以插入和删除需要大量元素。 顺序表实现 我们使用C语言来实现，首先有两个准备知识，一个是结构体的使用，第二个我准备创建一个可动态分配空间的顺序表，所以我们需要使用stdlib.h头文件中的内存管理函数。 然后我们需要明确一个顺序表创建需要什么，以及有哪些操作方法。参照上面线性表的操作方式。 在创建结构体中可以看到，在数组定
数据结构--数据结构的基本概念
m0_60593173的博客
06-25 544
若采用顺序存储，则各个数据元素在物理上必须是连续的；若采用非顺序存储，则各个数据元素在物理上可以是离散的。数据的存储结构会影响存储空分配的方便程度。eg：插队数据的存储结构会影响对数据运算的速度。eg：查看第7个元素的值。
【实用编程技巧】不想改bug?初学者必须学会使用的报错函数assert!(断言函数详解)
C/C++领域,数据结构,linux,MySQl学习者
10-15 2538
有关报错函数assert断言的新手入门详解.其中包括assert函数简介,参数及返回值解析,assert函数用法总结及注意事项,使用断言的原则等相关内容.学会使用断言,你的程序就能自己找bug了!
数据结构----单向链表
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点只知道下一个节点的位置，而不知道前一个节点的位置。 单向链表的特点是插入和删除操作的效率较高，但是查找某个节点的效率较低。链表的头节点是链表的入口，尾节点的指针指向空。 以下是单向链表的基本操作： 1. 插入操作：在链表的任意位置插入一个新节点。需要修改前一个节点的指针，使其指向新节点，同时新节点的指针指向原来的下一个节点。 2. 删除操作：删除链表中的某个节点。需要修改前一个节点的指针，使其指向下一个节点，同时释放被删除节点的内存空间。 3. 查找操作：遍历链表，逐个比较节点的值，直到找到目标节点或者到达链表末尾。 4. 遍历操作：按顺序访问链表中的每个节点，可以用来打印链表或者进行其他操作。 单向链表常用于需要频繁插入和删除操作的场景，比如实现栈、队列等数据结构，也可以用于实现其他高级数据结构，如图、树等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

@简单就好

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

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

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

打赏作者

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

抵扣说明：

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

余额充值