当前位置：首页 > news >正文

数据结构——队列（Queue）

news 2025/8/5 19:15:00

数据结构——队列（Queue）

一、队列的基本概念

定义
队列（Queue）是一种先进先出（First In First Out，FIFO）的线性数据结构。
特点
• 只允许在**队尾（rear）插入，在队头（front）**删除。
• 插入称为 入队（Enqueue），删除称为 出队（Dequeue）。

二、队列的抽象数据类型（ADT）描述

ADT Queue {Data: 线性序列Operations:enqueue(x)   // 入队dequeue()    // 出队并返回队首peek()       // 查看队首isEmpty()    // 判空size()       // 返回元素个数
}

三、队列的常见应用场景（如任务调度、消息队列、BFS算法等）

• 操作系统：进程/线程就绪队列、打印任务队列
• 网络：TCP 报文重组、消息队列（Kafka、RabbitMQ）
• 算法：BFS 层序遍历、滑动窗口最大值、缓存 LRU
• 前端：JS 事件循环宏任务/微任务队列

四、队列的实现方式

基于数组的静态队列
思路：用一段连续内存存储，维护 front、rear 两个索引。
问题：出队后前面空间浪费 → 采用循环队列。
基于链表的动态队列
思路：用带头指针 front 和尾指针 rear 的单链表，无需考虑容量。
循环队列（Circular Queue）
• 逻辑上把数组视为环，模运算取余。
• 牺牲一个空位或维护计数器区分空/满。
• 优势：O(1) 入队/出队，空间利用率高。

五、队列的基本操作复杂度

操作	数组队列（循环）	链表队列	说明
Enqueue	O(1)	O(1)	尾插
Dequeue	O(1)	O(1)	头删
Peek	O(1)	O(1)	直接读 front
Size	O(1) 或 O(n)	O(1)	若维护计数器
Space	O(n)	O(n)	均与元素数成正比

六、队列的变种与扩展

双端队列（Deque）
两端都可插入删除，可用于滑动窗口最大值、撤销/重做。
优先队列（Priority Queue）
按优先级出队：二叉堆 O(log n)，斐波那契堆 O(1) amortized。
阻塞队列（Blocking Queue）
线程安全，满/空时阻塞等待，用于生产者-消费者。
并发队列（Concurrent Queue）
无锁 CAS 实现（如 Java ConcurrentLinkedQueue），高并发场景。

七、完整代码实现

#define  _CRT_SECURE_NO_WARNINGS 
#include<stdio.h>
#include<stdlib.h>
#define Maxsize 5
typedef int ElemType;
//队列的顺序存储结构和基本运算实现
typedef struct
{ElemType data[Maxsize];int front, rear;
}SqQueue;// 1）初始化队列
void InitQueue(SqQueue & q)
{q.front = q.rear = -1;
}//2) 判断队列是否为空
bool QueueEmpty(SqQueue* q)
{return (q->front == q->rear);
}
// 3)进队列
bool enQueue(SqQueue& q, ElemType e)
{if (q.rear == Maxsize - 1)//队满上溢出return false;q.rear++;q.data[q.rear] = e;return true;
}
// 4)出队列 
bool deQueue(SqQueue& q, ElemType& e)
{if (q.front == q.rear)//队空下溢出return false;q.front++;e = q.data[q.front];return true;
}
bool PrintQueue(SqQueue q)
{if (q.front == q.rear)//队空下溢出return false;int i = 0;while (i <= q.rear){printf("%d->", q.data[i++]);}printf("end\n");return true;
}int main()
{SqQueue	Q1;InitQueue(Q1);int x = 0;scanf("%d", &x);int i = Q1.rear;while (x != 9999 && Q1.rear <Maxsize - 1){enQueue(Q1, x);scanf("%d", &x);}PrintQueue(Q1);return 0;}//为了解决假溢出，引进循环队列 //循环队列会牺牲一个存储单元// 1）初始化队列
void InitQueue1(SqQueue*& q)
{q = (SqQueue*)malloc(sizeof(SqQueue));q->front = q->rear = -1;
}
// 2) 销毁队列
void DestroyQueue1(SqQueue*& q)
{free(q);
}
//3) 判断队列是否为空
bool QueueEmpty1(SqQueue* q)
{return (q->front == q->rear);
}
// 4)进队列
bool enQueue1(SqQueue*& q, ElemType e)
{if ((q->rear+1)%Maxsize==q->front)//队满上溢出return false;q->rear=(q->rear+1)%Maxsize;q->data[q->rear] = e;return true;
}
// 5)出队列 
bool deQueue1(SqQueue*& q, ElemType& e)
{if (q->front == q->rear)//队空下溢出return false;q->front = (q->front+1)%Maxsize;e = q->data[q->front]; return true;
}
//6)判断队满
/*队列的链式存储结构及其基本运算的实现*/typedef struct qnode 
{ElemType data;struct qnode* next;//下一个结点指针
}DataNode;  //链队数据结点的类型
typedef struct 
{DataNode* front;//指向队头结点DataNode* rear;//指向队尾结点
}LinkQuNode;   //链队结点的类型  // 1) 初始化队列
void InitLinkQueue(LinkQuNode*& q)
{q = (LinkQuNode*)malloc(sizeof(LinkQuNode));q->front = q->rear = NULL;
}
void DestroyLinkQueue(LinkQuNode*& q)
{DataNode* pre = q->front, * p;if (pre != NULL){p = pre->next;while (p != NULL){free(pre);pre = p;p = p->next;}free(pre);}free(q);
}
// 3）判断是否为空bool LinkQueueEempty(LinkQuNode* q)
{return (q->rear == NULL);
}// 4)进队列
bool  enLinkQueue(LinkQuNode*& q, ElemType e)
{DataNode* p = (DataNode*)malloc(sizeof(DataNode));p->data = e;p->next = NULL;if (q->rear == q->front) {//如果链队为空,不带头节点的第一个元素入队需要特殊处理q->rear = p;q->front = p;}else{q->rear->next = p;q->rear = p;}return true;
}
//5)出队列
bool deLinkQueue(LinkQuNode*& q, ElemType& e)
{if (q->rear==NULL)//链队为空return false;DataNode* p=q->front;e = p->data;q->front = p->next;  //移动if (q->rear == p)//当出队时，链队只有一个结点需要移动队尾指针q->front = q->rear = NULL;free(p);return true;
}