C 数据结构2 —— 栈\队列

已于 2023-03-04 17:15:26 修改
阅读量231 收藏 4
点赞数 1
分类专栏： 王道C与数据结构 文章标签： 数据结构 c语言 链表
于 2023-03-04 17:02:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42731062/article/details/129176765
版权

文章目录

1. 栈

1.1 定义

在这里插入图片描述

  • 基本操作
    在这里插入图片描述

1.2 栈的顺序存储

  • 栈为空
    在这里插入图片描述
  • 栈满
    在这里插入图片描述

1.2.1 元素入栈

// 入栈
bool Push(SqStack& S, ElemType x)
{
	if (S.top == MaxSize - 1)// 栈满，不能入栈
	{
		return false;
	}
	S.data[++S.top] = x;// top从-1开始，++S.top之后top = 0
	return true;// 入栈成功
}

在这里插入图片描述

1.2.2 元素出栈

// 弹出栈顶元素
bool Pop(SqStack& S, ElemType& x)
{
	if (StackEmpty(S))// 栈为空
	{
		return false;
	}
	x = S.data[S.top];// 等价于x = S.data[S.top--]
	S.top--;
	return true;
}

在这里插入图片描述

1.3 栈的链表存储

  • 元素入栈
    在这里插入图片描述
  • 元素出栈，Lhead后面的元素就是栈顶元素(top)
    在这里插入图片描述
  • 栈满
    在这里插入图片描述

1.4 总程序

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>

// 实现栈，可以用数组，也可以用链表，这里使用数组
#define MaxSize 50
typedef int ElemType;
typedef struct
{
	ElemType data[MaxSize];// 数组
	int top;
}SqStack;// 结构体起别名Sqstack

// 初始化
void InitStack(SqStack &S)// 加引用表示要对其进行修改操作
{
	S.top = -1;// 栈顶 = -1，代表栈为空
}

// 读数据
bool StackEmpty(SqStack S)// 不用加引用
{
	if (S.top == -1)
	{
		return true;
	}
	return false;
}

// 入栈
bool Push(SqStack& S, ElemType x)
{
	if (S.top == MaxSize - 1)// 栈满，不能入栈
	{
		return false;
	}
	S.data[++S.top] = x;// top从-1开始，++S.top之后top = 0
	return true;// 入栈成功
}

// 获取栈顶元素
bool GetTop(SqStack S, ElemType &x)// x的值要改变
{
	if (StackEmpty(S))// 栈为空，则StackEmpty(S)的值为true
	{
		return false;
	}
	/*if (S.top == -1)与上面StackEmpty(S)的效果一致
		return false;*/
	x = S.data[S.top];
	return true;
}

// 弹出栈顶元素
bool Pop(SqStack& S, ElemType& x)
{
	if (StackEmpty(S))// 栈为空
	{
		return false;
	}
	x = S.data[S.top];// 等价于x = S.data[S.top--]
	S.top--;
	return true;
}

int main()
{
	SqStack S;// 先进后出 FILO LIFO
	bool flag;
	ElemType m;// 用来存放拿出的元素，下面有用
	InitStack(S);// 初始化
	flag = StackEmpty(S);
	if (flag)
	{
		printf("栈是空的\n");
	}
	Push(S, 3);// 入栈元素3
	Push(S, 4);// 入栈元素4
	Push(S, 5);
	flag = GetTop(S, m);// 获取栈顶元素,但是S.top的值不变
	if (flag)
	{
		printf("获取栈顶元素为%d\n", m);
	}
	flag = Pop(S, m);// 弹出栈顶元素
	if (flag)
	{
		printf("弹出元素为%d\n", m);
	}
	return 0;
}

2. 循环队列

2.1 定义

在这里插入图片描述

  • 初始化
    在这里插入图片描述
    在这里插入图片描述

2.2 元素入队

// 入队
bool EnQueue(SqQueue& Q, ElemType x)
{
	if ((Q.rear + 1) % MaxSize == Q.front)// 表示队列满了
	{
		return false;// 队列满了
	}
	Q.data[Q.rear] = x;
	Q.rear = (Q.rear + 1) % MaxSize;// 向后移动一格
	return true;
}

在这里插入图片描述

2.3 元素出队

// 出队
bool DeQueue(SqQueue &Q, ElemType &x)// 两个都要加引用,出队要改变x,x是起接收的作用
{
	if (Q.front == Q.rear)// 队列为空
	{
		return false;
	}
	x = Q.data[Q.front];
	Q.front = (Q.front + 1) % MaxSize;// 向后移动一格
	return true;
}

在这里插入图片描述

2.4 总程序

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>

