【数据结构】队列的基本概念 | 从零开始实现队列 | 利用思路草图将思路转变为代码

已于 2022-02-09 19:58:24 修改
阅读量2.1k 收藏 48
点赞数 70
分类专栏： 树锯结构 (C/C++) 文章标签： 数据结构 c语言 算法
于 2021-11-22 17:06:07 首次发布
zdfs
本文链接：https://blog.csdn.net/weixin_50502862/article/details/121411021
版权

前言：

本章我们将学习 "队列" ，首先介绍队列的概念和结构，然后我们将着重讲解栈的实现。我们从零开始写队列的接口，并从零开始步步解读。本章将继续巩固画思路草图的能力，只要思路草图画好了，就可以很轻松地将其转换成代码。

一、队列（Queue）

0x00 队列的概念

📚 概念：

① 队列只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。

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

③ 队列中的元素遵循先进先出的原则，即 FIFO 原则（First In First Out）

0x01 队列的结构

🔍 结构：

二、队列的定义

0x00 链式队列

typedef int QueueDataType;   //队列类型

typedef struct QueueNode {
    struct QueueNode* next;  //指向下一个节点
    QueueDataType data;      //数据
} QueueNode;

typedef struct Queue {
    QueueNode* pHead;        //头指针
    QueueNode* pTail;        //尾指针
} Queue;

❓ 为什么不使用单链表？

💡 单链表我们只定义了一个指针指向头，没有定义尾指针。因为定义尾指针解决不了问题，比如尾插尾删。所以我们没有必要定义一个结构体把他们封到一起。这里我们再定义一个头指针 head 一个尾指针 tail ，这两个指针才有意义。因为根据队列的性质，我们只会在队尾插，不会再队尾删。所以这个尾指针的价值就得到了完美的体现，实际中定义几个指针是看你的需求确定的。

0x02 接口函数

📚 这是需要实现几个接口函数：

void QueueInit(Queue* pQ);                  //队列初始化
void QueueDestroy(Queue* pQ);               //销毁队列
bool QueueIsEmpty(Queue* pQ);               //判断队列是否为空
void QueuePush(Queue* pQ, QueueDataType x); //入队
void QueuePop(Queue* pQ);                   //出队
QueueDataType QueueFront(Queue* pQ);        //返回队头数据
QueueDataType QueueBack(Queue* pQ);         //返回队尾数据
int QueueSize(Queue* pQ);                   //求队列大小

三、队列的实现

0x00 队列初始化（QueueInit）

💬 Queue.h

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

typedef int QueueDataType;   //队列类型

typedef struct QueueNode {
    struct QueueNode* next;  //指向下一个节点
    QueueDataType data;      //数据
} QueueNode;

typedef struct Queue {
    QueueNode* pHead;        //头指针
    QueueNode* pTail;        //尾指针
} Queue;

void QueueInit(Queue* pQ);   //队列初始化

💬 Queue.c

/* 队列初始化：将头尾指针置为NULL */
void QueueInit(Queue* pQ) {
    assert(pQ);                          //防止传入的pQ为空

    pQ->pHead = pQ->pTail = NULL;        //将头尾指针置空
}

🔑 解析：首先使用断言防止传入的pQ为空。初始化只需要把头指针和尾指针都置成空即可。

0x01 销毁队列（QueueDestroy）

/* 销毁队列：free掉所有队列元素并将头尾置空 */
void QueueDestroy(Queue* pQ) {
    assert(pQ);                          //防止传入的pQ为空
 
    QueueNode* cur = pQ->pHead;          //创建遍历指针cur
    while(cur != NULL) {                 //cur不为空就进入循环
        QueueNode* curNext = cur->next;  //信标指针curNext，防止释放cur后找不到其下一个节点
        free(cur);                       //释放cur当前指向的节点
        cur = curNext;                   //移动指针cur
    }
    pQ->pHead = pQ->pTail = NULL;        //置空干掉野指针
}

🔑 解读：

① 首先断言防止传入的pQ为空。

② 销毁要把所有节点都释放掉，我们创建遍历指针 cur 遍历整个队列。既然要释放 cur 指向的节点，为了防止释放 cur 之后找不到其下一个节点导致无法移动，我们这里创建一个类似于信标性质的指针 curNext 来记录一下 cur 的下一个节点，之后再 free 掉 cur，这样就可以移动 cur 了。

③ 最后为了防止野指针，还需要把头指针和尾指针都置为空。

0x02 判断队列是否为空（HeapIsEmpty）

