【数据结构】C语言实现链队列(附完整运行代码)

已于 2023-12-10 14:55:39 修改
阅读量1k 收藏 30
点赞数 23
分类专栏： 数据结构 实战项目集 C语言 文章标签： 数据结构 c语言 开发语言 算法 学习 队列
于 2023-11-25 21:16:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_72357342/article/details/134618998
版权

🦄个人主页:修修修也

🎏所属专栏:数据结构

⚙️操作环境:Visual Studio 2022

一.了解项目功能

在本次项目中我们的目标是实现一个链队列:

该链队列使用动态内存分配空间,可以用来存储任意数量的同类型数据.

队列结点(QNode)需要包含两个要素:数据域data,指针域next.

队列结点(QNode)逻辑结构图示如下:

   提供的功能有:

  1.   队列的初始化.
  2.   队列的入队.
  3.   队列的出队.
  4.   队列的长度.
  5.   队列的判空.
  6.   队列取队头元素.
  7.   队列取队尾元素.
  8.   队列的销毁

二.项目功能演示

要编写一个链队列项目，首先要明确我们想要达到的效果是什么样，下面我将用vs2022编译器来为大家演示一下链队列程序运行时的样子：

链队列的C语言实现

三.逐步实现项目功能模块及其逻辑详解

通过第二部分对项目功能的介绍，我们已经对链队列的功能有了大致的了解，虽然看似需要实现的功能很多，貌似一时间不知该如何下手，但我们可以分步分模块来分析这个项目的流程，最后再将各部分进行整合，所以大家不用担心，跟着我一步一步分析吧！

！！！注意，该部分的代码只是为了详细介绍某一部分的项目实现逻辑，故可能会删减一些与该部分不相关的代码以便大家理解，需要查看或拷贝完整详细代码的朋友可以移步本文第四部分。

1.实现链队列程序菜单

菜单部分的逻辑比较简单，就是利用C语言printf函数打印出这个菜单界面即可。但要注意菜单的标序要和后续switch...case语句的分支相应,以免导致后续执行语句错乱的问题.基础问题就不过多赘述了，代码如下：

该部分功能实现代码如下: 

void QMenu()
{
	printf("**********************************\n");
	printf("******请选择要进行的操作    ******\n");
	printf("******1.链队列入队          ******\n");
	printf("******2.链队列出队          ******\n");
	printf("******3.取队首元素          ******\n");
	printf("******4.取队尾元素          ******\n");
	printf("******5.队列判空            ******\n");
	printf("******6.查询当前队列长      ******\n");
	printf("******7.清空队列            ******\n");
	printf("******0.退出链队列程序      ******\n");
	printf("**********************************\n");
	printf("请选择:>");

}

2.实现链程序功能可循环使用

由于我们要实现  的功能可以反复使用的逻辑，且至少在一开始执行一次,因此我们选择do...while的循环语句来实现这一部分的逻辑.

该部分功能实现代码如下:

 int main()
    {
        Que Q;//创建队头尾指针结构体
        QueueInit(&Q);//初始化

        int swi = 0;//创建变量swi作为do...while循环的终止条件,以及switch语句的运行条件
        do          //使用do...while实现
        {

            QMenu();
            scanf("%d", &swi);

            switch (swi)
            {
            case 0:
                // 释放队列内存
                QueueDestroy(&Q);
            
                printf("您已退出程序:>\n");

                break;

            case 1:
                printf("请输入要入队的数据:>");
                QDatatype pushback_data = 0;
                scanf("%d", &pushback_data);

                QueuePush(&Q, pushback_data);

                printf("已成功入队:>\n");
                break;

            case 2:
                QueuePop(&Q);
                printf("出队成功:>\n");

                break;

            case 3:
                printf("队首元素为:");
                QDatatype e = QueueFront(&Q);
                printf("%d\n", e);
                break;

            case 4:
                printf("队尾元素为:");
                QDatatype n = QueueBack(&Q);
                printf("%d\n", n);
               
                break;

            case 5:
                if (!QueueEmpty(&Q))
                {
                    printf("当前队列不为空:>\n");
                }
                else
                {
                    printf("当前队列为空\n");
                }
                break;

            case 6:
               printf("当前队列长度为:");
               int size= QueueSize(&Q);
               printf("%d\n", size);
                break;

            case 7:
                QueueDestroy(&Q);
                QueueInit(&Q);
                printf("队列已清空:>\n");
                break;

            default:
                printf("输入错误,请重新输入\n");
                break;
            }
        } while (swi);

        return 0;
    }

3.创建链队列

