数据结构-队列

于 2024-08-20 14:16:28 发布
阅读量243 收藏 3
点赞数 3
分类专栏： C语言 各问题解决方法 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yandadzf/article/details/141355967
版权

一、了解队列

队列的定义

        队列是一种先进先出（FIFO, First In First Out）的数据结构。它的基本特性是：在队列中，元素的插入（入队）发生在队尾，元素的删除（出队）发生在队头。队列通常用于需要按顺序处理数据的场景。

基本操作

  1. 初始化队列：创建一个空队列。InitQueue(SqQueue* Q)

  2. 入队：将元素添加到队尾。bool EnQueue(SqQueue* Q, int e)

  3. 出队：从队头移除元素并返回该元素。bool DeQueue(SqQueue* Q, int* e)

  4. 获取队头元素：查看队头元素但不移除它。bool GetHead(SqQueue Q, int* e)

  5. 检查队列是否为空：判断队列是否包含元素。bool isEmpty(SqQueue Q)

  6. 获取队列长度：返回队列中当前元素的数量。int LengthQueue(SqQueue Q)

队列的作用

  1. 任务调度：在操作系统中，队列用于管理任务的执行顺序。
  2. 数据缓冲：在生产者-消费者模型中，队列用于存储生产者生成的数据，以便消费者按顺序处理。
  3. 广度优先搜索（BFS）：在图论算法中，队列用于实现广度优先搜索。
  4. 网络请求处理：在服务器中，队列用于管理请求的处理顺序。

队列的优缺点

优点
  1. 简单易用：队列的逻辑结构简单，易于理解和实现。
  2. 高效的插入和删除：在队列的两端（队头和队尾）进行插入和删除操作的时间复杂度为 O(1)。
  3. 适用场景广泛：队列在许多算法和应用中具有重要作用，如任务调度、数据流处理等。
缺点
  1. 固定大小：使用数组实现的队列在初始化时需要定义最大容量，可能导致空间浪费或溢出。
  2. 内存管理：使用链表实现的队列需要额外的内存管理，可能导致内存碎片。
  3. 访问限制：只能访问队头和队尾的元素，无法随机访问队列中的其他元素。

二、队列的顺序存储结构（C语言）

1. 顺序存储结构


#define MaxSize 50 // 定义队列的最大容量为50

// 定义顺序队列的结构体
typedef struct {
    int data[MaxSize]; // 存储队列元素的数组
    int front;         // 队列头指针，指向队列的第一个元素
    int rear;          // 队列尾指针，指向队列的最后一个元素的下一个位置
} SqQueue;

2. 初始化队列

// 初始化队列
void InitQueue(SqQueue* Q) {
    Q->front = 0; // 将队列头指针初始化为0
    Q->rear = 0;  // 将队列尾指针初始化为0
}

3.  入队


// 入队操作
bool EnQueue(SqQueue* Q, int e) {
    // 判断队列是否已满，使用环形队列的特性
    if ((Q->rear + 1) % MaxSize == Q->front) return false;
    Q->data[Q->rear] = e; // 将元素e插入到队列尾
    Q->rear = (Q->rear + 1) % MaxSize; // 更新尾指针
    return true; // 返回成功
}

4.  出队


// 出队操作
bool DeQueue(SqQueue* Q, int* e) {
    // 判断队列是否为空
    if (Q->front == Q->rear) return false;
    *e = Q->data[Q->front]; // 将队列头元素赋值给e
    Q->front = (Q->front + 1) % MaxSize; // 更新头指针
    return true; // 返回成功
}

5. 获取队头元素


// 获取队列头元素
bool GetHead(SqQueue Q, int* e) {
    // 判断队列是否为空
    if (Q.front == Q.rear) return false;
    *e = Q.data[Q.front]; // 将队列头元素赋值给e
    return true; // 返回成功
}

6. 检查队列是否为空


// 判断队列是否为空
bool isEmpty(SqQueue Q) {
    return Q.front == Q.rear; // 如果头指针和尾指针相等，则队列为空
}

7. 获取队列长度