💬 Queue.h

bool QueueIsEmpty(Queue* pQ);               //判断队列是否为空

🔑 解读：布尔值，返回 true 或 false

💬 Queue.c

/* 判断队列是否为空 */
bool QueueIsEmpty(Queue* pQ) {
    assert(pQ);                          //防止传入的pQ为空

    return pQ->pHead == NULL;            //如果成立则为True，不成立则为False
}

🔑 解读：

① 首先断言防止传入的pQ为空。

② 判断队列是否为空，可以直接返回，巧妙地利用布尔类型的特性。如果 pQ->pHead == NULL 成立则为真，会返回 true；不成立则为假，会返回 false。

0x03 入队（QueuePush）

💬 Queue.h

void QueuePush(Queue* pQ, QueueDataType x); //入队

💬 Queue.c

/* 入队：队尾入数据，对头出数据。如果是第一个入队的则既要当头又当尾 */
void QueuePush(Queue* pQ, QueueDataType x) {
    assert(pQ);             //防止传入的pQ为空

    /* 创建新节点：创建一个大小为QueueNode的空间 */
    QueueNode* new_node = (QueueNode*)malloc(sizeof(QueueNode));
    /* 检查malloc */
    if(new_node == NULL) {
        printf("malloc failed!\n");
        exit(-1);
    }
    /* 放置 */
    new_node->data = x;     //待插入的数据
    new_node->next = NULL;  //默认为空
    
    /* 入队：
     *【思路草图】
     *   情况1：队列为空：既当头又当尾
     *         [new_node]
     *           ↑    ↑
     *         pHead pTail
     * 
     *   情况2：队列不为空：队尾入数据
     *          [] -> [] -> [] -> []   ->  [new_node]
     *         pHead             pTail     pTail->next
     *                            ↓             ↑
     *                            ----------→ pTail（更新尾指针）
     */
    if(pQ->pHead == NULL) {                //情况1: 队列为空
        pQ->pHead = pQ->pTail = new_node;  //       既当头又当尾
    } else {                               //情况2: 队列不为空
        pQ->pTail->next = new_node;        //       在现有尾的后一个节点放置new_node
        pQ->pTail = new_node;              //       更新pTail，使它指向新的尾
    }
}

🔑 解读：

① 首先断言防止传入的pQ为空。

② 我们首先要创建新节点。通过 malloc 动态内存开辟一块 QueueNode 大小的空间，都学到这里了大家想必都养成了检查 malloc 的好习惯了吧？。最后放置数据吗，将待插入的数据 x 交给 data，next 默认置空，和之前学链表一样，这里就不过多赘述了。

③ 新节点创建好后，我们可以开始写入队的操作了。首先要理解队列的性质：队尾入数据，队头出数据。这里既然是入队，就要在对尾后面进行插入。这里我们还要考虑到如果队列为空的情况，这时我们要把头指针和尾指针都交付给 new_node 。为了理清思路，我们可以画一个思路草图来帮助我们更好地理解：

有了这个图，我们就可以清楚地实现了：

if(pQ->pHead == NULL) {                //情况1: 队列为空
    pQ->pHead = pQ->pTail = new_node;  //       既当头又当尾
}
else {                                 //情况2: 队列不为空
    pQ->pTail->next = new_node;        //       在现有尾的后一个节点放置new_node
    pQ->pTail = new_node;              //       更新pTail，使它指向新的尾
}

当队列为空时，令头指针和尾指针都指向 new_node ，当队列不为空时，再尾部地下一个节点放置 new_node ，随后再更新尾指针让其指向新的尾（new_node 的位置）。

0x04 出队（QueuePop）

💬 Queue.h

void QueuePop(Queue* pQ);                   //出队

💬 Queue.c

/* 出队：队尾入数据，对头出数据 */ 
void QueuePop(Queue* pQ) {
    assert(pQ);                            //防止传入的pQ为空
    assert(!QueueIsEmpty(pQ));             //防止队列为空

    /* 出队:
     *【思路草图】
     *        [free] ->  []     -> [] -> []
     *        pHead    headNext  
     *           ↓         ↑
     *           -------→ pHead（更新头指针）
     */
    QueueNode* headNext = pQ->pHead->next; //信标指针HeadNext
    free(pQ->pHead);
    pQ->pHead = headNext;                  //更新头

    /* 如果队内都被删完了，不处理pTail就会带来野指针的隐患 
     * 【思路草图】
     *          NULL               已经被free掉的内存！
     *           ↑                         ↑   （野指针警告）
     *         pHead(因为HeadNext是NULL)  pTail
    */
    if(pQ->pHead == NULL)                  //如果pHead为空
        pQ->pTail = NULL;                  //处理一下尾指针，将尾指针置空
}

