【初阶数据结构】——限定性线性表：栈 和 队列详解（C描述）

举报
YIN_尹 发表于 2023/08/12 09:10:01 2023/08/12
【摘要】 前言这篇文章我们继续线性表的学习，今天我们要学习两种特殊的线性表——限定性线性表，通俗点说，就是操作受限制的线性表。也是非常常用的两种数据结构：栈和队列！1. 栈首先我们来学习栈。1.1 栈的概念及结构首先我们来了解一下什么是栈：栈（stack）又名堆栈，它是一种运算受限的线性表。其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素...

前言

这篇文章我们继续线性表的学习，今天我们要学习两种特殊的线性表——限定性线性表，通俗点说，就是操作受限制的线性表。

也是非常常用的两种数据结构：栈和队列！

1. 栈

首先我们来学习栈。

1.1 栈的概念及结构

首先我们来了解一下什么是栈：

栈（stack）又名堆栈，它是一种运算受限的线性表。

其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

也可以说是先进后出。

向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素。

从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

即入数据和出数据都在栈顶。

e939d7f0ec82452ca9a7f5dac4bf6100.png

96de7aa004b6401b8bfe7621d43b29df.png

1.2栈的实现

了解了什么是栈以及栈的性质，接下来我们就来上手实现一个栈。

那要怎么实现呢？

我们之前已经学了两种线性表：链表和顺序表（数组）。

我们说栈和队列是操作受限制的线性表。

因此，栈的实现可以使用数组实现，也可以使用链表实现。

那选择哪一种方式更好呢？

相对而言数组的结构实现更优一些。因为数组在尾上插入删除数据的代价比较小。

下面，我们就用数组来实现一个栈。

1.2.1 动态or静态

和顺序表一样，我们选择数组来实现，可以实现成静态的（即数组的大小是固定的）栈：

typedef int STDataType;
#define N 10
typedef struct Stack
{
    STDataType _a[N];
    int _top; // 栈顶
}Stack;

也可以选择实现成动态的栈，还是用数组，只不过我们使用动态开辟的数组，这样的话一开始我们不用给太多空间，如果不够用我们可以进行扩容。

那我们选择那种呢？

定长的静态栈的结构，实际中一般不实用，所以我们下面主要实现的支持动态增长的栈。

1.2.2 结构介绍

动态栈的结构是什么样子的？

起始和顺序表差不多，因为我们这里本身就是选择用顺序表来实现栈的。

typedef int STDataType;
typedef struct Stack
{
    STDataType* arr;//指向动态开辟的数组
    
    int top;//top为0，表示指向栈顶元素的下一个，也是元素个数
            //top为-1，指向栈顶元素
            
    int capacity;//容量
}ST;

简单解释一下：

首先我们还是把栈定义成了一个结构体，因为它不仅仅是一个简单的数组，还有一些其它的属性，所以我们放在了一个结构体中。

因为栈入数据和出数据都是在栈顶进行操作，所以我们定义了一个top来标识栈顶 ，而top呢？

一般有两种取值，0和-1。

top为0，表示指向栈顶元素的下一个。

每插入一个数据，top++，同时top也是栈中有效数据的个数。

top为-1，指向栈顶元素。

插入数据时top要先++（因为数组下标从0开始），然后再插入数据。

除此之外：

还有一个capacity用来标识栈的容量，因为我们实现的时动态增长的栈，容量时可变的，我们可以扩容。

1.2.3 初始化栈

还是和顺序表一样，在对栈初始化时：

我们可以选择给它一个合适的大小，也可以先不给它分配空间，在我们插入数据时再动态申请空间。

那在实现顺序表的时候我们没有给初始空间，这里我们就换一个写法，给它一个初始空间。

//初始化栈
void StackInit(ST* ps)
{
    assert(ps);
    //不给初始大小
    /*ps->arr = NULL;
    ps->capacity = 0;
    ps->top = 0;*/

    //给一些空间
    ps->arr = (STDataType*)malloc(sizeof(STDataType) * 4);
    if (ps->arr == NULL)
    {
        perror("malloc fail!");
        exit(-1);
    }
    ps->capacity = 4;
    ps->top = 0;
}