// 获取队列的长度
int LengthQueue(SqQueue Q) {
    // 计算队列当前长度
    return (Q.rear + MaxSize - Q.front) % MaxSize;
}

三、队列的链式存储结构（C语言）

1. 链式存储结构


// 定义链表节点
typedef struct QNode {
    int data;              // 存储数据
    struct QNode* next;   // 指向下一个节点的指针
} QNode;

// 定义链式队列
typedef struct {
    QNode* front;         // 队列头指针
    QNode* rear;          // 队列尾指针
    int length;           // 队列长度
} LinkQueue;

2. 初始化队列


// 初始化队列
bool InitQueue(LinkQueue* Q) {
    Q->front = (QNode*)malloc(sizeof(QNode)); // 创建一个空节点
    if (Q->front == NULL) {
        Q->rear = NULL;
        return false; // 检查内存分配
    }

    Q->front->next = NULL; // 空节点的下一个指针指向NULL
    Q->rear = Q->front; // front 和 rear 指向同一个空节点
    Q->length = 0; // 初始化长度为0
    return true;
}

3.  入队


// 入队操作
bool EnQueue(LinkQueue* Q, int e) {
    QNode* p = (QNode*)malloc(sizeof(QNode)); // 创建新节点
    if (p == NULL) return false; // 检查内存分配
    p->data = e; // 设置节点数据
    p->next = NULL; // 新节点的下一个指针指向NULL

    Q->rear->next = p; // 将新节点链接到队列尾
    Q->rear = p; // 更新队列尾指针

    if (Q->length == 0) {
        Q->front = p; // 如果队列之前为空，更新队列头指针
    }

    Q->length++; // 更新队列长度
    return true; // 返回成功
}

4.  出队


// 出队操作
bool DeQueue(LinkQueue* Q, int* e) {
    // 判断队列是否为空
    if (Q->length == 0) return false;
    *e = Q->front->data; // 获取队头元素
    QNode* p = Q->front; // 保存当前头节点
    Q->front = p->next; // 更新队头指针
    free(p); // 释放原头节点
    Q->length--; // 更新队列长度
    return true; // 返回成功
}

5. 获取队头元素


// 获取队列头元素
bool GetHead(LinkQueue Q, int* e) {
    // 判断队列是否为空
    if (Q.length == 0) return false;
    *e = Q.front->data; // 获取队头元素
    return true; // 返回成功
}

6. 检查队列是否为空


// 判断队列是否为空
bool isEmpty(LinkQueue Q) {
    return Q.length == 0; // 如果长度为0，则队列为空
}

7. 获取队列长度


// 获取队列的长度
int LengthQueue(LinkQueue Q) {
    return Q.length; // 返回队列长度
}

四、总代码（C语言）

1. 顺序存储结构-使用示例

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

#define MaxSize 50 // 定义队列的最大容量为50

// 定义顺序队列的结构体
typedef struct {
    int data[MaxSize]; // 存储队列元素的数组
    int front;         // 队列头指针，指向队列的第一个元素
    int rear;          // 队列尾指针，指向队列的最后一个元素的下一个位置
} SqQueue;

// 初始化队列
void InitQueue(SqQueue* Q) {
    Q->front = 0; // 将队列头指针初始化为0
    Q->rear = 0;  // 将队列尾指针初始化为0
}

// 判断队列是否为空
bool isEmpty(SqQueue Q) {
    return Q.front == Q.rear; // 如果头指针和尾指针相等，则队列为空
}

// 入队操作
bool EnQueue(SqQueue* Q, int e) {
    // 判断队列是否已满，使用环形队列的特性
    if ((Q->rear + 1) % MaxSize == Q->front) return false;
    Q->data[Q->rear] = e; // 将元素e插入到队列尾
    Q->rear = (Q->rear + 1) % MaxSize; // 更新尾指针
    return true; // 返回成功
}

// 出队操作
bool DeQueue(SqQueue* Q, int* e) {
    // 判断队列是否为空
    if (Q->front == Q->rear) return false;
    *e = Q->data[Q->front]; // 将队列头元素赋值给e
    Q->front = (Q->front + 1) % MaxSize; // 更新头指针
    return true; // 返回成功
}