🔑 解读：

① 首先断言防止传入的 pQ 为空，这里还要放置队列为空，如果队列为空还要求出队的话会出问题的，所以这里要断言一下 QueueIsEmpty 为假。

② 思路草图如下：

出数据需要释放，和销毁一样，这里使用一个类似于信标性质的指针来记录 pHead 的下一个节点，之后我们就可以大胆地释放 pHead 而不用担心找不到了。free 掉之后更新头即可，令头指针指向 headNext 即可。 

📌 注意：这里还要考虑一个问题，如果队内都被删完了，pHead 往后走指向空，但是 pTail 仍然指向那块已经被 free 掉的空间。pTail 就是一个典型的野指针。

我们可以不用担心 pHead，因为后面没有数据他会自然指向 NULL，但是我们这里得关注 pTail ！我们需要手动处理一下它：

如果 pHead 为空，我们就把 pTail 也置为空即可。

 if(pQ->pHead == NULL)                  //如果pHead为空
        pQ->pTail = NULL;               //处理一下尾指针，将尾指针置空

0x05 返回队头数据（QueueFront）

💬 Queue.h

QueueDataType QueueFront(Queue* pQ);        //返回队头数据

💬 Queue.c

/* 返回队头数据 */
QueueDataType QueueFront(Queue* pQ) {
    assert(pQ);                            //防止传入的pQ为空
    assert(!QueueIsEmpty(pQ));             //防止队列为空

    return pQ->pHead->data;
}

🔑 解读：

① 首先断言防止传入的 pQ 为空，这里我们还是要断言一下 QueueIsEmpty 为假，因为如果队内没有数据，还返回个锤子数据呢。

② 这里直接返回头的数据即可，特别简单没有什么好讲的。

0x06 返回队尾数据（QueueBack）

💬 Queue.h

QueueDataType QueueBack(Queue* pQ);         //返回队尾数据

💬 Queue.c

/* 返回队尾数据 */
QueueDataType QueueBack(Queue* pQ) {
    assert(pQ);                            //防止传入的pQ为空
    assert(!QueueIsEmpty(pQ));             //防止队列为空

    return pQ->pTail->data;
}

🔑 解读：

① 首先断言防止传入的 pQ 为空，断言一下 QueueIsEmpty 为假。

② 这里直接返回队尾的数据即可。

0x07 求队列大小（QueueSize）

💬 Queue.h

int QueueSize(Queue* pQ);                   //求队列大小

💬 Queue.c

/* 求队列大小：计数器法 */
int QueueSize(Queue* pQ) {
    assert(pQ);             //防止传入的pQ为空
 
    int count = 0;          //计数器           
    QueueNode* cur = pQ->pHead;    //创建遍历指针cur
    while(cur != NULL) {
        ++count;            //计数+1
        cur = cur->next;    //移动指针cur
    }
    return count;
}

🔑 解读：这里我们采用计数器法来求大小即可，调用一次就是 O(N) ，也没什么不好的。

① 首先断言防止传入的 pQ 为空。

② 创建计数器变量和遍历指针 cur，遍历整个队列并计数，最后返回计数的结果即可。

0x08 完整代码

💬 Queue.h

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

typedef int QueueDataType;   //队列类型

typedef struct QueueNode {
    struct QueueNode* next;  //指向下一个节点
    QueueDataType data;      //数据
} QueueNode;

typedef struct Queue {
    QueueNode* pHead;        //头指针
    QueueNode* pTail;        //尾指针
} Queue;

void QueueInit(Queue* pQ);                  //队列初始化
void QueueDestroy(Queue* pQ);               //销毁队列
bool QueueIsEmpty(Queue* pQ);               //判断队列是否为空
void QueuePush(Queue* pQ, QueueDataType x); //入队
void QueuePop(Queue* pQ);                   //出队
QueueDataType QueueFront(Queue* pQ);        //返回队头数据
QueueDataType QueueBack(Queue* pQ);         //返回队尾数据
int QueueSize(Queue* pQ);                   //求队列大小

💬 Queue.c

#include <Queue.h>

/* 队列初始化：将头尾指针置为NULL */
void QueueInit(Queue* pQ) {
    assert(pQ);                          //防止传入的pQ为空
 
    pQ->pHead = pQ->pTail = NULL;        //将头尾指针置空
}
 