#define MaxSize 5// 这里没有封号
typedef int ElemType;
typedef struct
{
	ElemType data[MaxSize];// 存储MaxSize-1个元素
	int front, rear;// 队列头，队列尾
}SqQueue;

// 队列初始化，让队列为空
void InitQueue(SqQueue& Q)
{
	Q.front = 0;
	Q.rear = 0;// 队列尾
}

// 判断队列是否是空, 知识判断, 不需要加引用
bool isEmpty(SqQueue Q)
{
	if (Q.front == Q.rear)
	{
		return true;// 是空队列
	}
	return false;
}

// 入队
bool EnQueue(SqQueue& Q, ElemType x)
{
	if ((Q.rear + 1) % MaxSize == Q.front)// 表示队列满了
	{
		return false;// 队列满了
	}
	Q.data[Q.rear] = x;
	Q.rear = (Q.rear + 1) % MaxSize;// 向后移动一格
	return true;
}

// 出队
bool DeQueue(SqQueue &Q, ElemType &x)// 两个都要加引用,出队要改变x,x是起接收的作用
{
	if (Q.front == Q.rear)// 队列为空
	{
		return false;
	}
	x = Q.data[Q.front];
	Q.front = (Q.front + 1) % MaxSize;// 向后移动一格
	return true;
}

int main()
{
	SqQueue Q;
	InitQueue(Q);// 初始化循环队列
	bool ret;// 存储返回值

	// 判断队列是否为空
	ret = isEmpty(Q);
	if (ret)
	{
		printf("队列为空\n");
	}
	else
	{
		printf("队列不为空\n");
	}

	// 入队
	EnQueue(Q, 3);
	EnQueue(Q, 4);
	EnQueue(Q, 5);
	ret = EnQueue(Q, 6);
	/*ret = EnQueue(Q, 7);*/// 只能存储4个元素
	if (ret)
	{
		printf("入队成功\n");
	}
	else
	{
		printf("入队失败\n");
	}
	
	// 出队
	ElemType element;
	ret = DeQueue(Q, element);
	if (ret)
	{
		printf("出队成功，元素值为%d\n", element);
	}
	else
	{
		printf("出队失败\n");
	}

	ret = DeQueue(Q, element);
	if (ret)
	{
		printf("出队成功，元素值为%d\n", element);
	}
	else
	{
		printf("出队失败\n");
	}
	return 0;
}

2.5 队列的链式存储

在这里插入图片描述

  • 添加尾指针
    在这里插入图片描述
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>

typedef int ElemType;
typedef struct LinkNode
{
	ElemType data;
	struct LinkNode* next;
}LinkNode;

typedef struct
{
	LinkNode* front, * rear;// 链表头，链表尾
}LinkQueue;// 先进先出

// 队列初始化
void InitQueue(LinkQueue& Q)
{
	Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));// 头和尾指向同一个结点
	Q.front->next = NULL;// 头结点next指针为NULL
}

bool IsEmpty(LinkQueue Q)
{
	if (Q.front == Q.rear)
	{
		return true;
	}
	else
	{
		return false;
	}
}

// 入队，尾部插入法
void EnQueue(LinkQueue& Q, ElemType x)
{
	LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
	s->data = x;
	s->next = NULL;
	Q.rear->next = s;// rear始终指向尾部，相当于把s的地址填到上一个结点的next位置，就是建立与上一个结点的联系
	Q.rear = s;// 更新尾结点到s
}

// 出队，头部删除法
bool DeQueue(LinkQueue& Q, ElemType &x)
{
	if (Q.front == Q.rear)
		return false;// 队列为空
	LinkNode* p = Q.front->next;// 头结点什么都没有，所以头结点的下一个结点才有数据
	x = p->data;
	Q.front->next = p->next;// 断链，将p的链赋给front
	if (Q.rear == p)// 删除的是最后一个元素
		Q.rear = Q.front;// 队列置为空
	free(p);
	return true;
}

// 头部删除法，尾部插入法
int main()
{
	LinkQueue Q;
	bool ret;
	ElemType element;// 存储出队元素
	InitQueue(Q);// 初始化队列
	EnQueue(Q, 3);
	EnQueue(Q, 4);
	EnQueue(Q, 5);
	EnQueue(Q, 6);
	EnQueue(Q, 7);
	ret = DeQueue(Q, element);
	if (ret)
	{
		printf("出队成功，元素值为%d\n", element);
	}
	else
	{
		printf("出队失败\n");
	}
}

3. 中级Day4作业

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>// malloc关键字