// 获取队列的长度
int LengthQueue(SqQueue Q) {
    // 计算队列当前长度
    return (Q.rear + MaxSize - Q.front) % MaxSize;
}

// 获取队列头元素
bool GetHead(SqQueue Q, int* e) {
    // 判断队列是否为空
    if (Q.front == Q.rear) return false;
    *e = Q.data[Q.front]; // 将队列头元素赋值给e
    return true; // 返回成功
}



int main() {
    SqQueue Q;
    InitQueue(&Q); // 初始化队列

    // 入队操作
    for (int i = 1; i <= 5; i++) {
        if (EnQueue(&Q, i)) {
            printf("入队: %d\n", i);
        }
        else {
            printf("队列已满，无法入队: %d\n", i);
        }
    }

    // 获取队头元素
    int head;
    if (GetHead(Q, &head)) {
        printf("队头元素: %d\n", head);
    }
    else {
        printf("队列为空，无法获取队头元素。\n");
    }

    // 输出队列长度
    printf("当前队列长度: %d\n", LengthQueue(Q));

    // 出队操作
    int e;
    while (!isEmpty(Q)) {
        if (DeQueue(&Q, &e)) {
            printf("出队: %d\n", e);
        }
        else {
            printf("队列为空，无法出队。\n");
        }
    }

    // 再次检查队列是否为空
    if (isEmpty(Q)) {
        printf("队列现在为空。\n");
    }

    return 0;
}

2. 链式存储结构

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

// 定义链表节点
typedef struct QNode {
    int data;              // 存储数据
    struct QNode* next;   // 指向下一个节点的指针
} QNode;

// 定义链式队列
typedef struct {
    QNode* front;         // 队列头指针
    QNode* rear;          // 队列尾指针
    int length;           // 队列长度
} LinkQueue;

// 初始化队列
bool InitQueue(LinkQueue* Q) {
    Q->front = (QNode*)malloc(sizeof(QNode)); // 创建一个空节点
    if (Q->front == NULL) {
        Q->rear = NULL;
        return false; // 检查内存分配
    }

    Q->front->next = NULL; // 空节点的下一个指针指向NULL
    Q->rear = Q->front; // front 和 rear 指向同一个空节点
    Q->length = 0; // 初始化长度为0
    return true;
}

// 判断队列是否为空
bool isEmpty(LinkQueue Q) {
    return Q.length == 0; // 如果长度为0，则队列为空
}

// 入队操作
bool EnQueue(LinkQueue* Q, int e) {
    QNode* p = (QNode*)malloc(sizeof(QNode)); // 创建新节点
    if (p == NULL) return false; // 检查内存分配
    p->data = e; // 设置节点数据
    p->next = NULL; // 新节点的下一个指针指向NULL

    Q->rear->next = p; // 将新节点链接到队列尾
    Q->rear = p; // 更新队列尾指针

    if (Q->length == 0) {
        Q->front = p; // 如果队列之前为空，更新队列头指针
    }

    Q->length++; // 更新队列长度
    return true; // 返回成功
}

// 出队操作
bool DeQueue(LinkQueue* Q, int* e) {
    // 判断队列是否为空
    if (Q->length == 0) return false;
    *e = Q->front->data; // 获取队头元素
    QNode* p = Q->front; // 保存当前头节点
    Q->front = p->next; // 更新队头指针
    free(p); // 释放原头节点
    Q->length--; // 更新队列长度
    return true; // 返回成功
}

// 获取队列的长度
int LengthQueue(LinkQueue Q) {
    return Q.length; // 返回队列长度
}

// 获取队列头元素
bool GetHead(LinkQueue Q, int* e) {
    // 判断队列是否为空
    if (Q.length == 0) return false;
    *e = Q.front->data; // 获取队头元素
    return true; // 返回成功
}