/* 销毁队列：free掉所有队列元素并将头尾置空 */
void QueueDestroy(Queue* pQ) {
    assert(pQ);                          //防止传入的pQ为空
 
    QueueNode* cur = pQ->pHead;          //创建遍历指针cur
    while(cur != NULL) {                 //cur不为空就进入循环
        QueueNode* curNext = cur->next;  //信标指针curNext，防止释放cur后找不到其下一个节点
        free(cur);                       //释放cur当前指向的节点
        cur = curNext;                   //移动指针cur
    }
    pQ->pHead = pQ->pTail = NULL;        //置空干掉野指针
}
 
/* 判断队列是否为空 */
bool QueueIfEmpty(Queue* pQ) {
    assert(pQ);                          //防止传入的pQ为空
 
    return pQ->pHead == NULL;            //如果成立则为True，不成立则为False
}
 
/* 入队：队尾入数据，对头出数据。如果是第一个入队的则既要当头又当尾 */
void QueuePush(Queue* pQ, QueueDataType x) {
    assert(pQ);             //防止传入的pQ为空
 
    /* 创建新节点：创建一个大小为QueueNode的空间 */
    QueueNode* new_node = (QueueNode*)malloc(sizeof(QueueNode));
    /* 检查malloc */
    if(new_node == NULL) {
        printf("malloc failed!\n");
        exit(-1);
    }
    /* 放置 */
    new_node->data = x;     //待插入的数据
    new_node->next = NULL;  //默认为空
    
    /* 入队：
     *【思路草图】
     *   情况1：队列为空：既当头又当尾
     *         [new_node]
     *           ↑    ↑
     *         pHead pTail
     * 
     *   情况2：队列不为空：队尾入数据
     *          [] -> [] -> [] -> []   ->  [new_node]
     *         pHead             pTail     pTail->next
     *                            ↓             ↑
     *                            ----------→ pTail（更新尾指针）
     */
    if(pQ->pHead == NULL) {                //情况1: 队列为空
        pQ->pHead = pQ->pTail = new_node;  //       既当头又当尾
    } else {                               //情况2: 队列不为空
        pQ->pTail->next = new_node;        //       在现有尾的后一个节点放置new_node
        pQ->pTail = new_node;              //       更新pTail，使它指向新的尾
    }
}
 
/* 出队：队尾入数据，对头出数据 */ 
void QueuePop(Queue* pQ) {
    assert(pQ);                            //防止传入的pQ为空
    assert(!QueueIsEmpty(pQ));             //防止队列为空
 
    /* 出队:
    
     *【思路草图】
     *        [free] ->  []     -> [] -> []
     *        pHead    headNext  
     *           ↓         ↑
     *           -------→ pHead（更新头指针）
     */
    QueueNode* headNext = pQ->pHead->next; //信标指针HeadNext，防止释放pHead后找不到其下一个节点
    free(pQ->pHead);
    pQ->pHead = headNext;                  //更新头
 
    /* 如果队内都被删完了，不处理pTail就会带来野指针的隐患 
     * 【思路草图】
     *          NULL               已经被free掉的空间！
     *           ↑                         ↑   （野指针）
     *         pHead(因为HeadNext是NULL)  pTail
    */
    if(pQ->pHead == NULL)                  //如果pHead为空
        pQ->pTail = NULL;                  //处理一下尾指针，将尾指针置空
}
 
/* 返回队头数据 */
QueueDataType QueueFront(Queue* pQ) {
    assert(pQ);                            //防止传入的pQ为空
    assert(!QueueIsEmpty(pQ));             //防止队列为空
 
    return pQ->pHead->data;
}   
 
/* 返回队尾数据 */
QueueDataType QueueBack(Queue* pQ) {
    assert(pQ);                            //防止传入的pQ为空
    assert(!QueueIsEmpty(pQ));             //防止队列为空
 
    return pQ->pTail->data;
}
 
/* 求队列大小：计数器法 */
int QueueSize(Queue* pQ) {
    assert(pQ);             //防止传入的pQ为空
 
    int count = 0;          //计数器           
    QueueNode* cur = pQ->pHead;    //创建遍历指针cur
    while(cur != NULL) {
        ++count;            //计数+1
        cur = cur->next;    //移动指针cur
    }
    return count;
}

💬 Test.c