正常情况下，ps接收我们定义好的栈的结构体地址，不可能为空，所以我们加一个断言assert(ps);，这里我们上去先给栈开辟了4个整型的大小（当然这个按自己的想法随便给），所以capacity 要赋值为4，此时栈中还没有入数据，在这里我们选择top 的初值为0，即指向栈顶元素的下一个。

1.2.4 销毁栈

与初始化对应，我们就直接把销毁写了：

因为我们实现的时动态增长的栈，数组的空间是在堆上动态开辟的，需要我们最后使用free释放的，否则会发生内存泄漏。

//销毁栈
void StackDestroy(ST* ps)
{
    assert(ps);
    free(ps->arr);
    ps->arr = NULL;
    ps->capacity = 0;
    ps->top = 0;
}

销毁的逻辑很简单，把ps->arr指向的栈的空间释放掉，把top和capacity都置为0 就行了。

1.2.5 压栈

栈初始化好了，那就往里放数据啊，接下来就写一下压栈对应的函数：

压栈就是从栈顶入数据，怎么入呢？

很简单，就是往数组里放元素嘛，放到那个位置呢？

是不是就是下标为top的位置啊。

因为我们选的top初值为0，数组下标呢也从0开始，那直接放就行了，然后top++，还是指向栈顶的下一个位置。

那有没有什么需要注意的呢？

别忘了，我们初始化只给个4个容量，那就只能入4个数据，所以呢，每次数据压栈之前，我们要检查一下容量。

那是不是也很简单，顺序表的时候我们已经写过。什么时候需要扩容？

是不是ps->top == ps->capacity，因为top从0开始的话，top的值就是栈中有效数据的个数，所以ps->top == ps->capacity就是栈满了，此时需要扩容，这里我们还是选择扩到原来的两倍。

//压栈
void StackPush(ST* ps, STDataType x)
{
    assert(ps);
    //检查栈满了需要扩容
    if (ps->top == ps->capacity)
    {
        STDataType* tmp = (STDataType*)realloc(ps->arr, sizeof(STDataType) * ps->capacity * 2);
        if (tmp == NULL)
        {
            perror("realloc fail!");
            exit(-1);
        }
        ps->arr = tmp;
        ps->capacity *= 2;
    }
    ps->arr[ps->top] = x;
    ps->top++;
}

1.2.6 出栈

出栈就太简单了。


我们只需要让top--就行了，以后再插入新数据的时候，会覆盖掉原来的值，不会产生任何影响。

当然，这里要注意进行一个判断assert(!StackEmpty(ps));（这个函数我们马上就会实现，栈为空返回真，不空返回假），如果栈为空，就不能再出栈元素了。

//出栈
void StackPop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));
    ps->top--;
}

1.2.7 判空

既然上面判空的时候使用到了判空的函数，我们就先实现一下：

判空也很容易，直接返回ps->top == 0，如果等于0 ，就是空，该表达式结果为真，不等于0，就是非空，表达式结果为假。

//判空
bool StackEmpty(ST* ps)
{
    assert(ps);
    return ps->top == 0;
}

1.2.8 取栈顶元素

栈顶元素怎么取？

是不是就是下标为top的元素，直接拿就行，当然也要记得进行一个判断，如果栈空了，自然没法取了。

//取栈顶元素
STDataType StackTop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));
    return ps->arr[ps->top - 1];
}

1.2.9 获取有效元素个数

上面已经说过了，我们初始化top的值为0，top的值就是有栈中有效数据的个数。

所以，直接返回top的值就行了。

//获取栈中有效元素个数
int StackSize(ST* ps)
{
    assert(ps);
    return ps->top;
}

写完这几个函数，大家可能会想，有的函数这么简单，一句代码就搞定了，为什么还要封装成一个函数，有必要嘛？


那我们接下来就来讨论一下这个问题，就拿StackSize这个函数来说，top就是数据个数，我们直接就可以获取，好像没必要再去写一个函数，再调用这个函数去获取栈中的元素个数。

但是呢？