int main() {
    LinkQueue Q;
    int e;

    // 初始化队列  
    if (!InitQueue(&Q)) {
        printf("初始化队列失败\n");
        return 1; // 初始化失败，退出程序  
    }

    // 检查队列是否为空  
    if (isEmpty(Q)) {
        printf("队列为空\n");
    }

    // 入队操作  
    EnQueue(&Q, 10);
    EnQueue(&Q, 20);
    EnQueue(&Q, 30);

    // 获取队列长度  
    printf("队列长度: %d\n", LengthQueue(Q));

    // 获取队列头元素  
    if (GetHead(Q, &e)) {
        printf("队列头元素: %d\n", e);
    }

    // 出队操作并打印  
    while (!isEmpty(Q)) {
        if (DeQueue(&Q, &e)) {
            printf("出队元素: %d\n", e);
        }
    }

    // 再次检查队列是否为空  
    if (isEmpty(Q)) {
        printf("队列为空\n");
    }

    // 清理工作
    // 释放所有节点
    QNode* current = Q.front;
    while (current != NULL) {
        QNode* temp = current;
        current = current->next;
        free(temp);
    }

    return 0;
}

参考：

1. 数据结构-栈

2. 数据结构-线性表-了解循环链表

3. 数据结构-线性表-单链表