创建链队列结点的结构体应该包括:存储数据的数据域data,以及存储下一个结点地址的指针域next.

图示如下:

因此我们创建QNode结构体类型时应由一个数据成员类型及一个指向该结构体的结构体指针组成.

然后队列特殊与单链表的点出现了:队列额外需要一个指向队头的队头指针,以及一个指向队尾的队尾指针,以及一个记录队长的整型size.

为了避免设计函数时要传好几个参数的情况,我们将这三个变量额外封装一个结构体,这样只要给函数传结构体变量就可以在函数内部访问这三个变量了.

如果有朋友对队列的两个结构体还搞不太清楚,可以这样理解:Queue结构体中的head指针相当于链表中的头指针,它的使用方式和链表中的头指针完全相同.然后在此基础上,只是多一个tail指针记录尾,多一个整型记录队列长度.

综上,该部分代码如下:

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1

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

typedef int QDatatype;

typedef struct QueueNode//一个是结点结构
{
	struct QueueNode* next;
	QDatatype data;
}QNode;


typedef struct Queue//一个是队列整体结构
{
	QNode* head;
	QNode* tail;
	int size ;
}Que;

4.链队列的初始化.

回忆我们在链表部分对链表的初始化仅仅是将头指针置为NULL.而到了链队列这里,我们还多出两个需要处理的变量,一个是尾指针tail,一个是链队列长度size.

因此我们封装一个初始化函数将这3个变量一起初始化.

链队列结构初始化部分代码逻辑图示如下:

 综上,该部分代码如下:

void QueueInit(Que* pq)
{
	assert(pq);

	pq->head = pq->tail = NULL;
	pq->size = 0;

}

5.链队列的入队.

链队列在入队时思路如下:

  • 开辟新结点
  • 判断队列是否为空队列
  • 为空则将新结点"头插"进队列
  • 不为空则将新结点"尾插"进队列

综上,该部分代码如下:

void QueuePush(Que* pq, QDatatype x) //入队是尾插
{
    //创建新结点
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
    //新结点赋值
	newnode->data = x;
	newnode->next = NULL;
    
    //当队列为空时,入队相当于头插
	if (pq->head == NULL)
	{
		assert(pq->tail == NULL);
        //head为空,tail不为空就出事了,即队头为空但是队尾不为空
		//将head和tail一起指向newnode
		pq->head = pq->tail = newnode;
		
	}
	else//否则就是尾插
	{
        //尾插直接将新结点链接在原来的队尾后面
		pq->tail->next = newnode;
        //然后更新队尾
		pq->tail = newnode;
	}
    
    //新结点插入成功后队列长度要+1
	pq->size++;

}

6.链队列的出队.

链队列在出队思路如下:

  • 判断队列是否为空队列
  • 如果是,抛出异常终止程序
  • 如果不是,则判断队列中是否仅剩一个结点
  • 如果只剩一个结点,释放该结点,然后将head和tail置为空
  • 如果不是只剩一个结点,那么使用一个指针记录下当前队头的下一个结点的位置
  • 释放当前队头结点,然后更新队头指针
  • 最后队列长度-1

综上,该部分代码如下:

void QueuePop(Que* pq)//出队是头删,删前先判空
{
	assert(pq);
	assert(!QueueEmpty(pq));//assert为假会终止程序

	QNode* cur = pq;

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}

	pq->size--;

}

7.链队列的长度.

求链队列的长度,因为我们有设计记录链队列长度的变量size,因此我们直接返回结构体中的size成员的值即可.

int QueueSize(Que* pq)
{
	assert(pq);

	return pq->size;

}

8.链队列的判空.

判断队列是否为空,我们可以返回(pq->size==0)表达式的值:

  • 如果队列为空,则size=0,则pq->size==0表达式为真,函数返回true.
  • 如果队列不为空,则size不等于0,则pq->size==0表达式为假,函数返回false.

综上,该部分代码如下: 

bool QueueEmpty(Que* pq)//判空!为空返回真!
{
	assert(pq);

	return pq->size==0;
}

9.链队列取队头元素.

取队头元素思路:

  • 判断队列是否为空
  • 为空抛出异常
  • 不为空返回队头指针指向的头节点的数据域

综上,该部分代码如下: 

QDatatype QueueFront(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;

}

10.链队列取队尾元素.

取队尾元素思路:

  • 判断队列是否为空
  • 为空抛出异常
  • 不为空返回队尾指针指向的尾节点的数据域

综上,该部分代码如下:

QDatatype QueueBack(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;

}

