数据结构：队列——队列的概念、顺序和链式存储的实现

已于 2022-07-29 17:34:54 修改
阅读量936 收藏 8
点赞数 4
分类专栏： 数据结构(C版) 文章标签： 数据结构 算法 c语言
于 2022-07-27 16:32:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46629453/article/details/125956562
版权

队列

基本概念

  1. 队列定义：
    队列也是一种受限的线性表，只允许一端插入，另一端删除
    在这里插入图片描述

  2. 基本操作

    void InitQueue(SqQueue &Q)  			初始化队列
bool QueueEmpty(SqQueue Q)				判断队空
bool EnQueue(SqQueue &Q,ElemType e)		入队
bool DnQueue(SqQueue &Q,ElemType &e)	出队
bool GetHead(SqQueue Q,ElemType &e)		读队头元素

  3. 顺序队列和循环队列

    1. 顺序队列
      下图表示队列的初始化、入队、出队，可以看出
      队初始化：front=rear=0
队空：front==0&&rear==0
      那么队满呢？
      假设rear=maxsize表示队满，当有元素出栈时，rear仍=maxsize，但此时队列是满的，所以rear==maxsize不能作为队满的条件
      在这里插入图片描述
      那么，用rear-front==maxsize 呢？当有元素出队而队中仍有元素时，队尾指针已经到达队末尾，不会有元素能进入队中，队不会满。
      在这里插入图片描述
    2. 循环队列
      由于顺序队列的不足，因此引出循环队列的概念将顺序队列臆造为一个环状的空间。如图：
      在这里插入图片描述

队列的顺序存储（循环队列）

牺牲一个单元来区分队空和队满

入队

  1. 图解
    请添加图片描述

  2. 代码

    /*入队*/
bool EnQueue(SqQueue &Q,ElemType e){
    if(QueueFull(Q))return false;
    Q.data[Q.rear]=e;
    Q.rear=(Q.rear+1)%MaxSize;
    return true;
}

出队

  1. 图解
    请添加图片描述

  2. 代码

    /*出队*/
bool DnQueue(SqQueue &Q,ElemType &e){
    if(QueueEmpty(Q))return false;
    e=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;
    return true;
}

栈空和栈满理解

队空：front==rear
队满：(rear+1)%maxsize==front

以下两种情况都属于栈满，该方法需要牺牲掉一个空间来区分栈空和栈满,这个空间并不是指特定的，只是在队头和队尾之间留一个空。
在这里插入图片描述

完整代码

#include "stdio.h"
#include "stdlib.h"

#define MaxSize 50

typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];     //存放元素
    int front,rear;             //队头指针和队尾指针
}SqQueue;

/*初始化队列*/
void InitQueue(SqQueue &Q){
    Q.front=Q.rear=0;
}
/*判断队空*/
bool QueueEmpty(SqQueue Q){
    if (Q.rear==Q.front)return true;
    else return false;
}

/*判断队满*/
bool QueueFull(SqQueue Q){
    if ((Q.rear+1)%MaxSize==Q.front)return true;
    else return false;
}

/*入队*/
bool EnQueue(SqQueue &Q,ElemType e){
    if(QueueFull(Q))return false;
    Q.data[Q.rear]=e;
    Q.rear=(Q.rear+1)%MaxSize;
    return true;
}

/*出队*/
bool DnQueue(SqQueue &Q,ElemType &e){
    if(QueueEmpty(Q))return false;
    e=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;
    return true;
}

/*读队头元素*/
bool GetHead(SqQueue Q,ElemType &e){
    if(QueueEmpty(Q))return false;
    e=Q.data[Q.front];
    return true;
}

/*队长*/
int Length(SqQueue Q){
    return (Q.rear-Q.front+MaxSize)%MaxSize;
}

/*遍历*/
void Proint(SqQueue Q){
    for (int i = Q.front; i < Q.rear; ++i) {       
        printf("%d  ",Q.data[i]);
    }
    printf("\n");
}

