02线性表之顺序表

最新推荐文章于 2021-09-16 08:59:36 发布
最新推荐文章于 2021-09-16 08:59:36 发布
阅读量197 收藏 1
点赞数 3
分类专栏： 数据结构（C语言实现） 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52670477/article/details/119255653
版权

在之前我们学的变量数据中，各个数据之间相互独立的，通过一个变量是无法访问另一个变量的。但是线性表和它们不同，线性表中的数据在逻辑结构上相互挨着，因此一个数据和它相邻的数据之间是有联系的，比如数组。在顺序表中我们用到了C语言中结构体和动态开辟内存的知识。

文章目录

一、线性表的概念

线性表，全名为线性存储结构。使用线性表存储数据的方式可以这样理解，即“把所有数据用一根线儿串起来，再存储到物理空间中”。
线性表是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

用线性表存储的数据有两个特点：

  • 存储的数据本身的类型一定保持相同，是int型就都是int型，是结构体就都是一种结构体。
  • 数据一旦用线性表存储，各个数据元素之间的相对位置就固定了。

二、顺序表

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

顺序表一般可以分为：

  1. 静态顺序表：使用定长数组存储。
  2. 动态顺序表：使用动态开辟的数组存储。

由于静态顺序表的空间是固定的，过大容易浪费空间，过小容易不够，因此我们一般使用动态顺序表，动态顺序表的内容如下：
在这里插入图片描述

顺序表中的内容不一定非要是整形，也可以是浮点型或者结构体。

2.1顺序表的代码实现

  • 声明顺序表
typedef int SQDataType;//将int取别名为SQDataType，如果想要改为其他类型数据，只需要修改int即可

//使用动态顺序表
typedef struct SeqList
{
	SQDataType* a;//使用指针，方便扩容
	int size;  //有效数据的个数
	int capacity;//容量
}SL;//给struct SeqList起别名为SL
  • 初始化顺序表
//初始化
void SeqListInit(SL* ps)
{
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

由于一开始顺序表中的内容为空，此时还没有开辟空间，因此可以先把指针置为空，数据个数和容量都为0。

  • 扩容
//如果链表空间为空或者容量不够
void SeqListCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
	     //线性表为空则容量改为4，否则容量扩大为原来的两倍
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		//满了，扩容
		SQDataType* tmp = (SQDataType*)realloc(ps->a, newcapacity * sizeof(SQDataType));
		if (tmp == NULL)
		{
			printf("扩容失败\n");
			exit(-1);//退出程序
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
	}
}
  • 尾插
//尾插
void SeqListPushBack(SL* ps, SQDataType x)
{
	SeqListCheckCapacity(ps);//检查容量是否已满或者容量为空

    //插入数据
	ps->a[ps->size] = x;
	ps->size++;

}

尾插即在顺序表的尾部插入一个数据。
在这里插入图片描述

  • 头插
//头插
void SeqListPushFront(SL* ps, SQDataType x)
{
	SeqListCheckCapacity(ps);//检查容量是否已满或者容量为空

	int end = ps->size - 1;//最后一个元素下标的位置
	while (end>=0)
	{
		ps->a[end + 1] = ps->a[end];//将元素从后往前依次往后移动
		end--;
	}
	//插入数据
	ps->a[0] = x;
	ps->size++;
}

在这里插入图片描述

  • 尾删
//尾删
void SeqListPopBack(SL* ps)
{
	assert(ps->size > 0);//如果数据为空则报错
	ps->size--;
}

尾删的方式是直接将数据的个数减一，由于最后的数据是通过数据个数size访问的，因此虽然最后的数据还存在内存中，但是size减一以后也就访问不到了，在后续插入数据中，最后原来的数据会被覆盖掉。

  • 头删
//头删
void SeqListPopFront(SL* ps)
{
	assert(ps->size > 0);
	int start = 1;//第二个元素的下标
	while (start < ps->size)
	{
		ps->a[start - 1] = ps->a[start];

		start++;
	}
	ps->size--;
}

头删的方式就是从第二个数据开始依次往前移，覆盖掉第一个元素，同时个数size也要减一。
在这里插入图片描述

  • 任意位置插入