11.链队列的销毁

 链队列的销毁思路:

  • 从头遍历队列的元素,逐一释放链队列中的结点
  • 释放完将队头指针和队尾指针置为NULL,将队列长度size置为0.

 综上,该部分代码如下:

void QueueDestroy(Que* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;

}

四.项目完整代码

我们将程序运行的代码分别在三个工程文件中编辑,完整代码如下:

test.c文件

#include"Queue.h"
	//因为链队列头指针是必须的
	//而在队尾插入则尾指针同样也是必须的
	//因此我们不妨设置两个指针,一个记录队头,一个记录队尾
	//为方便起见,多个数据我们把头指针和尾指针再封装一个结构体

	//单链表不设置尾指针的原因是它不能解决尾删问题

    int main()
    {
        Que Q;//初始化
        QueueInit(&Q);

        int swi = 0;//创建变量swi作为do...while循环的终止条件,以及switch语句的运行条件
        do          //使用do...while实现
        {

            QMenu();
            scanf("%d", &swi);

            switch (swi)
            {
            case 0:
                // 释放队列内存
                QueueDestroy(&Q);
            
                printf("您已退出程序:>\n");

                break;

            case 1:
                printf("请输入要入队的数据:>");
                QDatatype pushback_data = 0;
                scanf("%d", &pushback_data);

                QueuePush(&Q, pushback_data);

                printf("已成功入队:>\n");
                break;

            case 2:
                QueuePop(&Q);
                printf("出队成功:>\n");

                break;

            case 3:
                printf("队首元素为:");
                QDatatype e = QueueFront(&Q);
                printf("%d\n", e);
                break;

            case 4:
                printf("队尾元素为:");
                QDatatype n = QueueBack(&Q);
                printf("%d\n", n);
               
                break;

            case 5:
                if (!QueueEmpty(&Q))
                {
                    printf("当前队列不为空:>\n");
                }
                else
                {
                    printf("当前队列为空\n");
                }
                break;

            case 6:
               printf("当前队列长度为:");
               int size= QueueSize(&Q);
               printf("%d\n", size);
                break;

            case 7:
                QueueDestroy(&Q);
                QueueInit(&Q);
                printf("队列已清空:>\n");
                break;

            default:
                printf("输入错误,请重新输入\n");
                break;
            }
        } while (swi);

        return 0;
    }

 Queue.c 文件

#include"Queue.h"

void QueueInit(Que* pq)
{
	assert(pq);

	pq->head = pq->tail = NULL;
	pq->size = 0;

}
void QueueDestroy(Que* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;

}

void QueuePush(Que* pq, QDatatype x) //入队是尾插
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;

	if (pq->head == NULL)//头插
	{
		assert(pq->tail == NULL);//head为空,tail不为空就出事了,队头为空但是队尾不为空
		
		pq->head = pq->tail = newnode;
		
	}
	else//尾插
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;

}


void QueuePop(Que* pq)//出队是头删
{
	assert(pq);
	assert(pq->head!=NULL);//***

	QNode* cur = pq;

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}

	pq->size--;

}

int QueueSize(Que* pq)
{
	assert(pq);

	return pq->size;

}

bool QueueEmpty(Que* pq)//判空!为空返回真!
{
	assert(pq);

	return pq->size==0;
}

QDatatype QueueFront(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;

}
QDatatype QueueBack(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;

}

void QMenu()
{
	printf("**********************************\n");
	printf("******请选择要进行的操作    ******\n");
	printf("******1.链队列入队          ******\n");
	printf("******2.链队列出队          ******\n");
	printf("******3.取队首元素          ******\n");
	printf("******4.取队尾元素          ******\n");
	printf("******5.队列判空            ******\n");
	printf("******6.查询当前队列长      ******\n");
	printf("******7.清空队列            ******\n");
	printf("******0.退出链队列程序      ******\n");
	printf("**********************************\n");
	printf("请选择:>");

}

Queue.h文件

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1

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

typedef int QDatatype;

typedef struct QueueNode//一个是结点结构
{
	struct QueueNode* next;
	QDatatype data;
}QNode;


typedef struct Queue//一个是队列整体结构
{
	QNode* head;
	QNode* tail;
	int size ;
}Que;

void QueueInit(Que* pq);
void QueueDestroy(Que* pq);

void QueuePush(Que* pq,QDatatype x);
void QueuePop(Que* pq);

int QueueSize(Que* pq);

bool QueueEmpty(Que* pq);

QDatatype QueueFront(Que* pq);
QDatatype QueueBack(Que* pq);

void QMenu();

结语