int main(){
    SqQueue Q;

    printf("***************************************\n");
    printf("********  1.初始化队  2.空队判断  ********\n");
    printf("********  3. 进 队   4. 出 队   ********\n");
    printf("********  5.读取队首  6.队满判断  ********\n");
    printf("********  7. 遍 历   8. 队 长   ********\n");
    printf("********  0. 退 出             ********\n");
    printf("***************************************\n");

    bool flag= true;
    int x;
    ElemType e;
    while(flag){
        printf("请输入命令：");
        scanf("%d",&x);
        switch (x) {
            case 1:
                InitQueue(Q);
                printf("\t空队初始化完成\n");
                break;
            case 2:
                if(QueueEmpty(Q)) printf("\t该队是空队\n");
                else printf("\t该队不是空队\n");
                break;
            case 3:
                printf("\t请输入要进队的元素：");
                int a;
                scanf("%d",&e);
                if(EnQueue(Q,e))printf("\t元素入队成功\n");
                else printf("\t元素入队失败\n");
                break;
            case 4:
                if(DnQueue(Q,e))
                    printf("\t元素出队成功,出队的元素为：%d\n",e);
                else
                    printf("\t元素出队失败\n");
                break;
            case 5:
                if(GetHead(Q,e))
                    printf("\t队首元素为：%d\n",e);
                else
                    printf("\t该队为空栈\n");
                break;
            case 6:
                if(QueueFull(Q))
                    printf("\t该队已满\n");
                else
                    printf("\t该队还未满\n");
                break;
            case 7:
                printf("\t当前队中元素有：");
                Proint(Q);
                break;
            case 8:
                printf("\t当前队长为：%d\n",Length(Q));
                break;
            case 0:
                printf("退出成功\n");
                flag= false;
                break;
            default:
                printf("命令错误，请重新输入！！！");
                break;
        }
    }
}

运行截图

在这里插入图片描述

增设size表示元素个数的数据成员

栈空和栈满理解

typedef struct {
  ElemType data[MaxSize]; //存放元素
  int front,rear; //队头指针和队尾指针
  int size;//表示队中成员个数
}SqQueue;

队空：size=0
队满：size=maxsize
在这里插入图片描述

完整代码

#include "stdio.h"
#include "stdlib.h"

#define MaxSize 50

typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];     //存放元素
    int front,rear;             //队头指针和队尾指针
    int size;
}SqQueue;

/*初始化队列*/
void InitQueue(SqQueue &Q){
    Q.front=Q.rear=0;
    Q.size=0;
}
/*判断队空*/
bool QueueEmpty(SqQueue Q){
    if (Q.size==0)return true;
    else return false;
}

/*判断队满*/
bool QueueFull(SqQueue Q){
    if (Q.size==MaxSize)return true;
    else return false;
}

/*入队*/
bool EnQueue(SqQueue &Q,ElemType e){
    if(QueueFull(Q))return false;
    Q.data[Q.rear]=e;
    Q.rear=(Q.rear+1)%MaxSize;
    Q.size++;
    return true;
}

/*出队*/
bool DnQueue(SqQueue &Q,ElemType &e){
    if(QueueEmpty(Q))return false;
    e=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;
    Q.size--;
    return true;
}

/*读队头元素*/
bool GetHead(SqQueue Q,ElemType &e){
    if(QueueEmpty(Q))return false;
    e=Q.data[Q.front];
    return true;
}

/*队长*/
int Length(SqQueue Q){
    return Q.size;
}

/*遍历*/
void Proint(SqQueue Q){
    for (int i = Q.front; i < Q.rear; ++i) {       
        printf("%d  ",Q.data[i]);
    }
    printf("\n");
}