typedef int ElemType;
typedef struct LNode// data是4个字节，指针是4个字节，一共8个字节
{
	ElemType data;
	struct LNode* next;// 指向下一个结点
}LNode, * LinkList;// LinkList等价于struct LNode *,LNode和上面相同没问题

// 头插法新建链表
LinkList CreateList1(LinkList& L)// list_head_insert，加了引用&函数中的L与主函数中的L是同一个值，可以修改
{
	LNode* s; int x;// s为结构体指针，所以用->指向成员
	L = (LinkList)malloc(sizeof(LNode));// 创建带头结点的链表L，L表示头指针
	L->next = NULL;// L->data里边没有东西
	scanf("%d", &x);// 从标准输入读取数据
	// 3 4 5 6 7 9999
	while (x != 9999)
	{
		s = (LNode*)malloc(sizeof(LNode));// 申请一个空间，强制类型转换
		s->data = x;// 把读取的值，给新空间中的data成员
		s->next = L->next;// 让新结点的next指针指向链表的第一个元素(不是指L,而是指a1),第一个放我们数据的元素
		L->next = s;// 让s成为第1个元素
		scanf("%d", &x);// 读取标准输入
	}
	return L;
}

// 尾插法新建链表(r用来一直指向尾部)
LinkList CreateList2(LinkList& L)
{
	int x;
	L = (LinkList)malloc(sizeof(LNode));// 带有头结点的链表
	LNode* s, * r = L;// s与r都是结构体指针，写成LinkList s , r = L也可以；r代表链表表尾结点，指向链表尾部
	// 3 4 5 6 7 9999
	scanf("%d", &x);
	while (x != 9999)// r一直是表尾结点，s是新插入的结点
	{
		s = (LNode*)malloc(sizeof(LNode));// LNode* 和 LinkLis都可以，本质是等价的
		s->data = x;
		r->next = s;// r本身就是表尾结点，让尾部结点指向新结点s,s就是不断创造出来的新结点
		r = s;// r指向新的尾插结点
		scanf("%d", &x);
	}
	r->next = NULL;// 尾结点的next指针赋值为NULL
	return L;
}

// 打印链表中每个结点的值
void PrintList(LinkList L)// 这里没写引用
{
	L = L->next;// 让L指向第1个有数据的结点
	while (L != NULL)// NULL就是代表一张空的藏宝图，
	{
		printf("%d", L->data);// 打印当前结点数据
		L = L->next;// 指向下一个结点，如果有NULL的话，就截止(L真实指向的应该是结点的第二个位置)
		if (L != NULL)
		{
			printf(" ");
		}
	}
	printf("\n");
}

int main()
{
	LinkList L = NULL;// 链表头，是结构体指针类型
	LinkList search;// 用来存储拿到的某一个节点
	CreateList1(L);// 输入的数据可以为3 4 5 6 7 999,头插法倒着排序
	PrintList(L);// 打印链表
	CreateList2(L);// 输入的数据可以为3 4 5 6 7 999，尾插法顺着排序
	PrintList(L);// 打印链表
	return 0;
}

4. 中级Day5作业

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>

typedef int ElemType;
typedef struct LNode// data是4个字节，指针是4个字节，一共8个字节
{
	ElemType data;
	struct LNode* next;// 指向下一个结点
}LNode, * LinkList;

// 尾插法新建链表(r用来一直指向尾部)
LinkList CreateList2(LinkList& L)
{
	int x;
	L = (LinkList)malloc(sizeof(LNode));// 带有头结点的链表
	LNode* s, * r = L;// s与r都是结构体指针，写成LinkList s , r = L也可以；r代表链表表尾结点，指向链表尾部
	// 3 4 5 6 7 9999
	scanf("%d", &x);
	while (x != 9999)// r一直是表尾结点，s是新插入的结点
	{
		s = (LNode*)malloc(sizeof(LNode));// LNode* 和 LinkList都可以，本质是等价的
		s->data = x;
		r->next = s;// r本身就是表尾结点，让尾部结点指向新结点s,s就是不断创造出来的新结点
		r = s;// r指向新的尾插结点
		scanf("%d", &x);
	}
	r->next = NULL;// 尾结点的next指针赋值为NULL
	return L;
}

// 按序号查找结点
LNode* GetElem(LinkList L, int i)// L没有被改变，不用加引用&
{
	int j = 1;
	LNode* p = L->next;// L为头结点，让p指向第1个结点就是a1
	if (i == 0)
	{
		return L;// i为0就返回头结点
	}
	if (i < 1)
	{
		return NULL;// i是负值就返回空
	}
	while (p && j < i)
	{
		p = p->next;// p指向下一个a2
		j++;
	}
	return p;
}