//任意位置插入
void SeqListInsert(SL* ps, int pos, SQDataType x)//pos是下标，从0开始
{
	assert(pos<ps->size);
	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 SeqListErase(SL* ps, int pos)
{
	assert(ps->size > 0);
	int start = pos+1;
	while (start < ps->size)
	{
		ps->a[start - 1] = ps->a[start];

		start++;
	}
	ps->size--;
}

与头删类似，只不过起始位置改为了任意位置的下标

  • 修改任意位置的元素
//修改
void SeqListModity(SL* ps, int pos, SQDataType x)
{
	assert(pos < ps->size);
	ps->a[pos] = x;

}
  • 冒泡排序整个顺序表
//冒泡排序

void SeqListBubleSort(SL* ps)
{
	//冒泡排序，每趟比较可以确定一个最大(最小)的数，所以需要size-1趟(最后一次自己跟自己比较不需要)
	for (int i = 0; i < ps->size - 1; ++i)
	{
		//每趟中需要比较size-i-1次(前面比较完的i个数不需要重复比较，最后一次自己跟自己比较不需要)
		for (int j = 0; j < ps->size - i - 1; ++j)
		{
			if (ps->a[j] > ps->a[j + 1])
			{
				SQDataType tmp = ps->a[j];
				ps->a[j] = ps->a[j + 1];
				ps->a[j + 1] = tmp;
			}
		}
	}
}
  • 打印整个顺序表元素
//打印
void SeqListPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
  • 查找指定的元素
//查找
int SeqListFind(SL* ps, SQDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

找到以后返回该元素的下标

  • 释放空间
//释放空间
void SeqListDestory(SL* ps)
{
	free(ps->a);
	ps->a=NULL;
	ps->capacity = ps->size = 0;
}

由于动态顺序表的空间是动态开辟的，因此在用完顺序表以后需要手动释放掉并把指针置为空指针。

三、顺序表菜单实现

将上面的功能依次调用，即可实现通过菜单来修改顺序表：

  • SeqList.h:
#pragma once

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<assert.h>
#define MAX_SIZE 10

typedef int SQDataType;

//静态顺序表给少了不够用，给多了会浪费时间
//使用动态顺序表
typedef struct SeqList
{
	SQDataType* a;
	int size;  //有效数据的个数
	int capacity;//容量
}SL;

//增删查改等接口函数

//初始化
void SeqListInit(SL* ps);

//尾插
void SeqListPushBack(SL* ps, SQDataType x);

//头插
void SeqListPushFront(SL* ps, SQDataType x);

//尾删
void SeqListPopBack(SL* ps);

//头删
void SeqListPopFront(SL* ps);

//打印
void SeqListPrint(SL* ps);

//任意位置插入
void SeqListInsert(SL* ps, int pos, SQDataType x);

//任意位置删除
void SeqListErase(SL* ps, int pos);

//销毁空间
void SeqListDestory(SL* ps);

//查找
int SeqListFind(SL* ps, SQDataType x);

//修改
void SeqListModity(SL* ps, int pos, SQDataType x);

//冒泡排序
void SeqListBubleSort(SL* ps);

//清空顺序表
void clear(SL* ps);
  • SeqList.c
#include"SeqList.h"

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

//如果链表空间为空
void SeqListCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		//满了，扩容
		SQDataType* tmp = (SQDataType*)realloc(ps->a, newcapacity * sizeof(SQDataType));
		if (tmp == NULL)
		{
			printf("扩容失败\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
	}
}
//尾插
void SeqListPushBack(SL* ps, SQDataType x)
{
	SeqListCheckCapacity(ps);

	ps->a[ps->size] = x;
	ps->size++;

}

//头插
void SeqListPushFront(SL* ps, SQDataType x)
{
	SeqListCheckCapacity(ps);
	int end = ps->size - 1;
	while (end>=0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}

//尾删
void SeqListPopBack(SL* ps)
{
	assert(ps->size > 0);
	ps->size--;


}

//头删
void SeqListPopFront(SL* ps)
{
	assert(ps->size > 0);
	int start = 1;
	while (start < ps->size)
	{
		ps->a[start - 1] = ps->a[start];

		start++;
	}
	ps->size--;
}

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


//任意位置插入
void SeqListInsert(SL* ps, int pos, SQDataType x)
{
	assert(pos<ps->size);
	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 SeqListErase(SL* ps, int pos)
{
	assert(ps->size > 0);
	int start = pos+1;
	while (start < ps->size)
	{
		ps->a[start - 1] = ps->a[start];

		start++;
	}
	ps->size--;
}

//销毁空间
void SeqListDestory(SL* ps)
{
	free(ps->a);
	ps->a=NULL;
	ps->capacity = ps->size = 0;
}

//查找
int SeqListFind(SL* ps, SQDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

//修改
void SeqListModity(SL* ps, int pos, SQDataType x)
{
	assert(pos < ps->size);
	ps->a[pos] = x;

}

//冒泡排序
void SeqListBubleSort(SL* ps)
{
	//冒泡排序，每趟比较可以确定一个最大(最小)的数，所以需要size-1趟(最后一次自己跟自己比较不需要)
	for (int i = 0; i < ps->size - 1; ++i)
	{
		//每趟中需要比较size-i-1次(前面比较完的i个数不需要重复比较，最后一次自己跟自己比较不需要)
		for (int j = 0; j < ps->size - i - 1; ++j)
		{
			if (ps->a[j] > ps->a[j + 1])
			{
				SQDataType tmp = ps->a[j];
				ps->a[j] = ps->a[j + 1];
				ps->a[j + 1] = tmp;
			}
		}
	}
}

//清空顺序表
void clear(SL* ps)
{
	ps->size = 0;
}
  • test.c
#include"SeqList.h"
void menu()
{
	printf("*******************************************\n");
	printf("**1.尾插数据                   2.头插数据**\n");
	printf("**3.尾删数据                   4.头删数据**\n");
	printf("**5.任意位置插入数据   6.任意位置删除数据**\n");
	printf("**7.查找数据                   8.排序数据**\n");
	printf("**9.修改数据                   10.清空数据**\n");
	printf("**11.显示数据                      -1.退出**\n");
	printf("*******************************************\n");
	printf("请输入选项:>\n");
	
}
int main()
{
	SL s;//创建一个顺序表变量
	SeqListInit(&s);//初始化
	int x=0;
	int option=0;

	int n = 0;
	int pos=0;
	int ret=0;
	while (1)
	{
		menu();
		scanf("%d", &option);
		switch (option)
		{
			case 1:
				printf("请输入要插入的个数:\n");
				scanf("%d", &n);
				printf("请输入要插入的数据:\n");
				for (int i = 0; i < n; i++)
				{
					scanf("%d", &x);
					SeqListPushBack(&s, x);
				}
	
				break;
			case 2:
				printf("请输入要插入的数据:\n");
				scanf("%d", &x);
				SeqListPushFront(&s, x);

				break;
			case 3:
				SeqListPopBack(&s);

				break;
			case 4:
				SeqListPopFront(&s);

				break;
			case 5:
				printf("请输入要插入的下标位置:\n");
				scanf("%d", &pos);
				printf("请输入要插入的数据:\n");
				scanf("%d", &x);
				SeqListInsert(&s, pos, x);
	
				break;
			case 6:
				printf("请输入要插入的下标位置:\n");
				scanf("%d", &pos);
				SeqListErase(&s, pos);
				break;
			case 7:
				printf("请输入要查找的数据:\n");
				scanf("%d", &x);
				ret=SeqListFind(&s, x);
				printf("下标位置是%d\n", ret);
	
				break;
			case 8:
				SeqListBubleSort(&s);

				break;
			case 9:
				printf("请输入要修改的下标位置:\n");
				scanf("%d", &pos);
				printf("请输入修改后的值:\n");
				scanf("%d", &x);
				SeqListModity(&s, pos, x);

				break;
			case 10:
				clear(&s);

				break;
			case 11:
				SeqListPrint(&s);

				break;
			case -1:
				exit(-1);
				break;
			default:
				printf("选择错误，请重新选择");

				break;

		}
	}

	SeqListDestory(&s);
	return 0;
}
今天也要写bug、
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
截取列表前面100行_python列表
weixin_39789042的博客
11-27 2271
List列表一组由有序数据做成的序列数据具有先后顺序数据可以不是一类数据list的创建直接创建，用中括号创建，内容用英文逗号隔开使用list()创建列表包含单个字符串的时候是个特列list的常见操作访问使用下标操作，也叫索引列表的元素索引是从0开始切片操作对列表进行任意一段的截取截取之后生成了一段新的列表允许设置步长从右往左，第一个下标不是0，是-1排序list相关函数 list练习# 直接赋值创...
学习数据结构第4天(线性表的顺序表示)
最新发布
研究方向：机器学习、深度学习、AIOT
04-15 772
线性表的顺序存储又称顺序表。顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储时指用一组地址连续的存储单元，依次存储线性表中的各个元素。因此线性表中任一数据元素都可以随机存取，所以线性表的顺序存储结构是一种随机存取的存储结构。第一个元素存储在线性表的起始位置，数组下标为0，第i个元素存储在数组下标为i-1的位置。顺序表中元素的逻辑顺序与其物理顺序相同，且物理地址的相差为【数组下标的差 * sizeof(单个元素)】，例如：第一个数组的类型是char类型的数据，这个数组的第一个元素[
重学数据结构之顺序表
twilight_shaw的博客
06-02 356
还是把顺序表从头到尾温习了一遍。 顺序表是线性表按照顺序存储结构存储的。我们按顺序将数据存储到存储空间中，所以存储单元的地址是连续的，即元素序号与存放它的数组下标一一对应。 序号通常从1开始，而下标从0开始，所以第i个元素的下标则是[i-1]。 我们用数组存放数据，数组的初始化必先定义长度，下文中我们用MaxSize来表示线性表总共占用的存储空间，而用length表示实际占用（length之...
顺序表的查找
weixin_52634719的博客
09-16 524
可以从最后开始或者从头开始查找 从第一个元素，即下标为0的元素开始。 第一个元素存在下标为0的位置，所以0+1，才能表示他是第几个元素。 i<L.length，即i从下标为0最大能到n-1,一个一个去看，找不到就i++下一次循环。变成n后，<的条件不成立，退出循环，不执行循环体。 ...
数据结构：顺序表的基本操作
热门推荐
Keep Fighting All The Time
05-03 10万+
线性表的顺序存储 顺序表的线性存储示意图 C语言定义线性表的顺序存储结构 线性表的顺序存储        线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素，使得线性表在逻辑结构上相邻的元素存储在连续的物理存储单元中，即：通过数据元素物理存储的连续性来反应元素之间逻辑上的相邻关系。采用顺序存储结构存储的线性表通常简称为顺序表。        顺序存
线性表之顺序表
03-28
在数据结构的领域里，线性表有多种实现方式，其中顺序表是最简单也是最直观的一种。顺序表是指表中的元素在内存中是连续存放的，就像数组一样，可以通过下标直接访问任意位置的元素。 顺序表的优点在于其访问速度快...
C语言_线性表之顺序表
01-16
线性表是最基础的数据结构之一，顺序表则是线性表的一种常见实现。本文将深入探讨C语言实现顺序表的相关知识点，包括其定义、操作以及具体实现。 顺序表是一种特殊的线性表，它的所有元素在内存中是连续存放的，...
线性表之顺序表常见操作
04-04
线性表之顺序表常见操作 增删改查,逆转等
线性表之顺序表增强操作
04-04
在“线性表之顺序表增强操作”中，我们可以探讨如何通过算法优化来提升顺序表的性能。SequenceList.java和SequenceListAlgorithm.java这两个文件很可能包含了对顺序表的一些操作实现，例如： 1. **扩容机制**：当...
线性表之顺序表合并.cpp
03-30
两个不同长度的线性表的合并，在合并过程中，两个线性表中共有的元素会自动删掉，合并后的线性表没有排序，如需排序，请看我之前发的线性表之顺序表实验
删除顺序表指定下标的元素
weixin_34087301的博客
07-22 327
天勤论坛高分笔记 2016 版，第 27 页，例 2-2。 描述：删除顺序表L中下标为p（1<=p<=length）的元素，成功返回1，否则返回0，并将被删除元素的值赋给e。 c/* Page 27, Example 2-2. 描述：删除顺序表L中下标为p（1<=p<=length）的元素，成功返回1，否则返回0...
顺序表中序号与对应数组下标区别详解
weixin_47219110的博客
07-27 3783
顺序表 数组下标 a1 0 a2 1 a3 2 … … an n-1 由上表可以直观看到，顺序表中的序号是从1开始的，而数组下标是从0开始的，所以，在代码的编写过程中，要格外注意这个区别。 下列顺序表中的插入元素e操作为例： bool ListInsert(SqList &L,int i,ElemType e) { if(i<1IIi>L.length+1) return false; if(L.length>MaxSize) return fa...
Python基础入门：从变量到异常处理（Task02-1列表）——天池
weixin_43848117的博客
09-07 880
1.列表 x = [0 for i in range(5)] print(x, type(x)) [0, 0, 0, 0, 0] <class ‘list’> x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0] print(x, type(x)) [3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99] <class ‘list’> 1.1
顺序表-顺序表的基本操作(初始化+指定位置元素值 + 用元素值求下标)
muyu_muyu的博客
12-25 1699
顺序表的存储结构： typedef struct{ int data[Maxsize]; //存在顺序表中的元素 int length; //存放顺序表的长度 }SqList; 一.初始化顺序表算法： void InitList(SqList &L){ L.length = 0; } 二.求顺序表中指定位置元素值的算法 1.首先要判断输入参数位置是否有误，有，则返回0 2.如果没有，则用e保存所要得到元素值 int GetElem
列表的下标为什么是从0开始而不是1?(顺序表)
qq_45019143的博客
10-29 7868
文章目录列表的下标为什么从零开始为什么列表append比insert快列表append之后,id值为什么不变,也可以说内存地址不变 列表的下标为什么从零开始 在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用 变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生变化（可以增加或删除元素）。 对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际 应用中的某种有意义的信息，或者表示数据之间的某种关系。 这样的
09交换排序算法---冒泡排序和快速排序
精致的灰的博客
08-09 3762
文章目录一、冒泡排序1.1.时间空间复杂度分析二、快速排序2.1.快排的递归实现2.1.1.挖坑法2.1.2.左右指针法2.1.3.前后指针法2.2.快排的非递归实现2.2.1.挖坑法2.2.2.左右指针法2.2.3.前后指针法2.2.4.用栈实现非递归2.3.快排的优化2.3.1三数取中2.3.2.小区间优化2.4.时间空间复杂度分析 一、冒泡排序 冒泡排序应该是最简单也是最容易理解的一种排序算法，它的逻辑是每趟将最大的数移到数组的最右边： 我之前写过冒泡排序的详细说明，链接如下：冒泡排序 代码实现：
12八大排序算法的稳定性以及时间空间复杂度总结
精致的灰的博客
08-09 2012
文章目录一、排序的稳定性二、八种排序方式的复杂度和稳定性 一、排序的稳定性 假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。 至于为什么有的排序不稳定，这和排序本身的实现算法逻辑有关，以快排的挖坑法为例： 如果begin[i]和key相等，begin会跳过这个数，最终交换以后key会到这个数的右边，顺序就
13迷宫问题（回溯思想）
精致的灰的博客
08-12 1573
迷宫问题是回溯思想的一种运用，一般可以用栈来实现 文章目录迷宫问题求解题目分析代码实现迷宫最短路径求解题目分析代码实现 迷宫问题求解 原题链接迷宫问题. 题目分析 题目要求我们先输入两个数代表迷宫的行和列，然后再输入具体的数组内容。这里的起点是左上角，终点是右下角，注意这里有可能让我们输入多组迷宫，所以此时需要用while循环来实现多次输入。另外这个题目中，1代表墙，不能走，0代表路，可以走。 从起点开始走迷宫，我们得先告诉程序向哪走，这里按上下左右的顺序依次走，如果走不通就向另一个方向走,要实现这
10归并排序算法
精致的灰的博客
08-09 1562
文章目录一、归并排序1.1.归并排序的递归实现1.2.归并排序的非递归实现1.3.时间空间复杂度分析 一、归并排序 归并的的思路是： 将数组拆分成若干个有序的子序列（一般是只有一个数的子序列），然后将已有序的子序列合并，得到完全有序的序列。 1.1.归并排序的递归实现 //归并排序的子函数 //这个函数将左右区间进行归并 void _MergeSort(int* a, int left, int right,int*tmp) { if (left >= right) { return;
线性表详解：顺序表与链表
1. 顺序存储：也称为顺序表，它将线性表的所有元素存储在一块连续的内存区域中。通过数组的方式，可以通过下标直接访问元素，具有较高的存取效率。例如，"0，1，2，…，9" 或 "A，B，C，…，Z" 可以看作是顺序表的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

今天也要写bug、

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

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

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

打赏作者

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

抵扣说明：

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

余额充值