《数据结构》（二）线性表之顺序表（超详细的万字教程）

置顶 已于 2022-10-04 14:02:00 修改
阅读量931 收藏 22
点赞数 27
分类专栏： 数据结构 C/C++ 链表 文章标签： 数据结构 算法 链表 c语言
于 2022-07-05 10:30:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Miraitowa_GT/article/details/125588140
版权
C/C++ 同时被 3 个专栏收录
12 篇文章 3 订阅
订阅专栏
数据结构
11 篇文章 2 订阅
订阅专栏
链表
5 篇文章 0 订阅
订阅专栏

今天把数据结构顺序表做了一个详细的总结🎉🎉🎉 ，既是方便自己复习也能帮助大家，大家有什么疑惑，或者不同的见解都可以和我讨论 ✉️✉️✉️

字数有点多，建议大家收藏起来慢慢看 😇家人们一起加油哈! 你我终成大牛！ 😎😎😎

顺序表之线性表

一.顺序表

下面我们先来介绍一下什么是线性表和什么是顺序表

1.1线性表

🎤线性表： 线性表的其中之一就是顺序表，属于包含与被包含的关系，线性表： 是n个具有相同特性的数据元素的有限序列，。常见的线性表：顺序表、链表、栈、队列、字符串…
线性表理想状态下是呈现一条线性的，
但是在物理结构中不一定是连续的，通常以数组和链式结构的形式存储
在这里插入图片描述

1.2顺序表

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

二.顺序表的实现

顺序表一般可以分为两种：

1. 静态顺序表：使用定长数组存储。

🎤我理解的静态表的意思就是:创建时的容量是确定的，也就是使用固定长度的数组 ， 下面我们就来构建一下静态存储

//构建顺序表中的静态存储
#define N 100             //用宏自定义数组长度，方便日后更改数据类型，增强代码可维护性
typedef int SLDataType;   //这里是将int重命名为SLDataType，也是增强代码可维护性
typedef struct SeqList
{
    SLDataType a[N];   //定长数组
    int size;             //数组中有效数据的个数
}SeqList;

🎤大家很容易就看出了静态存储有很多弊端。假如我们要存1000个数据，定长数组明显放不下，如果我们定长数组长度是1000，而我们只有10个数组需要存放，显然浪费空间，这样往返改变N的大小是不够方便的，这就体现了静态存储的不灵活性。😕😕😕下面我们就详细介绍动态顺序表与其接口实现

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

2.1构建动态顺序表
// 顺序表的动态存储
typedef int SQDataType;// 增强程序可维护性
typedef struct SeqList
{
	SQDataType* a;     //指向动态内存开辟的数组
	int size;          // 有效数据的个数
	int capacity;      // 容量空间的大小
}SL;
2.2动态顺序表的初始化
void SeqListInit(SL* ps)//初始化函数实现
{
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

🎤这里为什么要用指针呢？😮😮😮
🎤我们结合主函数给大家解释一下

int main()
{
    SL s;
	SeqListInit(&s); 
}
return 0;

因为传过去的形参只能在这个函数块（SeqListInit）内有效，改变形参对实参没有影响(我们的最终目的就是通过改变形参来改变实参)，所以这个用指针的方式，一荣俱荣，一损俱损。😉😉😉

2.3顺序表的空间检查及扩容

🎤动态存储与静态存储不一样的地方就是它能及时的扩容
大致思路：先判断在数据个数与容量是否相同，如果相同就进行扩容，这里就用realloc来动态申请内存，详细解释也写在代码块的注释里

void SeqListCheckCapacity(SL* ps)//增容函数实现--检查空间是否够用
{
	// 满了就要扩容
	if (ps->size == ps->capacity)//当数据个数与容量相同就是满了，进入下面扩容，else就不用写了，空间够了直接过了就行
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//如果newcapacity等于零就先给四个空间，如果不等于零就二倍一下
		SQDataType* tmp = (SQDataType*)realloc(ps->a, newcapacity * sizeof(SQDataType));//两倍两倍的扩容
		if (tmp == NULL)//检查是否失败--失败
		{
			printf("realloc fail\n");
			exit(-1);//结束程序
		}
		else//成功
		{
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
	}
}
2.4增删查改等接口实现

🎤顺序表基本上就是为了数据在内存中存起来，并实现增删查改

2.4.1尾部插入

🎤大致思路：尾部插入就是在顺序表中有效数据的后面增加一个新的数据，空间不够就扩容。下面用图片来帮助大家理解一下：
在这里插入图片描述

void SeqListPushBack(SL* ps, SQDataType x)//尾部插入函数实现
{
	SeqListCheckCapacity(ps);             //调用增容函数
	ps->a[ps->size] = x;                  //把x放在在下标为size的位置上
	ps->size++;                           //有效数据的个数增加1
}
2.4.2头部插入

🎤大致思路：头部插入和尾部插入刚好相反，基本思想就是先将顺序表中有效数据向后移动一位，然后将需要插入的新数据放在第一位上，空间不够就扩容。 如图：
在这里插入图片描述

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++;
}
2.4.3尾部删除