int main(){
    SqQueue Q;

    printf("***************************************\n");
    printf("********  1.初始化队  2.空队判断  ********\n");
    printf("********  3. 进 队   4. 出 队   ********\n");
    printf("********  5.读取队首  6.队满判断  ********\n");
    printf("********  7. 遍 历   8. 队 长   ********\n");
    printf("********  0. 退 出             ********\n");
    printf("***************************************\n");

    bool flag= true;
    int x;
    ElemType e;
    while(flag){
        printf("请输入命令：");
        scanf("%d",&x);
        switch (x) {
            case 1:
                InitQueue(Q);
                printf("\t空队初始化完成\n");
                break;
            case 2:
                if(QueueEmpty(Q)) printf("\t该队是空队\n");
                else printf("\t该队不是空队\n");
                break;
            case 3:
                printf("\t请输入要进队的元素：");
                int a;
                scanf("%d",&e);
                if(EnQueue(Q,e))printf("\t元素入队成功\n");
                else printf("\t元素入队失败\n");
                break;
            case 4:
                if(DnQueue(Q,e))
                    printf("\t元素出队成功,出队的元素为：%d\n",e);
                else
                    printf("\t元素出队失败\n");
                break;
            case 5:
                if(GetHead(Q,e))
                    printf("\t队首元素为：%d\n",e);
                else
                    printf("\t该队为空栈\n");
                break;
            case 6:
                if(QueueFull(Q))
                    printf("\t该队已满\n");
                else
                    printf("\t该队还未满\n");
                break;
            case 7:
                printf("\t当前队中元素有：");
                Proint(Q);
                break;
            case 8:
                printf("\t当前队长为：%d\n",Length(Q));
                break;
            case 0:
                printf("退出成功\n");
                flag= false;
                break;
            default:
                printf("命令错误，请重新输入！！！");
                break;
        }
    }
}

运行截图

在这里插入图片描述

增设tag数据成员

栈空和栈满理解

typedef struct {
  ElemType data[MaxSize]; //存放元素
  int front,rear; //队头指针和队尾指针
  int tag;//用0、1来表示
}SqQueue;

队空：rear == front&&tag == 0
队满：rear == front&&tag == 1
在这里插入图片描述

完整代码

#include "stdio.h"
#include "stdlib.h"

#define MaxSize 50

typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];     //存放元素
    int front,rear;             //队头指针和队尾指针
    int tag;
}SqQueue;

/*初始化队列*/
void InitQueue(SqQueue &Q){
    Q.front=Q.rear=0;
    Q.tag=0;
}
/*判断队空*/
bool QueueEmpty(SqQueue Q){
    if (Q.rear==Q.front&&Q.tag==0)return true;
    else return false;
}

/*判断队满*/
bool QueueFull(SqQueue Q){
    if (Q.rear==Q.front&&Q.tag==1)return true;
    else return false;
}

/*入队*/
bool EnQueue(SqQueue &Q,ElemType e){
    if(QueueFull(Q))return false;
    Q.data[Q.rear]=e;
    Q.rear=(Q.rear+1)%MaxSize;
    Q.tag=1;
    return true;
}

/*出队*/
bool DnQueue(SqQueue &Q,ElemType &e){
    if(QueueEmpty(Q))return false;
    e=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;
    Q.tag=0;
    return true;
}

/*读队头元素*/
bool GetHead(SqQueue Q,ElemType &e){
    if(QueueEmpty(Q))return false;
    e=Q.data[Q.front];
    return true;
}

/*队长*/
int Length(SqQueue Q){
    return (Q.rear-Q.front+MaxSize)%MaxSize;
}

/*遍历*/
void Proint(SqQueue Q){
    for (int i = Q.front; i < Q.rear; ++i) {       
        printf("%d  ",Q.data[i]);
    }
    printf("\n");
}