// 新结点插入第i个位置
bool ListFrontInsert(LinkList L, int i, ElemType e)
{
	LinkList p = GetElem(L, i - 1);// p指向a(i-1)的位置,拿到要插入前一个位置的地址值
	if (p == NULL)
	{
		return false;
	}
	LinkList s = (LNode*)malloc(sizeof(LNode));// 为新插入的结点申请空间，LNode*换成LinkList也可以
	s->data = e;
	s->next = p->next;
	p->next = s;// s里面是起始地址，所以让p指向s
	return true;
}

// 删除第i个位置的元素
bool ListDelete(LinkList L, int i)
{
	LinkList p = GetElem(L, i - 1);// 查找删除位置的前驱结点
	if (p == NULL)// 空指针
	{
		return false;// 要删除的位置不存在
	}
	LinkList q = p->next;
	if (q == NULL)
	{
		return false;// q不存在则返回错误
	}
	p->next = q->next;// 断链
	free(q);// 释放对应结点的空间
	q = NULL;// 避免q成为野指针
	return true;//应该不是false
}

// 打印链表中每个结点的值
void PrintList(LinkList L)// 这里没写引用
{
	L = L->next;// 意思是L指向第一个放数据的元素a1的位置
	while (L != NULL)// NULL就是代表一张空的藏宝图，
	{
		printf("%3d", L->data);// 打印当前结点数据
		L = L->next;// 指向下一个结点，如果有NULL的话，就截止(L真实指向的应该是结点的第二个位置)
	}
	printf("\n");
}