🎤大致思路：尾部删除也是比较简单的，就直接找到顺序表中有效数据的最后一个，并删除（置零）就ok啦，洒洒水的啦。 如图：
在这里插入图片描述

void SeqListPopBack(SL* ps)//尾部删除函数实现
{
	assert(ps->size > 0);//assert断言，判断顺序表中是否有数据，大于零就继续，等于零就报错，如果没有一个数据，还删个锤子
	ps->a[ps->size - 1] = 0;
	ps->size--;
}
2.4.4头部删除

🎤大致思路：头部删除就是把顺序表中有效数据从左到右一次向左移动一位，直接覆盖就行了， 如图：
在这里插入图片描述

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--;
}
2.4.5任意位置插入

🎤大致思路：
第一步： 需要我们要确认我们需要插入的位置是否在有效数据位置之内，没在其中还不如头插和尾插…
第二步： pos是我们要插入位置的数组下标，它后面的数据从右到左依次向右移动一位
第三步： 将我们新增数据x放到我们需要放到的位置即可，空间不够就扩容。
如图：
在这里插入图片描述

void SeqListInsert(SL* ps, int pos, SQDataType x)//任意位置插入函数实现---pos待插入位置的下标
{
	assert(pos <= ps->size);                     //不能在其他地方插入，只能在ps->size内插入
	SeqListCheckCapacity(ps);                    //调用增容函数
	int end = ps->size-1;                        //end代表最后一个有效数据的下标
	while (end >= pos-1)
	{
		ps->a[end+1] = ps->a[end];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;
}
2.4.6任意位置删除

🎤大致思路：
第一步： 需要我们要确认我们需要删除的位置是否在有效数据位置之内；
第二步： 找到待删除数据pos的下一位（start），直接从左到右向前覆盖，每覆盖一次++start，直到（start>=size）为止。
如图：
在这里插入图片描述

void SeqListErase(SL* ps, int pos)//任意位置删除函数实现---pos待删除位置的下标
{
	assert(pos < ps->size);//同上任意位置插入函数实现一样
	int start = pos+1;
	while (start < ps->size)
	{
		ps->a[start-1] = ps->a[start];
		++start;
	}
	ps->size--;
}
2.4.7查找数据

🎤大致思路：查找的话大家可以自己试一试更高效率的查找算法（二分查找肯定不行的，我们数据可能存放无序数据），这里我就不写那么清楚了，直接一手暴力循环查找

int SeqListFind(SL* ps, SQDataType x)//查找函数实现
{
	for (int i = 0; i < ps->size; ++i)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}
2.4.8更改数据

🎤大致思路：更改的话太简单了，直接找到需要更改数据的下标，然后把新数据放进去就好了，搜易贼呀😆😆😆

void SeqListModity(SL* ps, int pos, SQDataType x)//更改函数实现
{
	assert(pos < ps->size);
	ps->a[pos] = x;
}
2.5打印数据

🎤大致思路：传址调用吧， 节省空间，然后同样也是一个循环就行了

void SeqListPrint(SL* ps)//打印数据函数实现
{
	for (int i = 0; i < ps->size; ++i)//i<ps->size 终止条件，所有数据打印完为止
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

总代码

Test.c

#define _CRT_SECURE_NO_WARNINGS 1//针对vs2022，scanf报错的举措
#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.打印数据，-1.退出\n");
	printf("**********************************************\n");
	printf("请输入你要操作的选项:");
}

int main()
{
	SL s;
	SeqListInit(&s);
	int option = 0;
	int x = 0;
	int pos = 0;
	int rot = 0;
	while (option != -1)
	{
		menu();
		scanf("%d", &option);
		switch (option)
		{
		case 1:
			printf("请输入你要在尾部插入的数据，以-1结束\n");
			do {
				scanf("%d", &x);
				if (x != -1)
				{
					SeqListPushBack(&s, x);
				}
			} while (x != -1);
			break;
		case 2:
			printf("请输入你要在头部插入的数据，以-1结束\n");
			do {
				scanf("%d", &x);
				if (x != -1)
				{
					SeqListPushFront(&s, x);
				}
			} while (x != -1);
			break;
		case 3:
			printf("正在删除尾部最后一个数据\n");
			SeqListPopBack(&s);
			printf("删除成功\n");
			printf("现在你的数据为：");
			SeqListPrint(&s);
			break;
		case 4:
			printf("正在删除头部最后一个数据\n");
			SeqListPopFront(&s);
			printf("删除成功\n");
			printf("现在你的数据为：");
			SeqListPrint(&s);
			break;
		case 5:
			printf("请输入需要插入数组中位置的下标与数据，以空格隔开:>");
			scanf("%d %d", &pos, &x);
			SeqListInsert(&s, pos,x);
			printf("插入成功\n");
			printf("现在你的数据为：");
			SeqListPrint(&s);
			break;
		case 6:
			printf("请输入需要删除数组中位置的下标:>");
			scanf("%d", &pos);
			SeqListErase(&s,pos);
			printf("删除成功\n");
			printf("现在你的数据为：");
			SeqListPrint(&s);
			break;
		case 7:
			printf("请输入需要查找的数据:>");
			scanf("%d", &x);
			rot=SeqListFind(&s, x);
			if (rot != -1)
			{
				printf("找到了!在数组中下标为：%d的位置\n", rot);
			}
			else
			{
				printf("暂无此数据\n");
			}
			break;
		case 8:
			printf("请输入需要更改的位置下标与数据，以空格隔开:>");
			scanf("%d %d", &pos,&x);
			SeqListModity(&s,  pos,  x);
			printf("更改成功\n");
			printf("现在你的数据为：");
			SeqListPrint(&s);
			break;
		case 9:
			SeqListPrint(&s);
			break;
		default:
			break;
		}
	}

	SeqListDestory(&s);//释放空间函数

	return 0;
}

SeqList.h

#pragma once                                  //防止头文件被重复的包含

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

typedef int SQDataType;                       // 增强程序可维护性
typedef struct SeqList
{
	SQDataType* a;                            //指向动态内存开辟的数组
	int size;                                 // 有效数据的个数
	int capacity;                             // 容量空间的大小
}SL;

// 增删查改等接口函数
void SeqListInit(SL* ps);                     //初始化函数
void SeqListPrint(SL* ps);                    //打印数据函数
void SeqListDestory(SL* ps);                  //释放空间函数

// 尾插 头插 尾删 头删
void SeqListPushBack(SL* ps, SQDataType x);   //尾部插入函数
void SeqListPushFront(SL* ps, SQDataType x);  //头部插入函数
void SeqListPopBack(SL* ps);                  //尾部删除函数
void SeqListPopFront(SL* ps);                 //头部删除函数
void SeqListInsert(SL* ps, int pos, SQDataType x);//任意位置插入函数
void SeqListErase(SL* ps, int pos);           //任意位置删除函数

//查  改
int SeqListFind(SL* ps, SQDataType x);        //查找函数
void SeqListModity(SL* ps, int pos, SQDataType x);//更改函数

源文件SeqList.c

#include "SeqList.h"
//初始化函数实现
void SeqListInit(SL* ps)
{
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

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

//增容函数实现--检查空间是否够用
void SeqListCheckCapacity(SL* ps)
{
	// 满了就要扩容
	if (ps->size == ps->capacity)//当数据个数与容量相同就是满了，所以扩容
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//如果newcapacity等于零就先给四个空间，如果不等于零就二倍一下
		SQDataType* tmp = (SQDataType*)realloc(ps->a, newcapacity * sizeof(SQDataType));//两倍两倍的扩容
		if (tmp == NULL)//检查是否失败--失败
		{
			printf("realloc fail\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);//assert断言，判断顺序表中是否有数据，大于零就继续，等于零就报错，如果没有一个数据，还删个锤子
	ps->a[ps->size - 1] = 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--;
}
//任插  任删
//任意位置插入函数实现---pos待插入位置的下标
void SeqListInsert(SL* ps, int pos, SQDataType x)
{
	assert(pos <= ps->size);//不能在其他地方插入，只能在ps->size内插入
	SeqListCheckCapacity(ps);//调用增容函数
	int end = ps->size-1;
	while (end >= pos-1)
	{
		ps->a[end+1] = ps->a[end];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;
}
//任意位置删除函数实现---pos待删除位置的下标
void SeqListErase(SL* ps, int pos)
{
	assert(pos < ps->size);//同上任意位置插入函数实现一样
	int start = pos+1;
	while (start < ps->size)
	{
		ps->a[start-1] = ps->a[start];
		++start;
	}
	ps->size--;
}
//查 改
//查找函数实现
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 SeqListPrint(SL* ps)
{
	for (int i = 0; i < ps->size; ++i)//i<ps->size 终止条件，所有数据打印完为止
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

结语

大家学到这里，对于顺序表已经掌握的差不多了🍭🍭🍭 后续我会持续更新数据结构的学习总结，大家感兴趣可以点赞关注一下喽😜😜😜
在这里插入图片描述

#唐解元
关注
  • 27
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 20
    评论
专栏目录
《画解数据结构》九张动图，画解顺序表
英雄哪里出来
08-26 2万+
关于数组的8个算法，带你进入算法的大门
数据结构之线性表（手绘版）
耀的博客
09-21 2527
目录 一，写在前面 二，线性表的定义 三，线性表的抽象数据类型 四，线性表的顺序存储结构 4.1，顺序存储的定义 4.2，顺序存储方式 4.3，数据长度与线性长度的区别 4.4，地址计算方法 五，顺序存储结构的插入和删除 5.1，获得元素操作 5.2，插入操作 5.3，删除操作 5.4，线性表顺序存储结构的优缺点 六，线性表的链式存储结构 6.1，线性表链式存储结构定义 6.2，头节点和头指针的异同 6.3，线性表链式存储结构的代码描述 七，全部代码 一，写在前面...
【数据结构学习笔记】二、线性表---顺序表篇（1）（画图详解+代码实现）
大家好我叫张同学
12-29 3286
数据结构、算法图解、线性表、顺序表、链表
数据结构--线性表之顺序表
最新发布
touchinaiyou的博客
04-24 754
数据结构--线性表之顺序表
第三章 线性表的链式存储结构（单链表超详细讲解）
qq_62822533的博客
12-17 1104
目录3.6.1 线性表链式存储结构定义3.6.2 单链表的存储结构3.6.3 单链表基本操作的实现（一）单链表的初始化（二）判断链表是否为空（三）销毁单链表（四）清空单链表（五）求单链表的表长（六）取单链表中的第i个元素的内容（七）按值查找——根据指定数据获取该数据所在的位置（地址）（八）按值查找--根据指定数据获取该数据位置序号（九）在L中第i个元素之前插入数据元素e（十）删除--删除第i个结点（十一）头插法（十二）尾插法3.6.3 全部代码定义：n个结点链结成一个链表，即为线性表（）的链式存储结构。
数据结构之顺序表 - 超详细的教程，手把手教你认识并运用顺序表
ミカミミミ博客
05-20 675
在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：【说明】1. ArrayList是以泛型方式实现的，使用时必须要先实例化2. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问3. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的4. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的。
《数据结构》复习之线性表（顺序表和链表）
King来写代码的专栏
06-30 2835
线性表的概念 线性表的比较 线性表的数据结构 顺序表的算法操作 双链表的补充 总结1.线性表的概念　　线性表的存储结构有顺序存储结构和链式存储结构两种。前者成为顺序表，后者称为链表。 顺序表： 顺序表就是把线性表中的所有元素按照其逻辑顺序，一次存储到从指定的存储 位置开始的一块连续的存储空间中，如下图所示。 链表 在链表的存储中，每一个节点不仅包含所存元素本身的信息，还包含元素之间的逻辑
《数据结构》习题刷刷刷2（第二章线性表的顺序表示）
qq_45926254的博客
10-06 600
0x7fffffff}(3)设n=（|S1|+|S2|+|S3|）,时间复杂度为O（n），空间复杂度为O（1）.
数据结构学习--线性表及其应用--顺序表
06-25
线性表是数据结构的基础，它是由n（n>=0）个相同类型元素构成的有限序列。线性表按照存储方式可以分为顺序表和链表。顺序表是将线性表中的元素顺序地存储在一块连续的内存空间里，通常采用数组作为其底层实现。这种...
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
代码包含顺序表和单链表的基本操作（增删改查等，详见注释），并展示了两个具体使用例子，包括对基本操作的验证和合并两个有序线性表为一个有序表。代码均已通过Dev-C++5.4.0，为了防止误修改，文档已限制编辑，密码...
数据结构实验线性表（用java创建顺序表与链表并解决实验题目）
05-10
（1）创建一个顺序表，存放在数组 A[N]中，元素的类型为整型，设计算法调整 A，使其左边的所有元素小于 0，右边的所有元素大于 0（要求算法的时间复杂度和空间复杂度均为 O(n)）。 （2）建立一个循环单链表，其节点...
c/c++数据结构-线性表-顺序表
04-26
数据结构实验中线性表的顺序表代码，带有详细注释，小白也能看得懂
数据结构之线性表之顺序表
01-03
很好用的顺序表方法学习资料， 代码经过整理和测试运行... 里面讲解丰富
数据结构 —— 顺序表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-04 3331
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。
数据结构之线性表（适合初学者+附原创图附代码超详细+更新中）
weixin_45418543的博客
11-06 4614
一、线性表的定义和特点 前言：线性表是一种逻辑结构，意为数据元素之间存在一对一的关系，例如将学生信息数据依照其入学报到时间的先后顺序进行排列，这就组成了一个线性结构，这只是从逻辑关系(表面)上描述数据，而不牵扯到怎么把这些学生信息数据存储到计算机中。而这些学生信息数据怎样在计算机中的存储表示则称为数据的存储结构(也称物理结构)，这些数据元素在计算机中有两种基本的存储结构，分别是顺序存储结构和链式存储结构。 定义： 线性表是具有相同特性数据元素的一个有限序列（别的教材中也写作：由n（n>=0）个数据特性
超详细讲解线性表和顺序表！！
weixin_72817878的博客
02-15 2051
超详细讲解线性表和顺序表！！
【数据结构 by 解学武】线性表简介
萌宅鹿的技术小屋
09-03 1230
什么是线性表顺序存储结构和链式存储结构前驱和后继 通过前面的学习我们知道，具有“一对一”逻辑关系的数据，最佳的存储方式是使用线性表。那么，什么是线性表呢？ 线性表，全名为线性存储结构。 使用线性表存储数据的方式可以这样理解，即 “把所有数据用一根线儿串起来，再存储到物理空间中” 。 如图 1 所示，这是一组具有“一对一”关系的数据，我们接下来采用线性表将其储存到物理空间中。 首先，用“一根线儿”...
什么是线性表
m0_56609339的博客
09-25 1986
线性表
线性表
anxiaoerbmj的专栏
10-10 485
大家都知道线性表是线性结构的典型代表，
线性表与顺序表详解-数据结构教程
"该资源是关于数据结构学习的，特别是针对顺序表的讲解。它涵盖了线性表的基本概念、特点、应用以及相关的操作，并探讨了线性表与数组的区别，同时还介绍了线性表的抽象数据类型（ADT）及其相关操作的定义。" 在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

#唐解元

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

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

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

打赏作者

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

抵扣说明：

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

余额充值