数据结构：队列

已于 2024-08-01 00:03:08 修改
阅读量696 收藏 10
点赞数 16
分类专栏： 数据结构 文章标签： 数据结构
于 2024-07-31 23:51:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74150890/article/details/140665561
版权

目录

一、【队列】

1.1 队列的定义

1.2 队列的基本操作

二、【队列的类型】

2.1 顺序队列

2.1.1 概述

2.1.2 接口实现

1. 初始化队列

2. 入队

3. 出队

4.  查看队头

5.  查看队尾

6.  检查队列是否为空

7.  获取队列大小

8.  销毁队列

2.2 循环队列

2.2.1 概述

1. 入队操作

2. 出队操作

3. 判断队列是否满

2.3 双端队列

2.3.1 概述

2.3.2 特殊的双端队列 

三、【完整代码】

一、【队列】

1.1 队列的定义

    队列是一种先进先出的数据结构。第一个入队列的元素将是第一个被移除的元素。可以将队列想象成一个排队的人，先到的人先得到服务。

    在队列中，允许插入的一端称为队尾，而允许删除的一端称为队头。当一个元素被添加到队列时，它会被放置在队尾；而当一个元素从队列中被移除时，它会从队头被取出。

1.2 队列的基本操作

队列的基本操作包括：

  • 入队（Enqueue）: 将一个元素添加到队列的末尾。

  • 出队（Dequeue）: 移除并返回队列的头部元素。

  • 查看队头（Peek/Front）: 返回队列的头部元素，但不移除它。

  • 查看队尾（Back）: 返回队列的尾部元素，但不移除它。

  • 检查队列是否为空（IsEmpty）: 判断队列中是否有元素。

  • 获取队列大小（Size）: 返回队列中元素的数量。

  • 初始化队列（Init）: 初始化队列，准备使用。

  • 销毁队列（Destroy）: 清理队列，释放相关资源。

二、【队列的类型】

注意：本文，仅实现顺序队列的完整代码

2.1 顺序队列

2.1.1 概述

顺序队列使用数组或链表来实现队列的基本操作。通过两个指针（或索引）来跟踪队头和队尾的位置，从而进行元素的入队和出队操作。

1. 使用数组实现：

#define MAX_SIZE 100 // 队列最大容量

// 顺序队列结构
typedef struct {
    int data[MAX_SIZE]; // 存储队列元素的数组
    int front;          // 队头索引
    int rear;           // 队尾索引
    int size;           // 当前队列大小
} ArrayQueue;

2. 使用链表实现：

// 节点结构
typedef struct Node {
    int data;              // 存储数据
    struct Node *next;     // 指向下一个节点的指针
} Node;

// 队列结构
typedef struct {
    Node *front; // 队头指针
    Node *rear;  // 队尾指针
    int size;    // 当前队列大小
} Queue;
2.1.2 接口实现

顺序队列的基本操作，包括初始化、入队、出队、查看队头、查看队尾、检查队列状态、获取队列大小和销毁队列的实现。

1. 初始化队列

初始化队列，设置 front 和 rear 为 NULL，队列大小为 0。

void initQueue(SeqQueue* queue) {
    queue->front = NULL;
    queue->rear = NULL;
    queue->size = 0;
}
2. 入队

在队列中添加元素，首先创建一个新节点。如果队列为空，则将 front 和 rear 都指向新节点；否则，将新节点添加到 rear 的后面，并更新 rear。

bool enqueue(SeqQueue* queue, int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (!newNode) {
        return false; // 内存分配失败
    }
    newNode->data = value;
    newNode->next = NULL; // 新节点的下一个节点为 NULL

    if (isEmpty(queue)) {
        queue->front = newNode; // 队列为空时，front 和 rear 都指向新节点
        queue->rear = newNode;
    } else {
        queue->rear->next = newNode; // 将新节点添加到队尾
        queue->rear = newNode; // 更新 rear 指针
    }
    queue->size++;
    return true;
}
3. 出队