我们这里的栈是自己写的，我们知道top的初值是0，代表的是元素个数。但是top一定是0吗，我们说过top是不是还可以取值为-1。

那如果你拿到一个别人写的栈，人家的实现一定和你想的一样吗？是不是有可能不一样啊，那这时如果没有提供对应的函数，你想获取栈中的数据个数，是不是还得去看一下栈的具体实现啊，看人家的top是怎么定义的。

但是如果提供的有接口函数（即使非常简单），那这对于使用者来说是不是就更加方便啊，使用者不必关心数据结构的具体实现，直接调用相关函数即可。

设想你是使用者，你希望开发的人怎么搞，是不是还是把所有的功能封装好提供给你啊，而不是觉得某一个函数很简单，让使用者自己解决。

因此，好的做法还是封装成一个函数，即使这个函数的实现可能很简单。


那到这里，栈的几个接口函数我们就实现完毕了。

1.3 测试

我们来简单的测试一下我们写的栈：

int main()
{
    ST st;
    StackInit(&st);
    StackPush(&st, 1);
    StackPush(&st, 2);
    StackPush(&st, 3);
    StackPush(&st, 4);
    StackPush(&st, 5);
    StackPush(&st, 6);
    printf("%d\n", StackSize(&st));
    printf("%d\n", StackTop(&st));

    StackPop(&st);
    StackPop(&st);
    StackPop(&st);
    printf("%d\n", StackSize(&st));
    printf("%d\n", StackTop(&st));
    printf("%d\n", StackEmpty(&st));

    StackDestroy(&st);
    return 0;
}

784d64e36616485ba24907f5c228632e.png

1.4 源码展示

下面把源码分享给大家：

1.4.1 stack.h

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

typedef int STDataType;
typedef struct Stack
{
    STDataType* arr;
    int top;//top为0，表示指向栈顶元素的下一个，也是元素个数
            //top为-1，指向栈顶元素
    int capacity;
}ST;

//初始化栈
void StackInit(ST* ps);

//销毁栈
void StackDestroy(ST* ps);

//压栈
void StackPush(ST* ps, STDataType x);

//出栈
void StackPop(ST* ps);

//取栈顶元素
STDataType StackTop(ST* ps);

//获取栈中有效元素个数
int StackSize(ST* ps);

//判空
bool StackEmpty(ST* ps);

1.4.2 stack.c

#define _CRT_SECURE_NO_WARNINGS
#include "Stack.h"

//初始化栈
void StackInit(ST* ps)
{
    assert(ps);
    //不给初始大小
    /*ps->arr = NULL;
    ps->capacity = 0;
    ps->top = 0;*/

    //给一下空间
    ps->arr = (STDataType*)malloc(sizeof(STDataType) * 4);
    if (ps->arr == NULL)
    {
        perror("malloc fail!");
        exit(-1);
    }
    ps->capacity = 4;
    ps->top = 0;
}

//销毁栈
void StackDestroy(ST* ps)
{
    assert(ps);
    free(ps->arr);
    ps->arr = NULL;
    ps->capacity = 0;
    ps->top = 0;
}

//压栈
void StackPush(ST* ps, STDataType x)
{
    assert(ps);
    //检查栈满了需要扩容
    if (ps->top == ps->capacity)
    {
        STDataType* tmp = (STDataType*)realloc(ps->arr, sizeof(STDataType) * ps->capacity * 2);
        if (tmp == NULL)
        {
            perror("realloc fail!");
            exit(-1);
        }
        ps->arr = tmp;
        ps->capacity *= 2;
    }
    ps->arr[ps->top] = x;
    ps->top++;
}

//出栈
void StackPop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));
    ps->top--;
}

//取栈顶元素
STDataType StackTop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));
    return ps->arr[ps->top - 1];
}

//获取栈中有效元素个数
int StackSize(ST* ps)
{
    assert(ps);
    return ps->top;
}

//判空
bool StackEmpty(ST* ps)
{
    assert(ps);
    return ps->top == 0;
}

1.4.3 test.c

