数据结构队列

1. 队列的基本概念

1.1概念
  • 队列(queue)是限定在⼀端插⼊另⼀端删除的线性表。因此,对队列来说,插⼊那⼀端叫做队尾,插⼊叫⼊队,删除那⼀端叫队头,删除叫做出队。队列中的数据元素遵循先进先出(FIFO,First In First Out)的特性。
  • 队列的⼊队出队顺序就简单多了,⽆论如何操作,⼀种⼊队顺序只对应⼀种出队顺序。
  • 队列在计算机系统中应用非常广泛,例如操作系统中的任务调度 、打印任务排队 、消息队列 、广度优先搜索(BFS) 等场景,都离不开队列这种先进先出的数据结构。
1.2 队列的基本操作
c 复制代码
// 初始化队列
void QueueInit(LinkQueue* q); 
// 销毁队列
void QueueDestroy(LinkQueue* q); 
// 检测队列是否为空,空返回真,否则返回假
bool QueueEmpty(LinkQueue* q); 
// 获取队列中有效元素个数 
int QueueSize(LinkQueue* q);
// 获取队头元素
QDataType QueueFront(LinkQueue* q); 
// 将x⼊队列
void EnQueue(LinkQueue* q, QDataType x); 
// 出队并返回队头数据
QDataType DeQueue(LinkQueue* q); 

说明:QDataType 是队列中存储的数据类型,通常用 typedef 定义为 int 等具体类型;LinkQueue 是链式队列的结构体类型,下文会给出完整定义。

2. 队列的链式存储

2.1 链式队列的结构
  • 队列的链式存储,我们可以选⽤单链表结构,也可以选⽤双向链表结构。他们⼊队对应着在表尾插⼊,出队对应着在表头删除。当然我们完全没必要选择双向链表,因为单链表就可以⾼效实现,还省空间⼀些。双向链表没有优势,每个结点还要多存储⼀个前驱指针,使⽤它纯粹浪费了。

  • 其次这⾥我们选择单链表实现,⼊队就是尾插,出队就是头删。可以带头结点,也可以不带头结点,带头结点的结构略简单⼀点。

  • 链式队列的核心结构如下:用 head 指向队头结点,用 tail 指向队尾结点。入队时在 tail 之后插入新结点并更新 tail,出队时删除 head 指向的结点并更新 head 。带头结点时,head 指向哨兵位头结点,真正的队头元素是 head->next。

c 复制代码
// 链式队列的结点结构
typedef struct QNode {
    QDataType data;      // 数据域
    struct QNode* next;  // 指针域,指向下一个结点
} QNode;

// 链式队列的结构(带头结点)
typedef struct Queue {
    QNode* head;  // 指向哨兵位头结点
    QNode* tail;  // 指向队尾结点
} LinkQueue;

// 初始化队列:创建哨兵位头结点
void QueueInit(LinkQueue* q) {
    q->head = (QNode*)malloc(sizeof(QNode));
    if (q->head == NULL) {
        printf("内存申请失败\n");
        exit(-1);
    }
    q->head->next = NULL;
    q->tail = q->head;  // 空队列时,尾指针也指向哨兵位
}

// 销毁队列:释放所有结点
void QueueDestroy(LinkQueue* q) {
    QNode* cur = q->head;
    while (cur != NULL) {
        QNode* next = cur->next;
        free(cur);
        cur = next;
    }
    q->head = q->tail = NULL;
}

// 检测队列是否为空:空返回真,否则返回假
bool QueueEmpty(LinkQueue* q) {
    return q->head->next == NULL;
}

// 获取队列中有效元素个数
int QueueSize(LinkQueue* q) {
    int size = 0;
    QNode* cur = q->head->next;
    while (cur != NULL) {
        size++;
        cur = cur->next;
    }
    return size;
}

// 获取队头元素(不删除)
QDataType QueueFront(LinkQueue* q) {
    assert(q->head->next != NULL);  // 队列非空
    return q->head->next->data;
}
2.3 出队
c 复制代码
// 入队:在队尾插入新结点
void EnQueue(LinkQueue* q, QDataType x) {
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL) {
        printf("内存申请失败\n");
        exit(-1);
    }
    newnode->data = x;
    newnode->next = NULL;

    q->tail->next = newnode;  // 新结点链接到队尾
    q->tail = newnode;        // 更新尾指针
}
``````c
// 出队:删除队头结点并返回其数据
QDataType DeQueue(LinkQueue* q) {
    assert(q != NULL);
    assert(q->head->next != NULL);  // 队列非空

    QNode* del = q->head->next;     // 待删除的队头结点
    QDataType ret = del->data;      // 保存数据

    q->head->next = del->next;      // 头结点指向下一个结点
    if (q->tail == del) {           // 删除的是最后一个结点
        q->tail = q->head;          // 尾指针回到哨兵位
    }
    free(del);                      // 释放结点
    return ret;
}

注意:当队列中只剩一个结点时,删除后 tail 必须重新指向哨兵位头结点,否则 tail 会变成野指针,后续入队操作将出错。