从队列中移除元素，首先检查队列是否为空。如果不为空，将 front 指向的节点移除，并更新 front 指针。如果队列变为空，还需要将 rear 置为 NULL。

bool dequeue(SeqQueue* queue, int* value) {
    if (isEmpty(queue)) {
        return false; // 队列为空
    }
    Node* temp = queue->front; // 保存队头节点
    *value = temp->data; // 获取队头元素
    queue->front = queue->front->next; // 更新 front 指针

    if (queue->front == NULL) {
        queue->rear = NULL; // 如果队列变为空，更新 rear 为 NULL
    }
    free(temp); // 释放队头节点
    queue->size--;
    return true;
}
4.  查看队头

查看队头元素而不移除它。

bool peekFront(SeqQueue* queue, int* value) {
    if (isEmpty(queue)) {
        return false; // 队列为空
    }
    *value = queue->front->data; // 返回队头元素
    return true;
}
5.  查看队尾

查看队尾元素而不移除它。

bool peekBack(SeqQueue* queue, int* value) {
    if (isEmpty(queue)) {
        return false; // 队列为空
    }
    *value = queue->rear->data; // 返回队尾元素
    return true;
}
6.  检查队列是否为空

判断队列中是否有元素。

bool isEmpty(SeqQueue* queue) {
    return queue->size == 0;
}
7.  获取队列大小

返回队列中元素的数量。

int size(SeqQueue* queue) {
    return queue->size;
}
8.  销毁队列

清理队列，释放相关资源。

void destroyQueue(SeqQueue* queue) {
    while (!isEmpty(queue)) {
        int value;
        dequeue(queue, &value); // 逐个出队并释放节点
    }
}

2.2 循环队列

2.2.1 概述

循环队列是一种对顺序队列的改进，通过将队列的尾部与头部连接起来，利用数组的循环特性来避免空间浪费。

1. 入队操作

在循环队列中，入队操作的步骤如下：

queue->data[queue->rear] = value; // 插入元素
queue->rear = (queue->rear + 1) % MAX_SIZE; // 更新队尾指针
  • 插入元素：queue->data[queue->rear] = value; 将新元素 value 放入 rear 指向的位置。
  • 更新队尾指针：queue->rear = (queue->rear + 1) % MAX_SIZE; 使用取余运算确保 rear 在达到 MAX_SIZE 后能够回绕到数组的开头，实现循环效果。
2. 出队操作

出队操作的步骤如下：

*value = queue->data[queue->front]; // 获取队头元素
queue->front = (queue->front + 1) % MAX_SIZE; // 更新队头指针
  • 获取队头元素：*value = queue->data[queue->front]; 取出 front 指向的元素。
  • 更新队头指针：queue->front = (queue->front + 1) % MAX_SIZE; 更新 front 指针，以便指向下一个元素。
3. 判断队列是否满
return (queue->rear + 1) % MAX_SIZE == queue->front; // 队列满
  • 在循环队列中，队列满的条件是 rear 的下一位置与 front 相等，即：
    (rear+1)% MAX_SIZE==front(rear+1)%MAX_SIZE==front
  • 这里的 MAX_SIZE 是队列的最大容量。使用取余运算可以确保 rear 在数组的边界处回绕。

示例：
假设 MAX_SIZE = 5，队列的状态如下：

队列索引01234
元素123
front0
rear12
  • 此时 rear 是 3，front 是 0。如果 rear 再增加 1，变为 4，队列仍然不满。
  • 当 rear 变为 0（即 (4 + 1) % 5），此时 front 仍然是 0，队列就满了。

2.3 双端队列

2.3.1 概述

双端队列允许在两端进行插入和删除操作。它可以通过数组或链表实现，提供灵活的操作方式。

1. 使用数组实现：使用一个固定大小的数组，并维护两个指针：front（队头指针）和 rear（队尾指针）。在实现时，需要注意数组的循环利用。

#define MAX_SIZE 100 // 定义双端队列的最大容量