0X78
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构---队列及其应用
CS专业追想日记
10-08 1457
实验目录一、实验目的二、实验内容三、实验步骤四、实验代码一、队列的定义二、算法的初始化和实现五、总结 一、实验目的 1.掌握队列的基本概念、基本操作和基本使用方式。 2.掌握循环队列的类型定义以及实现方法。 3.掌握循环队列的基本操作:初始化、入队、出队、队空判断、获取队头元素。 4.掌握循环队列的实现和简单应用。 5.能够清楚理解循环队列中空间的重用思想。 二、实验内容 1.设计和实现一个队列数据结构,且采用循环队列实现方法。 2.实现循环队列的各种操作,包括循环队列的初始化、出入队、清空和释放等。 3.
数据结构-队列实验报告.docx
11-29
数据结构-队列实验报告 本实验报告的主要目标是设计和实现一个队列数据结构，包括链队列、顺序队列和循环队列三个部分。通过对每种队列的设计和实现，学生可以更好地理解队列的基本操作和实现原理。 一、需求分析 ...
Educoder头歌数据结构-队列基本运算的实现及其应用
qq_50848214的博客
11-05 9118
**头歌实践平台答案educoder ** 数据结构-队列基本运算的实现及其应用 第1关：顺序队列的实现 /************************************************************* date: January 2019 循环顺序队列 实现文件 **************************************************************/ void SQ_In(SqQueue *Q, ElemType e) /
C语言数据结构-队列
Flin
03-13 2749
队列的特征： 特殊的线性表，先进先出(FIFO) (1)数据：对于非空的队列，表头没有直接前驱，表尾没有直接后继，其他有且仅有一个直接前驱和一个直接后继。 (2)操作：只允许在表尾插入数据，在表头删除数据 ...
【头歌】数据结构-队列的应用
wx_15774293141的博客
05-25 6589
任务描述本关任务：编写一个循环队列，实现入队、出队操作，判断队空、队满等特殊情况。相关知识为了完成本关任务，你需要掌握：1.循环队列定义，2.入队、出队的定义，3.队空、队满的情况。循环队列定义循环队列将数组存储区看成是一个首尾相接的环形区域（下图）。当数据存放到尾地址后，下一个地址就跳转到首地址。循环队列定义如下：入队出队定义入队操作：队列未满，在队尾插入一个元素item，使得，若超过存储空间则尾指针索引取模；出队操作：队列不空，返回队首元素值，并移除队首元素front+1。
数据结构-队列（Queue）
热门推荐
修心
01-22 2万+
队列（Queue）   队列的基本概念   定义   队列（Queue）。队列简称队。是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。向队列中插入元素称为入队或进队；删除元素称为出队或离队。其操作特性为先进后出（First In Last Out，FIFO），并且只允许在队尾进，队头出。   队头（Front）：允许删除的一端，又称队首   队尾（Rear）：允许插入的一端   空队列：不包含任何元素的空表   队列的基本操作   1）InitQueue（&Q）：初始化队
GO语言-数据结构-队列
qq522044637的博客
08-05 2580
GO语言-数据结构-队列（顺序存储结构和链式存储结构）
【详细剖析】数据结构-队列（queue）
weixin_64524066的博客
01-16 1815
一看就懂-特殊的链表->队列（queue）
数据结构-队列（队列的基本操作）
Eddy的博客
08-02 2064
队列 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 ...
数据结构-队列及其链表方式实现
Eliauk_U的博客
04-05 2599
目录 1.队列的概念 二.队列的实现 1.基本结构 2.常见接口 1.QueueInit函数-对队列结构进行初始化 2.QueuePush函数-队尾入队列 3.QueuePop函数-队头出数据 4.QueueBack函数-获取队尾元素 5.QueueSize函数-获取队列有效元素个数 6.QueueEmpty函数-判断队列是否为空 7.QueueDestroy函数-队列的销毁 1.队列的概念 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队
数据结构-队列的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 队列的部分实现代码，详细介绍参考数据结构--队列的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
漫话数据结构-队列的定义.pptx
11-03
在众多的数据结构中，队列是一种基本且重要的类型，尤其在处理顺序访问和优先级的问题时显得尤为关键。 队列的定义基于一个简单的理念：“先进先出”(First In First Out, FIFO)。它是一种线性数据结构，允许在结构...
基于C语言的数据结构-队列queue
06-25
在本主题“基于C语言的数据结构-队列queue”中，我们将深入探讨如何在C语言中实现队列的数据结构。 队列的基本操作包括： 1. **入队**（Enqueue）：将元素添加到队列的末尾。 2. **出队**（Dequeue）：移除并返回...
数据结构之---堆（2）
2301_81684056的博客
08-15 634
出堆是指将堆顶数据出堆。出堆完成后要保证剩余数据还是满足原来堆的性质。所以我们把堆顶数据和堆底最后一个数据交换，取出新堆底数据，之后通过向下调整算法将剩下的数据重新排列成一个堆。大堆经过出堆操作得出的数据是升序的小堆经过出堆操作得出的数据是降序的。
深入理解MySQL索引：原理、数据结构与优化策略
乙壳虫的博客
08-16 911
索引类似于一本书的目录，它可以帮助我们快速定位到需要的内容。没有索引时，MySQL 需要遍历整个表来找到目标记录，而索引通过构建特定的结构，可以加速查找的过程。索引的主要作用是提高数据库查询效率，减少数据库检索的行数，从而提升查询速度。B-Tree 索引：这是 MySQL 中最常见的索引结构，适用于大多数场景。B-Tree 是平衡树的一种，能够保持数据有序，从而加快查找速度。哈希索引（Hash Index）：通过将键映射为固定大小的哈希值来加速查找，适用于精确查找。
数据结构之树的存储结构
最新发布
DKPT的博客
08-16 569
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
数据结构——时间复杂度和空间复杂度
2301_80373479的博客
08-15 923
带你了解时间复杂度和空间复杂度
数据结构-队列的应用
07-28
回答: 队列是一种常见的数据结构，它遵循先进先出（FIFO）的原则。队列的应用非常广泛。其中一种应用是在操作系统中进行进程调度。操作系统使用队列来管理进程的执行顺序，确保每个进程按照一定的规则得到执行的机会。另一个应用是在计算机网络中进行数据传输。数据包在网络中按照队列的方式进行传输，以确保数据的有序性和可靠性。此外，队列还可以用于实现缓冲区，任务调度，消息传递等场景。总之，队列作为一种简单而有效的数据结构，在计算机科学和软件工程中有着广泛的应用。\[2\]\[3\] #### 引用[.reference_title] - *1* *2* *3* [算法与数据结构-队列的详解以及应用](https://blog.csdn.net/qq_53283658/article/details/122463796)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

0X78

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

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

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

打赏作者

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

抵扣说明：

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

余额充值