#include "Stack.h"
int main()
{
    ST st;
    StackInit(&st);
    StackPush(&st, 1);
    StackPush(&st, 2);
    StackPush(&st, 3);
    StackPush(&st, 4);
    StackPush(&st, 5);
    StackPush(&st, 6);
    printf("%d\n", StackSize(&st));
    printf("%d\n", StackTop(&st));

    StackPop(&st);
    StackPop(&st);
    StackPop(&st);
    printf("%d\n", StackSize(&st));
    printf("%d\n", StackTop(&st));
    printf("%d\n", StackEmpty(&st));

    StackDestroy(&st);
    return 0;
}

2. 队列

接下来我们来学习队列，那什么是队列呢？

2.1 队列的概念及结构

队列是一种特殊的线性表，和栈一样，队列是一种操作受限制的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作

作。

进行插入操作的端称为队尾，进行删除操作的端称为队头。

队列具有先进先出FIFO(First In First Out)的特性。

995c0c15ee1844db8358e304217d1d1c.png

2.2 队列的实现

队列也可以采用数组和链表两种结构实现。

那对于队列来说，采用哪一种结构实现更好呢？

使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上的元素，需要挪动数据，效率会比较低。

那链表也有好几种啊。

在这里我们采用单链表来实现队列，单链表就可以了，还能节省一个指针，没必要用双向的或其它更复杂的结构。

那要不要带哨兵位的头呢？

可以带，也可以不带。

带头的好处就是第一次尾插的时候比较方便，不用单独判断，这里我们就不带头，和我们之前写的单链表一样。

那要不要循环呢？

也不需要循环，单链表循环的话，就是尾结点的next指针域指向头，如果我们要找尾还是得从头找。

如果是双向循环的话拿头结点就可以直接找到尾，这里我们采用单链表，循环也没什么用。

2.2.1 结构

那既然我们用单链表来实现，首先就需要有一个结点结构：

typedef int QDataType;

//结点结构
typedef struct QueueNode
{
    QDataType data;
    struct QueueNode* next;
}QNode;

一个数据域，一个指针域。

然后呢，我们再来想一下：

我们知道队列只允许在队尾入数据，在队头出数据，那对于单链表来说，其实就是只能头删和尾插。

我们知道单链表找尾的话就需要从头遍历找尾，那如果我们每次往队列里入数据的时候，都去遍历找尾，是不是就太麻烦了，所以我们再加一个尾指针来记录尾结点的位置，方便我们尾插。

那正常情况下不是还有一个头指针嘛，现在就有两个指针。

c78c446898ca4e178347404122432803.png

那对于队列来说，有一个头指针指向队头，有一个尾指针指向队尾，我们就可以再搞一个结构体：

//队列结构
typedef struct Queue
{
    QNode* head;
    QNode* tail;
    int size;
}Queue;

除此之外，通常情况下，我们还要获取队列中有效元素的个数，所以我们可以再给队列的结构体加一个成员size，每次入数据我们让size++，每次出数据让size–，这样要获取元素个数的时候直接访问size就行了，不需要我们再遍历队列计算数据个数，就比较方便。

2.2.2 初始化队列

单链表我们没有写初始化的函数，为什么？

因为单链表是不是定义一个头指针就行了，拿到这个头指针，就相当于拿到了整个链表，没必要再写一个函数。

那我们的队列虽然是采用单链表来实现的，但是这里是不是又多了一个尾指针啊，而且还有一个size。

所以呢，我们干脆就加一个初始化的函数。

//初始化队列
void QueueInit(Queue* pq)
{
    assert(pq);
    pq->head = NULL;
    pq->tail = NULL;
    pq->size = 0;
}

初始头尾指针都指向空，size为0。

2.2.3 销毁队列

初始化写了，那我们就直接把销毁写了。

销毁那就和单链表的销毁一个道理，遍历，然后一个结点一个结点的销毁就行了。

3b8d5be98501405fa0e0acdeab4fd063.png

//销毁队列
void QueueDestory(Queue* pq)
{
    assert(pq);
    QNode* cur = pq->head;
    while (cur)
    {
        QNode* nextnode = cur->next;
        free(cur);
        cur = nextnode;
    }
    pq->head = pq->tail = NULL;
    pq->size = 0;
}