typedef struct {
    int data[MAX_SIZE]; // 存储双端队列元素的数组
    int front;          // 队头指针
    int rear;           // 队尾指针
} Deque;

2. 使用链表实现：使用双向链表实现双端队列，每个节点有两个指针，分别指向前一个节点和后一个节点。

typedef struct Node {
    int data;               // 存储数据
    struct Node *next;      // 指向下一个节点的指针
    struct Node *prev;      // 指向前一个节点的指针
} Node;

typedef struct {
    Node *front; // 队头指针
    Node *rear;  // 队尾指针
} Deque;
2.3.2 特殊的双端队列 

1.输入受限：能在一端能进行插入删除操作，另一端只能进行删除操作

2.输出受限：能在一端能进行插入删除操作，另一端只能进行插入操作

三、【完整代码】

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

// 节点结构
typedef struct Node {
    int data;              // 存储数据
    struct Node *next;     // 指向下一个节点的指针
} Node;

// 队列结构
typedef struct {
    Node *front; // 队头指针
    Node *rear;  // 队尾指针
    int size;    // 当前队列大小
} Queue;

// 初始化队列
void init(Queue *queue) {
    queue->front = NULL; // 队头指针初始化为NULL
    queue->rear = NULL;  // 队尾指针初始化为NULL
    queue->size = 0;     // 当前队列大小初始化为0
}

// 销毁队列
void destroy(Queue *queue) {
    Node *current = queue->front;
    while (current != NULL) {
        Node *next = current->next; // 保存下一个节点
        free(current);               // 释放当前节点
        current = next;             // 移动到下一个节点
    }
    queue->front = NULL; // 清空队头指针
    queue->rear = NULL;  // 清空队尾指针
    queue->size = 0;     // 重置队列大小
}

// 入队（Enqueue）
bool enqueue(Queue *queue, int value) {
    Node *newNode = (Node *)malloc(sizeof(Node)); // 创建新节点
    if (newNode == NULL) {
        return false; // 内存分配失败
    }
    newNode->data = value; // 设置节点数据
    newNode->next = NULL;  // 新节点的下一个指针设为NULL

    if (queue->rear != NULL) {
        queue->rear->next = newNode; // 如果队列不为空，将新节点添加到队尾
    } else {
        queue->front = newNode; // 如果队列为空，新节点是队头
    }
    queue->rear = newNode; // 更新队尾指针
    queue->size++;         // 更新队列大小
    return true;
}

// 出队（Dequeue）
bool dequeue(Queue *queue, int *value) {
    if (queue->front == NULL) {
        return false; // 队列为空，无法出队
    }
    Node *nodeToDelete = queue->front; // 获取队头节点
    *value = nodeToDelete->data;        // 返回队头数据
    queue->front = queue->front->next; // 更新队头指针

    if (queue->front == NULL) {
        queue->rear = NULL; // 如果队列为空，队尾也设为NULL
    }

    free(nodeToDelete); // 释放队头节点
    queue->size--;      // 更新队列大小
    return true;
}

// 查看队头（Peek/Front）
bool peekFront(Queue *queue, int *value) {
    if (queue->front == NULL) {
        return false; // 队列为空，无法查看队头
    }
    *value = queue->front->data; // 返回队头元素
    return true;
}

// 查看队尾（Back）
bool peekBack(Queue *queue, int *value) {
    if (queue->rear == NULL) {
        return false; // 队列为空，无法查看队尾
    }
    *value = queue->rear->data; // 返回队尾元素
    return true;
}

// 检查队列是否为空（IsEmpty）
bool isEmpty(Queue *queue) {
    return queue->size == 0; // 如果大小为0，则队列为空
}

// 获取队列大小（Size）
int size(Queue *queue) {
    return queue->size; // 返回当前队列大小
}