3. 队列的顺序存储

3.1 顺序队列的结构
  • 顺序存储结构实现队列,⼊队对应尾插,出队对应头删,⽽顺序存储结构直接头删的需要挪动数据时间复杂度为 O(n),如果实现队列的顺序存储结构效率太低,就⽆价值了。所以这⾥可以调整思路,出队头删时,不再挪动数据,⽽是移动队头的下标或指针。

  • 顺序队列的核心结构如下:用数组 a 存储数据,用 front 指向队头下标,用 rear 指向队尾下标。入队时在 rear 处写入数据并让 rear 后移,出队时让 front 后移即可,这样出队的时间复杂度降为 O(1)。

c 复制代码
// 顺序队列的结构
typedef struct SeqQueue {
    QDataType* a;   // 动态数组,存储数据
    int front;      // 队头下标
    int rear;       // 队尾下标
    int capacity;   // 数组容量
} SeqQueue;

// 初始化顺序队列
void SeqQueueInit(SeqQueue* q, int capacity) {
    q->a = (QDataType*)malloc(sizeof(QDataType) * capacity);
    if (q->a == NULL) {
        printf("内存申请失败\n");
        exit(-1);
    }
    q->front = 0;
    q->rear = 0;
    q->capacity = capacity;
}

// 入队:在队尾写入数据
void SeqQueuePush(SeqQueue* q, QDataType x) {
    assert(q->rear < q->capacity);  // 队列未满
    q->a[q->rear] = x;
    q->rear++;
}

// 出队:队头下标后移,不挪动数据
void SeqQueuePop(SeqQueue* q) {
    assert(q->front < q->rear);  // 队列非空
    q->front++;
}

// 获取队头元素
QDataType SeqQueueFront(SeqQueue* q) {
    assert(q->front < q->rear);  // 队列非空
    return q->a[q->front];
}

// 检测队列是否为空
bool SeqQueueEmpty(SeqQueue* q) {
    return q->front == q->rear;
}
3.2 顺序队列的问题
  • 顺序队列的⼀个经典问题就是假溢出问题,队列的存储空间(数组)中明明还有空闲位置,但由于队尾指针rear已经移动到了数组的末尾,导致⽆法再插⼊新元素,系统错误地判断为"队列已满"的现象,这种情况之所以被称为"假"溢出,是因为它并⾮真正的空间耗尽,⽽是⼀种由于数据结构设计缺陷导致的空间浪费。

  • 例如:数组容量为 5,连续入队 5 个元素后 rear 到达下标 5,此时再出队 3 个元素,front 变为 3,数组下标 0~2 已经空闲,但 rear 仍指向末尾,无法继续入队------这就是假溢出。

c 复制代码
// 演示假溢出问题
void DemoFakeOverflow() {
    SeqQueue q;
    SeqQueueInit(&q, 5);

    // 连续入队 5 个元素,rear 到达末尾
    for (int i = 1; i <= 5; i++) {
        SeqQueuePush(&q, i);
    }

    // 出队 3 个元素,front 变为 3,下标 0~2 空闲
    for (int i = 0; i < 3; i++) {
        SeqQueuePop(&q);
    }

    // 此时数组前 3 个位置空闲,但 rear 已到末尾,无法入队
    // SeqQueuePush(&q, 6);  // 触发 assert 失败,即"假溢出"
}

解决思路 :采用循环队列 ,让 rear 到达末尾后回绕到数组开头,从而复用空闲空间。循环队列中通常牺牲一个存储单元来区分队空与队满,即 (rear + 1) % capacity == front 表示队满,front == rear 表示队空。

相关推荐
lcj25115 小时前
[C++] C++11
开发语言·c++·笔记
kaixin_啊啊5 小时前
【三种鲑科鱼类比较基因组学分析鉴定出参与细胞内寄生菌鲑立克次体抗性的功能候选基因】论文学习
学习
一条破秋裤7 小时前
【1117】【内存资源管控】【笔记】
android·笔记
CappuccinoRose8 小时前
Redis 学习文档
redis·后端·学习·缓存·session·非关系型数据库·gossip
qingwufeiyang_5309 小时前
Docker学习笔记2
笔记·学习
Z21-X9 小时前
云原生运维学习笔记:从操作系统底层到 Kubernetes 集群的深度实践
运维·笔记·学习·云原生·kubernetes
Century_Dragon9 小时前
把高压回路“看透” 新能源汽车动力系统拆装与检测实训MR软件
学习
星恒随风10 小时前
MySQL 从零入门(七):索引原理与 B+ 树详解——从磁盘 I/O 到 InnoDB 聚簇索引
linux·服务器·数据库·笔记·mysql
希和20271 天前
江科大 51 单片机笔记:DS18B20 温度传感器 + LCD1602 显示代码详解
笔记·单片机·mongodb
电科_银尘1 天前
【深度学习项目实战·22】灰度图像着色:用小型U-Net学习从灰度到RGB
人工智能·深度学习·学习