希望这篇链队列的实现详解能对大家有所帮助,欢迎大佬们留言或私信与我交流.

学海漫浩浩,我亦苦作舟!关注我,大家一起学习,一起进步!

相关文章推荐

【数据结构】什么是线性表?

【数据结构】线性表的链式存储结构

【数据结构】C语言实现顺序表万字详解(附完整运行代码)

【数据结构】C语言实现单链表万字详解(附完整运行代码)

【数据结构】C语言实现带头双向循环链表万字详解(附完整运行代码)

【数据结构】什么是栈?

【数据结构】用C语言实现顺序栈(附完整运行代码)

数据结构栈与队列篇思维导图:

修修修也
关注
  • 23
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
链式的队列的创建、插入、删除、遍历、取队首元素
Zhang_Yi_Lan的博客
10-24 8964
链式的队列的创建、插入、删除、遍历、取队首元素上午操作。 我们今天将的方式是比较简单的方式，没有动态的分配空间。#include <stdio.h> typedef struct { int queue[100]; int front; int rear; } sqqueue; //创建一个空的队列 int initqueue(sqqueue *sq) { if(s
数据结构(C语言版)[严蔚敏]
04-27
光盘内容可在DOS环境下运行的以类C语言描述的“数据结构算法动态模拟辅助教学软件，以及在Windows环境下运行的以类PASCAL或类C两种语言描述的“数据结构算法动态模拟辅助教学软件”。 目录: 第1章 绪论 1.1 什么...
队列-队列-单链队列-带有头尾指针-内容请看代码
weixin_63543552的博客
11-26 76
【代码】队列-队列-单链队列-带有头尾指针。
LinkedList正确的遍历方式-附源码分析
泗水长流的博客
02-21 1714
LinkedList实现了List接口、Deque接口、Cloneable接口、Serializable接口，同时继承了AbstractSequentialList抽象类。通过实现Deque接口，使其具有了Queue队列类型的特点，通过实现Cloneable、Serializable接口，可以实现克隆和序列化。通过它的继承与实现类我们看到，与ArrayList相比，它并没有实现RandomAccess随机访问接口，在一定程度上说明了它不具备随机访问的特性。
数据结构学习——链式队列的创建和使用
weixin_63586719的博客
07-31 752
队列是一种常见的数据结构，它遵循先进先出（First-In-First-Out, FIFO）的原则，在队列的操作中入队从队列的尾部插入，出队的时候释放队列的头节点并且更新新的头节点。队列的存储方式主要有两种，分别是链式存储和顺序存储。每种存储方式都有其特点和适用场景。链式存储适合频繁进行插入和删除操作的队列，而顺序存储则适合频繁进行访问操作的队列。选择适当的存储方式要根据具体的应用需求和性能要求来决定。本篇主要介绍链式存储。
数据结构-链队列的基本操作代码实现
weixin_52144018的博客
01-07 833
#include <iostream> using namespace std; typedef int ElemType; typedef struct QNode { ElemType data; struct QNode* next; }QNode,*QueuePtr; typedef struct { QueuePtr front; QueuePtr rear; }LinkQueue; bool InitQueue(LinkQueue& Q);//初始化链队列 bo.
【数据结构】C语言实现堆(附完整运行代码)
C/C++领域,数据结构,linux,MySQl学习者
12-11 1104
使用C语言实现堆程序新手入门详解,包括堆程序每个函数的设计思路及逻辑图示物理图示,简洁明了,直观易懂,文末附程序运行完整代码.
链队列基本操作的C语言代码实现
m0_73171073的博客
10-11 2023
【代码】链队列基本操作的C语言代码实现。
用C语言实现链队列的基本操作
2301_80002696的博客
12-13 606
不多解释，直接上代码，代码已经写了注释！有不懂的欢迎随时提问！
数据结构:链队列的基本操作(C语言实现)
weixin_57425841的博客
04-06 4505
链队列是用链表作为存储结构的队列。队列的特点是先入先出，后入后出。这里采用带头结点的链表结构，并设置一个头指针front和一个尾指针rear始终指向头节点和队尾结点。 #include<stdio.h> #include<stdlib.h> typedef struct Node /*定义队列结点结构*/ { int data; /*数据域*/ struct Node *next; /*指针域*/ }LinkQueueNode; typede
严蔚敏版《数据结构》代码实现
01-13
这些代码主要是针对严蔚敏老师的《数据结构》一书中的大部分伪代码编辑的代码，能够正常运行，是基于C++编写的代码，包括，数组线性表，链表线性表、双向链表、顺序栈、链栈、链队列，顺序队列，循环队列、KMP算法、...
数据结构C语言回文判断(运用栈以及队列完成).doc
09-25
数据结构C语言回文判断（运用栈以及队列完成） 一、实验目的 通过本实验，旨在熟悉栈和队列的各项操作，区别栈和队列的操作原理，并学习如何使用栈和队列来判断回文序列。 二、实验内容 本实验的主要内容是使用...
数据结构c语言版期末考试复习试题
06-14
以下是对数据结构C语言版期末考试复习题目的详细解释： 1. 数据结构的分类：题目中提到的选择题第一题，数据结构通常被分为线性结构和非线性结构。线性结构如数组、链表、栈和队列，其中元素之间存在一对一的关系；...
《数据结构》（C语言版）严蔚敏
08-31
光盘内容可在DOS环境下运行的以类C语言描述的“数据结构算法动态模拟辅助教学软件，以及在Windows环境下运行的以类PASCAL或类C两种语言描述的“数据结构算法动态模拟辅助教学软件”。内附 数据结构算法实现（严蔚敏...
数据结构-绪论
pyc68的博客
06-17 791
本篇文章先介绍数据结构的研究内容，然后再介绍如何去理解数据结构，着重介绍表示数据结构关系的逻辑结构和存储结构（物理结构）。
数据结构8---查找
2303_79741845的博客
06-23 555
静态查找:数据集合稳定，不需要添加,删除元素的查找操作。对于静态查找来说，我们不妨可以用线性表结构组织数据，这样可以使用顺序查找算法，如果我们再对关键字进行排序，则可以使用折半查找算法或斐波那契查找算法等来提高查找的效率。
【数据结构】顺序表
最新发布
2401_82759674的博客
06-23 366
顺序表是一种线性表，在逻辑结构上是线性的，在物理结构上同样也是线性的，也就是说顺序表会使用一块连续的空间进行数据的存储，基本上以数组形式表示。顺序表中数据是连续存储，我们就可以使用下标来进行访问，访问元素更迅速。在顺序表功能实现中，头插头删，pos位置插入删除比较复杂，会对其他数据产生影响，需要关注操作细节。顺序表优点是访问便捷，但是缺点有很多，就在那几个问题中，这些缺点导致需要频繁中间插入删除数据时效率较慢。！！
c语言编程链队列基本操作完整代码
05-22
链队列是一种基于链表实现的队列，其特点是插入和删除的时间复杂度为O(1)，且不会出现队满的情况。以下是C语言链队列的基本操作完整代码： ```c #include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct Node *next; } Node; typedef struct { Node *front; Node *rear; } Queue; // 初始化队列 void initQueue(Queue *q) { q->front = q->rear = NULL; } // 判断队列是否为空 int isQueueEmpty(Queue *q) { return q->front == NULL; } // 入队操作 void enQueue(Queue *q, int data) { Node *newNode = (Node *)malloc(sizeof(Node)); newNode->data = data; newNode->next = NULL; if (isQueueEmpty(q)) { q->front = q->rear = newNode; } else { q->rear->next = newNode; q->rear = newNode; } } // 出队操作 int deQueue(Queue *q) { if (isQueueEmpty(q)) { printf("Queue is empty.\n"); return -1; } else { int data = q->front->data; Node *temp = q->front; q->front = q->front->next; free(temp); if (q->front == NULL) { q->rear = NULL; } return data; } } // 打印队列中的元素 void printQueue(Queue *q) { if (isQueueEmpty(q)) { printf("Queue is empty.\n"); } else { printf("Queue elements: "); Node *temp = q->front; while (temp != NULL) { printf("%d ", temp->data); temp = temp->next; } printf("\n"); } } int main() { Queue q; initQueue(&q); enQueue(&q, 1); enQueue(&q, 2); enQueue(&q, 3); enQueue(&q, 4); enQueue(&q, 5); printQueue(&q); deQueue(&q); deQueue(&q); printQueue(&q); return 0; } ``` 以上代码中，我们定义了一个链表节点Node和一个队列Queue。其中，Node包含了一个整型数据data和一个指向下一个节点的指针next；Queue包含了队列的头部指针front和尾部指针rear。在初始化队列时，我们将头部和尾部指针都指向NULL；在入队操作时，我们新建一个节点，并将其加入到队列的尾部；在出队操作时，我们将头部节点出队，并将头部指针指向下一个节点。最后，我们可以通过printQueue函数打印队列中的元素。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

修修修也

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

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

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

打赏作者

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

抵扣说明：

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

余额充值