// 测试链表实现的队列
int main() {
    Queue queue;
    init(&queue); // 初始化队列

    // 入队操作
    enqueue(&queue, 10);
    enqueue(&queue, 20);
    enqueue(&queue, 30);

    // 查看队头和队尾
    int value;
    if (peekFront(&queue, &value)) {
        printf("队头: %d\n", value);
    }
    if (peekBack(&queue, &value)) {
        printf("队尾: %d\n", value);
    }

    // 出队操作
    while (dequeue(&queue, &value)) {
        printf("出队: %d\n", value);
    }

    // 检查队列是否为空
    printf("队列是否为空: %s\n", isEmpty(&queue) ? 1 : 0);

    // 销毁队列
    destroy(&queue);
    return 0;
}

猫战士学习中
关注
  • 16
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图解数据结构(04) --队列
姜皓的博客
12-30 3070
队列1、什么是队列2、队列的基本操作【1】入队【2】出队循环队列循环队列代码实现3、队列的应用双端队列优先队列 1、什么是队列 假如公路上有一条单行隧道，所有通过隧道的车辆只允许从隧道入口驶入，从隧道出口驶出，不允许逆行，如下图： 因此，要想让车辆驶出隧道，只能按照它们驶入隧道的顺序，先驶入的车辆先驶出，后驶入的车辆后驶出，任何车辆都无法跳过它前面的车辆提前驶出： 队列（queue）是一种线性...
python数据结构：队列Queue
01-20
1.抽象数据类型Queue 1.1 1.2 2.Python实现ADT Queue 采用List来容纳Queue的数据项 将List首端作为队列尾端；List的末端作为队列首端 enqueue()复杂度为O(n) dequeue()复杂度为O(1) class Queue: #初始化 def _...
数据结构 队列入队，出队编程的例子
Z_Dream_ST的博客
10-29 8093
队列是先入先出的，即先入队的数据先出队 下面这个程序具有入队，出队，遍历队列数据的功能 #include #include typedef struct { int* pBase; int front; int rear; }QUEUE; //初始化静态队列，创建能够存储5个数据的静态队列 void Init_queue(QUEUE* _pQ) {
数据结构——队列（Queue）
XLZ_44847的博客
01-08 1381
队列，顾名思义，作为有素质的新时代公民，在现实生活中我们常常会遇到排队的场景，而队列就是借此种情形衍生出来的数据结构形式。在需要排队的时候，我们面对一个队列会自觉地站在队尾。随着当队伍中的人慢慢出队，我们的位置也从队尾慢慢移动到了队头，当我们成为一个队的第一个人时，我们就明白终于轮到我们出队了。队列这种数据结构组织数据的形式和排队的场景十分相似，均为先进先出，后进后出的规则。在掌握了栈这种数据结构的基础之上，我们再来学习队列会比较轻松。
数据结构——队列
m0_49687898的博客
04-22 1804
一、队列的概念 二、队列的实现 1. 创建队列 2. 队列初始化 3. 销毁队列 4. 入队 5. 出队 6. 判空 7. 获取队列元素个数 8. 获取队列头部 9. 获取队列尾部元素 三、总代码 Queue.h Queue.c Test.c
Java实现环形队列（入队、出队）
one_py的博客
07-20 2884
public class Class_queue {     private int q_head;     private int q_tail;     private int[] queue;     private int len;     private int length;     public Class_queue(int length) {         super();...
数据结构：队列（链式存储、顺序存储）
12-07
在这个主题中，我们将专注于队列，一种线性数据结构，它的主要特点在于数据的先进先出（FIFO，First In First Out）。队列在许多算法和程序设计问题中都有广泛的应用，如任务调度、缓冲区管理等。 在C语言中实现...
python数据结构：队列的应用-热土豆问题
12-22
队列作为其中一种基本的数据结构，具有“先进先出”（FIFO，First In First Out）的特点，即新加入的元素总是排在队尾，而最先加入的元素总是第一个被处理。在Python中，我们可以自定义类来实现队列的功能，如上述...
数据结构：链队列
05-30
在众多的数据结构中，链队列是一种常用且实用的结构，尤其适用于处理动态变化的数据集合。本篇文章将详细探讨链队列，包括它的定义、工作原理以及如何在实际编程中实现。 链队列，顾名思义，是基于链表实现的队列...
算法与数据结构：队列
12-02
在计算机科学中，算法与数据结构是至关重要的基础，它们直接影响到程序的效率和性能。队列作为一种基本的数据结构，广泛应用于各种计算机程序设计中，如任务调度、操作系统的缓冲区管理、网络数据包处理等。本文将...
数据结构笔记：双端队列
01-21
双端队列（deque，double-ended queue），是一种具有队列和栈的性质的数据结构。 双端队列中每一端，都可以进行存入和取出，去其中一段，都像一个栈一样。 存取也只限定在两端，不能在中间 双端队列的实现 通过...
C++实战篇(数据结构)：栈、队列
最新发布
08-03
C++实战篇(数据结构)：栈、队列 C++实战篇(数据结构)：栈、队列 C++实战篇(数据结构)：栈、队列 C++实战篇(数据结构)：栈、队列 C++实战篇(数据结构)：栈、队列 C++实战篇(数据结构)：栈、队列 C++实战篇(数据结构)...
【数据结构实验】队列的应用
06-15
能够根据实际情况选择合适的存储结构，解决实际问题。 2.实验内容： 利用循环队列模拟舞伴配对问题： 1、利用循环队列模拟舞伴配对问题。在舞会上，男、女各自排成一队。舞会开始时。依次从男队和女队的队头各出一...
头歌数据结构循环队列及链队列的基本操作
05-18
在本文中，我们将深入探讨头歌数据结构中的两种基本数据结构——循环队列和链队列，以及它们在实现过程中的基本操作。首先，我们来理解这两种数据结构的概念。 循环队列是一种线性数据结构，它模拟了现实生活中的...
数据结构精解：栈和队列
07-16
简述了栈和队列两种数据结构的基本构成和方法
队列 入队，插入，出队，是否队空，队元元素，清空，打印
abc882715的博客
11-22 597
#pragma once #include <windows.h> typedef struct KEEP // { int index; char* name; KEEP* next;}KEEP;typedef struct QUEUE // { int size; KEEP* front; KEEP* back;}QUEUE;/
队列的入队和出队
热门推荐
weixin_44573938的博客
05-28 1万+
队列是一个特殊的线性表，队列简称为“对”。 队列的插入元素的操作称为“入队”或者“入队列”，删除元素的操作称为“出队”或者“出队列”。 那么，队列是如何插入元素和删除元素的呢。 队列有两种存储结构，一种是顺序排列，另一种是链式排列。 队列的元素存放的都是地址连续的单元。而队列的特征是“先进先出”，且队列的入队只允许队尾操作，rear增加一位。队头front不允许修改。队列的出队则相反，只允许队头操作，front增加一位，队尾rear不允许修改。所以为了避免“假溢出”这个问题我以顺序队列的循环队列为例来讲解。
数据结构-----队列
Poison__的博客
07-21 2238
数据结构之队列 数据结构的学习笔记，不妥之处请指正。 文章目录数据结构之队列前言一、先入先出的数据结构1、先入先出的数据结构2、队列的实现3、循环队列4、设计循环队列二、队列和广度优先搜索参考 前言 在数组中，可以通过索引访问 随机 元素。 但是某些情况下，可能需要限制处理的顺序。 下面我们将学习第一个 先入先出（FIFO） 的处理顺序，也就是队列。 一、先入先出的数据结构 1、先入先出的数据结构 在队列中，第一个进入的元素就是第一个被处理的元素（先进先出）。 队列有头有尾，我们平常所说的插
队列的基本操作（入队、出队、清空……）
zillll的博客
05-06 3611
队列的基本操作（入队、出队、清空……） SqQue.h #ifndef __SQQUE_H__ #define __SQQUE_h__ typedef int element; typedef struct SqQue { element *data; //动态定义存储空间大小 int max_len; //存放最多的存储元素个数 int now_len; //当前存放的元素个数 int rear; //队尾下标，下一个入队元素的下标 int f
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值