int main(){
    SqQueue Q;

    printf("***************************************\n");
    printf("********  1.初始化队  2.空队判断  ********\n");
    printf("********  3. 进 队   4. 出 队   ********\n");
    printf("********  5.读取队首  6.队满判断  ********\n");
    printf("********  7. 遍 历   8. 队 长   ********\n");
    printf("********  0. 退 出             ********\n");
    printf("***************************************\n");

    bool flag= true;
    int x;
    ElemType e;
    while(flag){
        printf("请输入命令：");
        scanf("%d",&x);
        switch (x) {
            case 1:
                InitQueue(Q);
                printf("\t空队初始化完成\n");
                break;
            case 2:
                if(QueueEmpty(Q)) printf("\t该队是空队\n");
                else printf("\t该队不是空队\n");
                break;
            case 3:
                printf("\t请输入要进队的元素：");
                int a;
                scanf("%d",&e);
                if(EnQueue(Q,e))printf("\t元素入队成功\n");
                else printf("\t元素入队失败\n");
                break;
            case 4:
                if(DnQueue(Q,e))
                    printf("\t元素出队成功,出队的元素为：%d\n",e);
                else
                    printf("\t元素出队失败\n");
                break;
            case 5:
                if(GetHead(Q,e))
                    printf("\t队首元素为：%d\n",e);
                else
                    printf("\t该队为空栈\n");
                break;
            case 6:
                if(QueueFull(Q))
                    printf("\t该队已满\n");
                else
                    printf("\t该队还未满\n");
                break;
            case 7:
                printf("\t当前队中元素有：");
                Proint(Q);
                break;
            case 8:
                printf("\t当前队长为：%d\n",Length(Q));
                break;
            case 0:
                printf("退出成功\n");
                flag= false;
                break;
            default:
                printf("命令错误，请重新输入！！！");
                break;
        }
    }
}

运行截图

在这里插入图片描述

队列的链式存储

队列的链式存储，类似于单链表，入队——头插法，出队——删除首元结点。
假如程序中要使用多个队列，与多个栈的情形一样，最好使用链式队列。这样就不会出现存储分配不合理和“溢出”现象

队列的存储类型（比较特殊）

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

typedef struct {
    LinkNode *front,*rear;
}liQueue;

完整代码

#include "stdio.h"
#include "stdlib.h"

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

typedef struct {
    LinkNode *front,*rear;
}liQueue;

/*初始化队列*/
void InitQueue(liQueue &Q){
   Q.rear=Q.front=(LinkNode*) malloc(sizeof(LinkNode));
   Q.front->next=NULL;
}
/*判断队空*/
bool QueueEmpty(liQueue Q){
    if (Q.rear==Q.front)return true;
    else return false;
}


/*入队*/
bool EnQueue(liQueue &Q,ElemType e){
    LinkNode *s=(LinkNode*) malloc(sizeof(LinkNode));
    s->data=e;
    s->next=NULL;
    Q.rear->next=s;
    Q.rear=s;
    return true;
}

/*出队*/
bool DnQueue(liQueue &Q,ElemType &e){
    if (QueueEmpty(Q))return false;
    LinkNode *p=Q.front->next;
    e=p->data;
    Q.front->next=p->next;
    if (Q.rear==p)
        Q.rear==Q.front;
    free(p);
    return true;
}

/*读队头元素*/
bool GetHead(liQueue Q,ElemType &e){
    if (QueueEmpty(Q))return false;
    e=Q.front->next->data;
    return true;
}

/*队长*/
int Length(liQueue Q){
    int i=0;
    LinkNode *p=Q.front->next;
    if (p!=Q.rear){
        p=p->next;
        i++;
    }
    return ++i;
}

/*遍历*/
void Proint(liQueue Q){
    LinkNode *p=Q.front->next;
    while (p!=NULL){
        printf("%d  ",p->data);
        p=p->next;
    }
    printf("\n");
}

int main(){
    liQueue Q;

    printf("***************************************\n");
    printf("********  1.初始化队  2.空队判断  ********\n");
    printf("********  3. 进 队   4. 出 队   ********\n");
    printf("********  5.读取队首  6. 队 长  ********\n");
    printf("********  7. 遍 历   0. 退 出   ********\n");
    printf("***************************************\n");

    bool flag= true;
    int x;
    ElemType e;
    while(flag){
        printf("请输入命令：");
        scanf("%d",&x);
        switch (x) {
            case 1:
                InitQueue(Q);
                printf("\t空队初始化完成\n");
                break;
            case 2:
                if(QueueEmpty(Q)) printf("\t该队是空队\n");
                else printf("\t该队不是空队\n");
                break;
            case 3:
                printf("\t请输入要进队的元素：");
                int a;
                scanf("%d",&e);
                if(EnQueue(Q,e))printf("\t元素入队成功\n");
                else printf("\t元素入队失败\n");
                break;
            case 4:
                if(DnQueue(Q,e))
                    printf("\t元素出队成功,出队的元素为：%d\n",e);
                else
                    printf("\t元素出队失败\n");
                break;
            case 5:
                if(GetHead(Q,e))
                    printf("\t队首元素为：%d\n",e);
                else
                    printf("\t该队为空栈\n");
                break;
            case 6:
                printf("\t当前队长为：%d\n",Length(Q));
                break;
                break;
            case 7:
                printf("\t当前队中元素有：");
                Proint(Q);
                break;
            case 0:
                printf("退出成功\n");
                flag= false;
                break;
            default:
                printf("命令错误，请重新输入！！！");
                break;
        }
    }
}