这里的参数呢是Queue* pq，解释一下：

因为我们的队列定义成了一个结构体，那销毁或者插入删除等这些操作，改变的其实就是队列对应的结构体，所以我们传结构体的地址就行了，那接收就用一个结构体指针Queue*。

2.2.4 队尾入数据

队尾入数据其实就是对尾插嘛。

df4a6ecaf1db4b1686edd846e6598b6b.png

那我们就创建一个新结点，链接在原来的队尾后面就行了嘛。

但是呢？

要注意我们用的是不带哨兵位的单链表实现队列，所以空队列尾插的时候是需要单独处理的。d386328d1ed343f884d28c2d107e7e78.png

直接把newnode赋值给头尾指针就行了。

//队尾入数据
void QueuePush(Queue* pq, QDataType x)
{
    assert(pq);
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    newnode->data = x;
    newnode->next = NULL;

    if (pq->head == NULL)
    {
        pq->head = pq->tail = newnode;
    }
    else
    {
        pq->tail->next = newnode;
        pq->tail = newnode;
    }
    pq->size++;//入数据size++；
}

2.2.5 队头出数据

队头出数据就是头删嘛。

0da1f7281ae743c494f64f07c12d2455.png

但是需要注意的是：

由于我们这里加了一个尾指针，导致队列中只有一个数据时再去删除需要单独判断。

为什么呢？来看图：c7fad5ae8f72440e9047d6e58becd4bc.png

当对列中只有一个元素时，大家按照上面的代码逻辑再走一遍，会发现，删除完最后一个元素之后，head头指针时指向空了，但是尾指针tail还指向最后一个元素的地址，但是最后一个元素已经销毁了，此时它就是一个野指针了。

而且空队列tail和head应该同时指向空，但此时并不是。


所以呢，这里需要单独处理一下：

fd477b292318483e9e1162f088c2682c.png

所以，最终的代码时这样的：

//队头出数据
void QueuePop(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    if (pq->head->next == NULL)
    {
        free(pq->head);
        pq->head = pq->tail = NULL;
    }
    else
    {
        QNode* nextnode = pq->head->next;
        free(pq->head);
        pq->head = nextnode;
    }
    pq->size--;
}

2.2.6 取队头元素

取队头元素很简单，就是头指针的data嘛。

//取队头元素
QDataType QueueFront(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    return pq->head->data;
}

2.2.7 取队尾元素

取队尾元素也很简单：

如果没有尾指针的话，单链表找尾还需要从头遍历，但是我们现在有尾指针啊，那就非常easy了。

//取队尾元素
QDataType QueueBack(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    return pq->tail->data;
}

2.2.8 队列判空

什么时候队列为空？

是不是size等于0啊，当然当头尾指针都指向空的时候队列也为空。两种方法都可以判断。

//队列判空
bool QueueEmpty(Queue* pq)
{
    assert(pq);
    return pq->size == 0;
    //return pq->head == NULL && pq->tail == NULL;
}

2.2.9求队列有效元素个数

我们加了成员变量size，现在获取有效数据个数是不是soeasy啊。

//求队列有效元素个数
int QueueSize(Queue* pq)
{
    assert(pq);
    return pq->size;
}

2.3 测试

现在对我们实现的队列进行一个测试：

void QueueTest()
{
    Queue q;
    QueueInit(&q);

    QueuePush(&q, 1);
    QueuePush(&q, 2);
    QueuePush(&q, 3);
    QueuePush(&q, 4);
    QueuePush(&q, 5);
    QueuePush(&q, 6);
    printf("%d\n", QueueSize(&q));
    printf("%d\n", QueueFront(&q));
    printf("%d\n", QueueBack(&q));
    printf("%d\n", QueueEmpty(&q));

    QueuePop(&q);
    QueuePop(&q);
    QueuePop(&q);
    QueuePop(&q);
    QueuePop(&q);
    QueuePop(&q);

    printf("%d\n", QueueSize(&q));
    /*printf("%d\n", QueueFront(&q));
    printf("%d\n", QueueBack(&q));*/
    printf("%d\n", QueueEmpty(&q));


    QueueDestory(&q);
}