#include "Queue.h"

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

    QueuePush(&q, 1);
    QueuePush(&q, 2);
    QueuePush(&q, 3);
    QueuePush(&q, 4);

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

    QueueDestroy(&q);
}

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

    QueuePush(&q, 1);
    QueuePush(&q, 2);
    QueuePush(&q, 3);
    QueuePush(&q, 4);

    //假设先入了1 2，让1出来，再继续入，它的顺序还是不会变。
    // 永远保持先进先出的，无论是入了两个出两个，再入再出，还是全部入完了再出，都是不会变的。这就是队列的性质
    while(!QueueIsEmpty(&q)) {
        QueueDataType front = QueueFront(&q);
        printf("%d ", front);
        QueuePop(&q);  //pop掉去下一个
    }
    printf("\n");

    QueueDestroy(&q);
}

int main(void) {
    TestQueue2();

    return 0;
}

参考资料：

Microsoft. MSDN(Microsoft Developer Network)[EB/OL]. []. .

百度百科[EB/OL]. []. https://baike.baidu.com/.

📌 笔者：王亦优

📃 更新： 2021.11.17

❌ 勘误： 无

📜 声明： 由于作者水平有限，本文有错误和不准确之处在所难免，本人也很想知道这些错误，恳望读者批评指正！

本篇完。

平渊道人
关注
  • 70
    点赞
  • 踩
  • 48
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 24
    评论