运行截图

在这里插入图片描述

参考资料

《王道：数据结构考研复习指导》

仔仔木
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
队列概述及存储结构（顺序存储，链式存储，循环队列）代码实现
weixin_43800761的博客
07-13 4934
一、队列的基本概念 1.1 队列的定义   队列(Queue) 简称队，也是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。向队列中插入元素称为入队或进队。删除元素称为出队或离队。这和我们日常生活中的排队是一致的，最早排队的也是最早离队的，其操 作的特性是先进先出(First In First Out, FIFO)，如： 队头(Front)： 允许删除的一-端，又称队首。 队尾(Rear)。： 允许插入的一-端。 空队列： 不含任何元素的空表。 1.2 队列常见的基本操作 Init
数据结构第三章汇总
cwb296的博客
05-16 1415
栈与队列相关的知识点
链式存储结构实现队列的入队和出队操作以及 栈的出栈和入栈操作
wtm
07-22 2万+
链式存储结构实现队列的入队和出队操作以及 栈的出栈和入栈操作其实本质上就是用含头结点的单链表来模拟队列的入队和出队，以及栈的入栈和出栈 换句话来形容，用单链表来实现队列和栈 对于队列： 存储结构 typedef struct QueueNode//队列结点 { int data; QueueNode *next; }QueueNode; typedef struct
队列的存储方式
Summer_Jack的博客
10-16 658
队列的顺序存储结构： #include<stdio.h> #define ElemType int #define MAXSIZE 5 typedef struct Node { ElemType* base; int front; int rear; }QueueLink; QueueLink* Init(QueueLink* q) { q->base = new ElemType[MAXSIZE]; q->front = q->rear = 0; re.
课堂实验5 栈和队列
weixin_50849959的博客
10-29 959
1:第三章基础实验1.1 查看提交统计提问 总时间限制: 1000ms 内存限制: 2000kB 描述 设计字符顺序栈的基本运算程序，并用相关数据测试。 void InitStack(SqStack &st)//初始化顺序栈st void DestroyStack(SqStack st)//销毁顺序栈st int Push(SqStack &st,ElemType x)//进栈元素x int Pop(SqStack &st,ElemType &x)//出栈元素x int Ge
第三章 栈和队列 顺序存储结构和链式存储结构
04-20
本章将深入探讨两种重要的数据结构——栈和队列，以及它们的两种常见存储方式：顺序存储结构和链式存储结构。 栈（Stack）被称为“后进先出”（Last In, First Out，简称LIFO）的数据结构。栈的操作主要围绕两个...
作业 第三章 栈和队列 顺序存储结构和链式存储结构
最新发布
04-20
本章主要探讨的是两种常用且基础的数据结构——栈（Stack）和队列（Queue），以及它们的两种基本存储方式：顺序存储结构（Sequential Storage Structure）和链式存储结构（Linked Storage Structure）。我们将深入...
数据结构——堆栈和队列
02-06
总的来说，这个压缩包提供了关于数据结构——堆栈和队列的C语言实现，以及额外的数字转换和字符串处理功能。这些基础知识对于理解和编写高效的计算机程序至关重要。通过学习和理解这些内容，开发者能够更好地解决...
数据结构入门——队列的实现.rar
04-02
在这个"数据结构入门——队列的实现.rar"的压缩包中，我们主要关注的是队列这一基础但重要的数据结构。队列，正如其名，模拟了现实生活中的排队现象，遵循“先进先出”（FIFO, First In First Out）原则。这意味着最...
数据结构：第3章栈和队列C.ppt
06-12
本章主要探讨两种常用的数据结构——栈（Stack）和队列（Queue），它们在计算机程序设计中有着广泛的应用。 栈是一种后进先出（Last In First Out, LIFO）的数据结构，类似于日常生活中的叠盘子。在栈中，数据的...
队列的链表存储结构及实现(建立，入队一个元素，出队一个元素)
04-10
队列的链表存储结构及实现: 1 建立链表队列 2 入队一个元素 3 出队一个元素 4 结束程序运行
数据结构— —队列(顺序表实现)
m0_65635427的博客
11-04 2142
数据结构队列顺序实现
数据结构——链队列的初始化、入队、出队、销毁队列
TSY_1222的博客
10-08 9222
目录： 1、构造空队列 2、链队列基本操作——入队 3、链队列的基本操作——出队 4、销毁队列 队列是先进先出的线性表。它只允许在表的一端进行插入，而在另一端删除元素。 在队列中，允许插入的一端叫做队尾，允许删除的一端叫做对头。 队列的示意图： 栈和队列都是限制存取点的线性结构。 用链表表示...
数据结构我好爱：05链式队列
qq_60678811的博客
05-16 207
队列完全可以就直接拿个一维数组就直接可以啦！！！ 所以队列很简单，链式也一样，总之你最后会发现这TM不就一个单链表加点东西嘛！ 首先回忆，单链表有两种插入方法：头插法和尾插法 好的链式队列就基本结束了。 所以我就着重讲讲多了什么“东西”： typedef struct { NodePtr front, rear; }LinkQue, * LinkQuePtr; ...
数据结构上机实践第七周项目1 - 自建算法库——顺序环形队列
hou8389846的博客
12-25 597
自建算法库——顺序环形队列 本次实践将建立顺序环形队列的算法库，用于之后的工程中 实现源代码如下： 1.squeue.h [cpp] view plain copy       *问题描述：定义顺序环形队列存储结构，实现其基本运算，并完成测试。         要求：         1、头文件sqqueue.h中定义数据结构
数据结构｜队列
weixin_53937982的博客
04-17 1682
队列知识框图考点分析1、什么样的链表适合作为链队？2、判空判满知识框图 知识框图 考点分析 1、什么样的链表适合作为链队？ 2、判空判满 知识框图
第 3 章：稀疏数组和队列
Oneby的博客
07-25 4972
第 3 章：稀疏数组和队列 1、稀疏数组 1.1、实际需求 编写的五子棋程序中，有存盘退出和续上盘的功能 因为该二维数组的很多值是默认值 0 ，因此记录了很多没有意义的数据，我们将其转为稀疏数组进行存储 1.2、稀疏数组应用 1.2.1、稀疏数组处理方法 稀疏数组把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模 稀疏数组也是二维数组，行数由原数组的数据决定，列数一般为 3 列 稀疏数组的第一行记录原数组一共有几行几列，有多少个不为零的值 第一列：原数组的行数 第二列：原数组
队列相关习题及详解(选择题和综合题) ——数据结构
热门推荐
Amour
10-31 3万+
队列的基本概念队列的定义队列（Queue）：队列简称队，也是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。向队列中插入元素称为入队或进队；删除元素称为出队或离队。这和我们日常生活中的排队是一致的，最早排队的也是最早离队的。其操作的特性是先进先出（First In First Out, FIFO），故又称为先进先出的线性表。队头（Front）：允许删除的一端，又称为首队 队
使用 tag 文件定义自定义标签
du_minchao的专栏
04-04 1万+
1. 使用 tag 文件定义自定义标签. 1). 可以使用 tag 文件的方式来定义自定义标签. 先前使用过标签处理器类（SimpleTagSupport）来定义自定义标签.  2). 不能直接访问这个 Tag 文件 3). tag 文件是扩展名必须为 tag 4). tag 文件的结构几乎和 JSP 文件相同:  一个 Tag 文件中可以有普通的 HTML 标记符、某些特殊的指令标记、

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值