6842a30f8c3f46b3b1ec5b88c8d3b4d5.png

2.4 源码展示

源码分享给大家：

2.4.1 Queue.h

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

typedef int QDataType;

//结点结构
typedef struct QueueNode
{
    QDataType data;
    struct QueueNode* next;
}QNode;

//队列结构
typedef struct Queue
{
    QNode* head;
    QNode* tail;
    int size;
}Queue;

//初始化队列
void QueueInit(Queue* pq);
//销毁队列
void QueueDestory(Queue* pq);
//队尾入数据
void QueuePush(Queue* pq, QDataType x);
//队头出数据
void QueuePop(Queue* pq);
//取队头元素
QDataType QueueFront(Queue* pq);
//取队尾元素
QDataType QueueBack(Queue* pq);
//队列判空
bool QueueEmpty(Queue* pq);
//求队列有效元素个数
int QueueSize(Queue* pq);

2.4.2 Queu.c

#define _CRT_SECURE_NO_WARNINGS
#include "Queue.h"

//初始化队列
void QueueInit(Queue* pq)
{
    assert(pq);
    pq->head = NULL;
    pq->tail = NULL;
    pq->size = 0;
}
//销毁队列
void QueueDestory(Queue* pq)
{
    assert(pq);
    QNode* cur = pq->head;
    while (cur)
    {
        QNode* nextnode = cur->next;
        free(cur);
        cur = nextnode;
    }
    pq->head = pq->tail = NULL;
    pq->size = 0;
}
//队尾入数据
void QueuePush(Queue* pq, QDataType x)
{
    assert(pq);
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    newnode->data = x;
    newnode->next = NULL;

    if (pq->head == NULL)
    {
        pq->head = pq->tail = newnode;
    }
    else
    {
        pq->tail->next = newnode;
        pq->tail = newnode;
    }
    pq->size++;

}
//队头出数据
void QueuePop(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    if (pq->head->next == NULL)
    {
        free(pq->head);
        pq->head = pq->tail = NULL;
    }
    else
    {
        QNode* nextnode = pq->head->next;
        free(pq->head);
        pq->head = nextnode;
    }
    pq->size--;
}
//取队头元素
QDataType QueueFront(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    return pq->head->data;
}
//取队尾元素
QDataType QueueBack(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    return pq->tail->data;
}
//队列判空
bool QueueEmpty(Queue* pq)
{
    assert(pq);
    return pq->size == 0;
    //return pq->head == NULL && pq->tail == NULL;
}
//求队列有效元素个数
int QueueSize(Queue* pq)
{
    assert(pq);
    return pq->size;
}

2.4.3 Test.c

#include "Queue.h"

void QueueTest()
{
    Queue q;
    QueueInit(&q);

    QueuePush(&q, 1);
    QueuePush(&q, 2);
    QueuePush(&q, 3);
    QueuePush(&q, 4);
    QueuePush(&q, 5);
    QueuePush(&q, 6);
    printf("%d\n", QueueSize(&q));
    printf("%d\n", QueueFront(&q));
    printf("%d\n", QueueBack(&q));
    printf("%d\n", QueueEmpty(&q));

    QueuePop(&q);
    QueuePop(&q);
    QueuePop(&q);
    QueuePop(&q);
    QueuePop(&q);
    QueuePop(&q);

    printf("%d\n", QueueSize(&q));
    /*printf("%d\n", QueueFront(&q));
    printf("%d\n", QueueBack(&q));*/
    printf("%d\n", QueueEmpty(&q));


    QueueDestory(&q);
}

int main()
{
    QueueTest();
    return 0;
}

好的，到这里栈和队列的内容就讲解完了，希望能帮助到大家！！！

如果有写的不好的地方，也欢迎大家指正！！！

2f17d1bb8f334e4491e62451c424cf76.png

【版权声明】本文为华为云社区用户原创内容，转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息， 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
数据结构
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入