int main()
{
	LinkList L;// 链表头，是结构体指针类型
	LinkList search;// 用来存储拿到的某一个节点
	CreateList2(L);// 输入的数据可以为3 4 5 6 7 999,尾插法

	// 按照序号查找
	search = GetElem(L, 2);// 查找链表第2个位置元素的值
	if (search != NULL)
	{
		printf("%d\n", search->data);
	}

	// 插入
	ListFrontInsert(L, 2, 99);// 新结点插入第i个位置
	PrintList(L);

	// 删除
	ListDelete(L, 4);// 删除第4个结点
	PrintList(L);// 打印注意函数
	return 0;
}
2021 Nqq
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构-线性表（链表）（c++版）
理科男同学
09-30 598
目录 1，单链表的基本概念与特点 ​ 2， 单链表的特点 3，单链表的结构定义及其方法的实现 3.1 单链表结构的定义 3.2方法的基本实现 3.3 单链表的插入删除操作讲解 3.4 单链表的删除算法 3.5 单链表的顺序访问与尾递归 3.6 尾插法建立单链表（递归方法实现） 3.7 头插法建立单链表（递归实现） 3.8 非递归算法实现链表的头插法和尾插法 1，...
实验二 链队列
Laufen_j的博客
04-25 246
#include&lt;iostream&gt;using namespace std;struct Node{ int data; Node *next;};class LinkQueue{public: LinkQueue(); ~LinkQueue(); void EnQueue(int x); int DeQueue(); int GetQueue(); int Empty();priva...
链表
qq_41965731的博客
10-04 430
根据尚硅谷的韩顺平老师的数据结构视频总结的笔记 观看视频的网址 一、链表的介绍 链表是有序的列表，但是它在内存中是存储如下 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 二、单链表 1、单链表介绍 单链表（带头节点）逻辑结构如下图： 2、单链表的应用实例 使用带head头的单向链表实现 –水浒英雄排行榜管理 ..
C语言数据结构——栈和队列
zcxmjw的博客
12-27 332
本篇文章主要带领大家深入了解栈和队列以及相关实现。
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
数据结构——栈的详解
热门推荐
晴空๓
04-20 7万+
栈和队列是两种重要的线性结构，从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表的子集。他们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，他们是和线性表大不相同的两类重要的的抽象数据类型。 C语言和C++中的栈C语言中的栈栈的定义C语言中栈的基本操作栈的初始化判断是否为空栈判断是否为满栈入栈出栈C语言实现栈的具体代码C++中的栈C++中栈的基...
【C语言】实现数据结构——栈，队列
weixin_45423515的博客
05-18 2143
栈和队列都常用的数据结构，这里使用C语言实现栈和队列， 一、栈 栈：是一种特殊的线性表，其只允许在一端出数据和入数据，插入数据和删除数据的一端加栈顶，另一端叫栈底。其数据遵守先进后出的原则（Last in First out）。 因为这个特点那么如果进入一段数据是 1 2 3 4 5，那么其出数据就是反的 5 4 3 2 1。 压栈(push):往栈顶插入数据。 出栈(pop):把数据在栈顶删除。 实现： typedef int STdatatype; typedef...
C语言数据结构——栈和队列的实现
h2608011009的博客
05-13 242
文章目录前言栈Stack.hStack.c队列Queue.hQueue.c结束语 前言 本文章主要是为下一篇的在线OJ题目做铺垫，因为仅仅用c语言做栈与队列的OJ题时需要自己造轮子，也就是自己编写栈或者队列的前提下完成题目代码的编写。 栈（FIFO先进先出）的实现主要是用动态数组的形式构建，先进先出用数组再方便不过，只需要记录下标的值，初始为零，每次入栈加数据，下标加一，出栈的时候只需要将下标减一所对应的内容取出即可。 队列（FILO先进后出）的实现主要是用不带头循环的单链表的形式构建，注意需要记录头结点与
C语言描述数据结构 —— 栈和队列
weixin_59913110的博客
08-06 622
栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出(先进后出)的原则。压栈：栈的插入草错叫做进栈、压栈、入栈。 出栈：栈的删除操作叫做出栈。我们介绍过顺序表和链表，那么要实现栈的数据结构用顺序表合适还是用链表合适呢？一般都是用顺序表，因为对于栈的数据结构来说，只涉及到尾插尾删，所以综合顺序表和链表，顺序表是更占优势的。 队列只运训在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。队
《数据结构C语言版》——栈和队列详解(图文并茂)，从零开始的学习
青春无问西东 岁月自成芳华
04-20 4614
一文搞懂数据结构系列之栈和队列部分，从0基础到快速手敲数据结构，小白也能轻松看懂的宝典！
数据结构（C语言版） 栈与队列 迷宫问题
06-10
在C语言版的数据结构课程中，第三章深入探讨了两种基础但非常重要的数据结构——栈和队列，并应用它们解决实际问题，如迷宫问题。 栈是一种后进先出（LIFO）的数据结构，类似于我们日常生活中的叠放物品。它主要...
c语言数据结构课设——树的应用2.docx
08-19
在C语言课程设计中，你将学习到关于树和二叉树的重要概念，以及如何在C语言中实现它们。这个项目特别关注树与二叉树之间的转换，以及各种遍历算法（前序...完成这个项目后，你将具备使用C语言处理复杂数据结构的能力。
实验4栈和队列_栈_数据结构_creaturexqi_队列_
10-03
本实验主题为“实验4栈和队列”，由creaturexqi提供，旨在深入理解和实践两种基本的数据结构——栈和队列。我们将分别探讨这两种数据结构的概念、特点、操作以及在实际中的应用。 首先，让我们来看看栈（Stack）。...
数据结构——队列的应用.doc
07-11
通过这个实验，我们不仅加深了对栈队列特性和顺序存储结构的理解，还掌握了如何根据问题特点选择合适的数据结构。同时，我们锻炼了C语言编程技能，尤其是动态内存管理和循环队列操作。实验过程中，可能遇到的问题...
数据结构实验——树和二叉树子系统
07-31
在本实验“数据结构实验——树和二叉树子系统”中，我们将深入理解二叉树的特性和操作。 首先，实验目的主要涵盖以下几个方面： 1. **理解二叉树特点**：二叉树的每个节点至多有两个子节点，它允许快速查找、插入...
数据结构【顺序表】
最新发布
qq_67578580的博客
07-12 964
我们需要创建一个seqlist.h头文件，seqlist.c文件存放函数，还有一个.c的测试文件。
数据结构--树和二叉树的一些知识点总结
weixin_68489989的博客
07-09 429
数据结构--树和二叉树的一些知识点总结
数据结构 Java DS——链表部分经典题目 (1)
cjejwe的博客
07-09 658
笔者计划在暑假啃完JavaDS,Mysql的内容当然也会继续更这次给读者们分享的是链表的几个比较典型的题目,关于如何手搓一个链表,笔者还在筹划中,毕竟链表的种类也有那么多,但是在下面的题目中,只有单向链表。
Redis教程(二十三)：Redis的底层数据结构
十三月的博客
07-09 1483
Redis是一种高性能的key-value数据库，广泛用于缓存、消息队列、应用程序会话管理等领域。它之所以能提供高效的数据操作性能，很大程度上归功于其底层使用了多种优化过的数据结构来存储数据。
数据结构不挂科-3-栈和队列.pdf
07-17
本资料主要介绍了两个基本的数据结构——栈和队列，特别是它们在C语言中的实现。 栈是一种特殊的线性数据结构，被称为“后进先出”（LIFO，Last In First Out）或“先进后出”（FILO，First In Last Out）结构。它...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

2021 Nqq

你的鼓励是我学习的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值