【C语言】队列(Queue)数据结构的实现与分析

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

typedef int QDataType;

// 链式结构：表示队列节点
typedef struct QListNode
{
    struct QListNode* next;  // 指向下一个节点
    QDataType val;           // 节点存储的数据
} QNode;

// 队列的结构
typedef struct Queue
{
    QNode* phead;   // 队头指针
    QNode* ptail;   // 队尾指针  
    int size;       // 队列元素个数
} Queue;

核心设计特点

链式存储结构：使用单向链表实现，避免数组实现的容量限制
双指针设计 ：同时维护队头(phead)和队尾(ptail)指针
大小记录 ：使用size变量记录元素个数，避免遍历计数
泛型支持 ：通过typedef可轻松修改数据类型

队列操作实现详解

1. 初始化与销毁

复制代码

// 初始化队列
void QueueInit(Queue* q)
{
    assert(q);
    q->phead = NULL;
    q->ptail = NULL;
    q->size = 0;
}

// 销毁队列
void QueueDestry(Queue* q)
{
    assert(q);
    QNode* cur = q->phead;
    while (cur)
    {
        QNode* next = cur->next;
        free(cur);
        cur = next;
    }
    q->phead = NULL;
    q->ptail = NULL;
    q->size = 0;
}

关键点分析：

初始化时所有指针置为NULL，size设为0
销毁时遍历整个链表，释放每个节点内存
最后重置所有指针和size，避免野指针

2. 入队操作 (QueuePush)

复制代码

// 队尾入队列
void QueuePush(Queue* q, QDataType x)
{
    assert(q);
    QNode* node = (QNode*)malloc(sizeof(QNode));
    if (node == NULL)
    {
        perror("malloc fail");
        return;
    }
    
    node->next = NULL;
    node->val = x;
    
    if (q->phead == NULL)  // 空队列情况
    {
        q->phead = node;
        q->ptail = node;
    }
    else  // 非空队列
    {
        q->ptail->next = node;
        q->ptail = node;
    }
    q->size++;
}

算法分析：

时间复杂度：O(1)，直接操作尾指针
空间复杂度：O(1)，每次分配一个节点
边界处理：正确处理空队列和非空队列两种情况
内存管理：检查malloc是否成功

3. 出队操作 (QueuePop)

复制代码

// 队头出队列
void QueuePop(Queue* q)
{
    assert(q);
    assert(q->size != 0);

    // 一个节点的情况
    if (q->phead->next == NULL)
    {
        free(q->phead);
        q->phead = NULL;
        q->ptail = NULL;
    }
    else  // 多个节点的情况
    {
        QNode* temp = q->phead->next;
        free(q->phead);
        q->phead = temp;    
    }
    q->size--;
}

关键改进点：

原注释代码存在问题：当只有一个节点时，没有正确处理尾指针
修正后的代码明确区分单节点和多节点情况
单节点情况需要同时重置头尾指针，避免野指针

4. 访问操作

复制代码

// 获取队列头部元素
QDataType QueueFront(Queue* q)
{
    assert(q);
    assert(q->phead);  // 确保队列不为空
    return q->phead->val;
}

// 获取队列队尾元素  
QDataType QueueBack(Queue* q)
{
    assert(q);
    assert(q->ptail);  // 确保队列不为空
    return q->ptail->val;
}

安全机制：

使用assert确保在空队列上不会执行非法访问
直接通过头尾指针访问，时间复杂度O(1)

5. 状态查询操作

复制代码

// 获取队列中有效元素的个数
int QueueSize(Queue* q)
{
    assert(q);
    return q->size;  // O(1)时间复杂度
}

// 检测队列是否为空
bool QueueEmpty(Queue* q)
{
    assert(q);
    return q->size == 0;
}

设计优势：

通过维护size变量，所有状态查询都是O(1)时间复杂度
避免了遍历链表计数的O(n)开销

功能测试与验证

测试代码分析 (test.c)

复制代码

#include "queue.h"

int main()
{
    Queue q;
    // 初始化
    QueueInit(&q);
    
    // 入队列测试
    QueuePush(&q, 1);
    QueuePush(&q, 2);
    printf("%d ", QueueFront(&q));  // 预期输出: 1
    
    // 出队列测试
    QueuePop(&q);  // 移除1
    
    // 继续入队列
    QueuePush(&q, 3);
    QueuePush(&q, 4);
    QueuePush(&q, 5);
    
    // 遍历输出剩余元素
    while (!QueueEmpty(&q))
    {
        printf("%d ", QueueFront(&q));  // 预期输出: 2 3 4 5
        QueuePop(&q);
    }
    printf("\n");
    
    QueueDestry(&q);
    return 0;
}

测试结果 ：程序输出 1 2 3 4 5，验证了队列的FIFO特性。

扩展测试建议

复制代码

// 建议添加的测试用例
void TestQueueComprehensive() {
    Queue q;
    QueueInit(&q);
    
    // 测试1: 空队列操作
    printf("空队列大小: %d\n", QueueSize(&q));  // 应为0
    printf("队列是否为空: %s\n", QueueEmpty(&q) ? "是" : "否");  // 应为"是"
    
    // 测试2: 单元素队列
    QueuePush(&q, 10);
    printf("单元素队头: %d, 队尾: %d\n", QueueFront(&q), QueueBack(&q));  // 都应为10
    
    // 测试3: 多元素队列
    QueuePush(&q, 20);
    QueuePush(&q, 30);
    printf("三元素队头: %d, 队尾: %d\n", QueueFront(&q), QueueBack(&q));  // 10, 30
    
    // 测试4: 出队操作
    QueuePop(&q);
    printf("出队后队头: %d\n", QueueFront(&q));  // 应为20
    
    QueueDestry(&q);
}

性能分析与应用场景

时间复杂度分析

入队(QueuePush): O(1)
出队(QueuePop): O(1)
访问队头/队尾: O(1)
获取大小/判空: O(1)
销毁队列: O(n)

空间复杂度分析

每个元素需要额外的指针空间
总体空间复杂度为O(n)

应用场景

广度优先搜索(BFS): 遍历树或图结构
消息队列: 任务调度系统
缓冲区: 数据流处理
打印机队列: 多任务打印管理
CPU调度: 进程调度算法

实现优势与改进建议

实现优势

高效的入队出队操作：所有核心操作都是O(1)时间复杂度
动态扩容：链式结构自然支持动态增长
内存安全：完善的断言检查和内存释放
清晰的接口设计：每个函数职责单一

改进建议

错误处理增强：malloc失败时可提供更详细的错误信息
迭代器支持：可添加遍历队列的功能
泛型改进：使用void指针支持更广泛的数据类型
线程安全：在多线程环境中添加锁机制

总结

通过分析这个队列实现，我们看到了链式队列的经典设计模式：

双指针设计：头尾指针分别指向队列两端，实现高效的入队出队
大小维护：通过size变量避免遍历计数，提升性能
边界处理：正确处理空队列、单元素队列等边界情况
内存管理：完善的内存分配和释放机制

这个实现很好地体现了队列的FIFO特性，所有核心操作都达到了最优时间复杂度，是一个高质量的数据结构实现。理解这种基础数据结构的实现原理，对于学习更复杂的算法和系统设计具有重要意义。