专栏目录
【数据结构】从零开始逐步实现带哨兵位循环双向链表 | 学会用 “思路草图“ 将思路转变成代码
有道无术, 术尚可求。有术无道, 止于术。
11-15 2207
本章节将继续讲解链表，在上一章节中我们学习了单链表，本章将对其他的链表进行简要介绍，旨在让读者理解单链表和双链表各自存在的意义。将着重讲解带哨兵位双向循环链表，对常用的接口函数进行逐个讲解，本章开始引入可以将思路轻松转换成代码的 "思路草图" 方法。站在初学者的角度上进行讲解和分析。通过本章的学习，还能够帮助大家理解解 "代码复用" 的意义。
环形队列（索引从0开始（C语言、C++、Java）、索引从1开始（Matlab））
看看世界看看你
08-27 949
环形队列综合分析0索引开始的代码实现（C++）从1索引开始的代码实现(Matlab) 综合分析 关于数组模拟环形队列的问题，有两点疑问。 为什么用数组模拟？ 为什么要有环形队列？ 刚开始想用数组模拟队列，因为数组索引方便，使用简单。但是数组模拟队列有几点局限性。数组是一个定长的类型，即一经分配，无法修改长度。但是我们在使用队列的时候，可能需要很多个数据，那么对于队列的长度选取就存在着问题。因此，聪明的人们开始想着用环形队列进行代替，即环岛一样，可以重复利用多余的空间。 那么在使用数组进行环形队列模拟
C语言版数据结构（从0开始） 4.队列
qq_44970368的博客
01-31 495
运算受限的线性表---队列1.队列的概念2.顺序队列2.1顺序队列的概念2.2非循环队列非循环队列中的溢出现象2.3循环队列循环队列的空满判别循环队列的基本运算3.链队列3.1 链队列的概念3.2链队列的基本运算 1.队列的概念 和栈一样，队列(Queue)也是一种运算受限的线性表。它只允许在表的一端进行插入，而在另一端进行删除。允许删除的一端称为队头(front)，允许插入的一端称为队尾(rea...
队列、循环队列、双端队列详解（含完整代码）
m0_60284144的博客
04-24 2795
队列是一种操作受限的线性表。只允许在表的一端进行插入，在表的另一端进行删除。和日常生活中的队列一样 先入队的元素优先出队，即先进先出。
【维生素C语言】第五章 - 操作符
热门推荐
有道无术, 术尚可求。有术无道, 止于术。
05-27 1万+
本章将对操作符进行详细的讲解，讲操作符单独拿出来精讲。最后添加了些简单的练习题（带有解析）供读者使用。
java实现队列数据结构代码详解
08-28
本文主要介绍了 Java 实现队列数据结构的代码详解，包括队列结构的介绍、队列实现的代码和队列的应用场景。 队列结构是一种线性结构，具有特殊的运算法则：只能在一端（队头）删除，在另一端（队尾）插入。队列结构...
栈和队列数据结构的基本概念及其相关的Python实现
12-24
相同点：从”数据结构”的角度看，它们都是线性结构，即数据元素之间的关系相同。 不同点：栈（Stack）是限定只能在表的一端进行插入和删除操作的线性表。 队列（Queue）是限定只能在表的一端进行插入和在另一端进行...
数据结构-队列的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 队列的部分实现代码，详细介绍参考数据结构--队列的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
数据结构之栈和队列-思路清晰纯C
最新发布
08-31
队列 循环队列 栈 内容学习于 https://www.bilibili.com/video/BV1W64y1z7jh?p=19&spm_id_from=pageDriver&vd_source=4d33bf4ac4499f2c0370694554a02fa5
Python 数据结构之队列的实现
09-21
在Python中，数据结构是非常重要的...总的来说，理解并掌握Python中的队列数据结构及其实现对于编写高效的算法和解决实际问题至关重要。在实际编程中，根据具体需求选择合适的数据结构可以大大提高代码的效率和可读性。
数据结构-队列的定义及基本操作(代码+报告)
03-30
数据结构-队列的定义及基本操作(代码+报告)
在编程语言中怎样定义队列及其使用(C++)
08-26
主要介绍了在编程语言中怎样定义队列，本文主要根据c++来介绍，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
第 3 章：稀疏数组和队列
Oneby的博客
07-25 4981
第 3 章：稀疏数组和队列 1、稀疏数组 1.1、实际需求 编写的五子棋程序中，有存盘退出和续上盘的功能 因为该二维数组的很多值是默认值 0 ，因此记录了很多没有意义的数据，我们将其转为稀疏数组进行存储 1.2、稀疏数组应用 1.2.1、稀疏数组处理方法 稀疏数组把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模 稀疏数组也是二维数组，行数由原数组的数据决定，列数一般为 3 列 稀疏数组的第一行记录原数组一共有几行几列，有多少个不为零的值 第一列：原数组的行数 第二列：原数组
振弦采集模块AABB 通讯协议
duxi222333的博客
11-16 196
模块地址保存于寄存器 ADDR.[7:0]， 取值范围为 1~255，这些地址中， 255 在 AABB 协议中作为通用地址使用， 地址 128（ 0x80） 用于特殊用途， 故此对模块地址进行修改时可使用的地址有： 1~127、 129~254， 共 253 个。如下例中，校验和=0xAA+0xBB+0x01+0x08=0x016E，则只使用 0x6E 作为最终和校验码。主机发送指令： 0xAA 0xBB 0x01 0x88 0x00 0x64 0x52。例：使用通用地址，读取任一模块的寄存器 8。
队列的定义与实现(C语言实现)
。烊了
06-17 1万+
小时候，我们做早操的时候或者军训的时候，都排成一列，有头有尾。假设你迟到了，只能站到最后面一个，退场的时候，都是由第一个先走的。这就是队列雏形。 队列的定义 队列是一种特殊的线性表 队列仅在线性表的两端进行操作 队头(Front)：取出数据元素的一端 队尾(Rear)：插入数据元素的一端 队列不允许在中间部位进行操作！
【数据结构】队列的定义及实现（c语言）
weixin_42263122的博客
02-03 975
队列的定义： 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 队列的顺序存储实现： 队列的顺序存储通常由一个一维数组，一个记录队头的变量front，一个记录队尾的变量rear和一个记录队列大小的变量 MaxSize组成。结构如下: #...
栈和队列（栈、队列实现，循环队列）
weixin_45350365的博客
05-22 454
栈和队列的实现 //Stack.h // 支持动态增长的栈 typedef int STDataType; typedef struct Stack { STDataType* _a; int _top; // 栈顶 int _capacity; // 容量 }Stack; // 初始化栈 void StackInit(Stack* ps); // 入栈 void StackPush(Stack* ps, STDataType data); // 出栈 void StackPop
队列代码
ShawnWang1994的博客
07-15 3216
#include<stdio.h> #include<stdlib.h> #define QUEEN_SIZE 50 typedef struct QNode{ int data[QUEEN_SIZE]; int front; int rear; }Queue; //初始化队列 Queue *InitQueue() { Queue *q=(Queue*)malloc...
队列简单操作
stary_yan的博客
12-30 585
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。 队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素成为出队。因为队列只允许在一段插入，在另一端删除，所以只有最早进入队
数据结构基础：栈与队列的概念与实现
本资源聚焦于两个基本且重要的数据结构：栈和队列，这些概念是很多算法和系统设计的基础。 栈是一种遵循“后进先出”（LIFO，Last In First Out）原则的线性数据结构。这意味着最后被插入的元素（栈顶元素）将首先...
评论 24
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

平渊道人

喜欢的话可以支持下我的付费专栏

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

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

打赏作者

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

抵扣说明：

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

余额充值