C语言 队列 链式结构 实现

一个C语言链式结构实现的队列 mQueue (GCC编译)。

/**
* @brief C语言实现的链式队列
* @author wid
* @date 2013-10-31
*
* @note 若代码存在 bug 或程序缺陷, 请留言反馈, 谢谢!
*/

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

#define TRUE 1
#define FALSE 0

typedef struct Point2D
{
    int x;
    int y;
}ElemType;      //元素结构

typedef struct QNODE
{
    ElemType *pe;
    struct QNODE *next;
}QueueNode;     //队列节点结构

typedef struct MQUEUE
{
    QueueNode *rear;        //队列尾节点
    QueueNode *front;       //队列头节点
    int len;                //队列长度
}mQueue;

//队列方法声明
mQueue *CreateQueue();                          ///创建一个空队列
void DestroyQueue( mQueue *pQueue );            ///销毁队列 pQueue
void ClearQueue( mQueue *pQueue );              ///置空队列 pQueue
int IsEmpty( mQueue *pQueue );                  ///是否为空空队列
int GetLength( mQueue *pQueue );                ///获取队列长度
int EnQueue( mQueue *pQueue, ElemType *pe );    ///将元素pe插入到队尾
int DeQueue( mQueue *pQueue, ElemType **pe );   ///将将队头元素出队
int GetHead( mQueue *pQueue, ElemType **pe );   ///获取队头元素(不出队)
void ForEachQueue( mQueue *pQueue, void (*func)(ElemType *pe) );        ///从队头到队尾依次执行func函数


//队列方法实现
/**
* @brief 创建一个空队列
*
* @return 返回指向新创建的队列的指针
*/
mQueue *CreateQueue()
{
    ///创建队列
    mQueue *pQueue = (mQueue *)malloc( sizeof(mQueue) );

    ///令队头指向队尾
    pQueue->front = pQueue->rear = (QueueNode *)malloc( sizeof(QueueNode) );

    ///队尾的next节点指向NULL
    pQueue->rear->next = NULL;

    ///队头的next节点指向队尾
    pQueue->front->next = pQueue->rear;

    ///初始化队长为 0
    pQueue->len = 0;

    return pQueue;
}

/**
* @brief 销毁队列 pQueue
*
* @param pQueue 指向待销毁的队列
*/
void DestroyQueue( mQueue *pQueue )
{
    QueueNode *tmp = NULL;

    ///释放队列内元素
    while( pQueue->front != NULL )
    {
        tmp = pQueue->front->next;
        free( pQueue->front );
        pQueue->front = tmp;
    }

    ///释放队列
    free( pQueue );
}

/**
* @brief 将队列中的元素全部清除
*
* @param pQueue 指向待置空的队列
*/
void ClearQueue( mQueue *pQueue )
{
    QueueNode *tmp = NULL;

    ///释放队列内元素(保留一队尾节点)
    while( pQueue->front->next != NULL )
    {
        tmp = pQueue->front->next;
        free( pQueue->front );
        pQueue->front = tmp;
    }

    pQueue->len = 0;
}

/**
* @brief 是否为空队列
*
* @param pQueue 指向待检测的队列
*
* @return 若为空则返回 TRUE, 否则返回 FALSE
*/
int IsEmpty( mQueue *pQueue )
{
    return pQueue->len == 0 ? TRUE : FALSE;
}

/**
* @brief 获取队列长度
*
* @param pQueue 指向待获取长度的队列
*
* @return 返回队列当前长度
*/
int GetLength( mQueue *pQueue )
{
    return pQueue->len;
}

/**
* @brief 将元素pe插入到队尾
*
* @param pQueue 指向待入队的队列
* @param pe 指向待插入的元素
*
* @return 插入成功则返回入队后队列的长度, 否则返回 -1
*/
int EnQueue( mQueue *pQueue, ElemType *pe )
{
    ///请求一个新节点
    QueueNode *pNode = (QueueNode *)malloc( sizeof(QueueNode) );

    ///新节点的数据元素指向传入的元素
    pNode->pe = pe;

    ///新节点的next节点指向 NULL
    pNode->next = NULL;

    ///队尾的next节点指向新节点
    pQueue->rear->next = pNode;

    ///令队尾指向新节点
    pQueue->rear = pNode;

    return ++pQueue->len;
}

/**
* @brief 将队头元素出队
*
* @param pQueue 指向待出队的队列
* @param pe 指向接收元素的指针的指针
*
* @return 成功出队后返回出队后队列的长度, 否则返回 -1
*/
int DeQueue( mQueue *pQueue, ElemType **pe )
{

    ///队列是否为空
    if( pQueue->front == pQueue->rear )
        return -1;

    ///得到队头元素
    *pe = pQueue->front->next->pe;

    ///令队头指向上一节点
    QueueNode *tmp = pQueue->front;
    pQueue->front = pQueue->front->next;
    free( tmp );

    return --pQueue->len;
}

/**
* @brief 获取队头元素, 不出栈
*
* @param 指向待获取队头元素的队列
* @param 指向接收出栈元素的指针的指针
*
* @return 获取成功则返回元素在队列中的位置, 否则返回 -1, 且 *pe 指向 NULL
*
* @note 元素位置由 0 计起
*/
int GetHead( mQueue *pQueue, ElemType **pe )
{
    ///队列是否为空
    if( pQueue->front == pQueue->rear )
    {
        *pe = NULL;
        return -1;
    }

    ///得到队头元素
    *pe = pQueue->front->next->pe;

    return pQueue->len - 1;
}

/**
* @brief 从队头到队尾对每个元素依次执行 func 函数
*
* @param pQueue 指向待处理的队列
* @param func 回调函数
*/
void ForEachQueue( mQueue *pQueue, void (*func)(ElemType *pe) )
{
    QueueNode *tmp = pQueue->front;

    ///遍历执行 func
    while( tmp != pQueue->rear && (tmp = tmp->next) )
    {
        func( tmp->pe );
    }
}

//测试

/**
* @brief 输出元素 pe
*/
void display( ElemType *pe )
{
    printf( "(%d,%d )", pe->x, pe->y );
}

int main()
{
    ///准备数据元素
    ElemType pt1 = { 10, 10 };
    ElemType pt2 = { 20, 20 };
    ElemType pt3 = { 30, 30 };
    ElemType pt4 = { 40, 40 };
    ElemType pt5 = { 50, 50 };

    ///测试 CreateQueue
    mQueue *pque = CreateQueue();

    ///测试 IsEmpty、GetLength
    if( IsEmpty(pque) == TRUE )
        printf( "队列当前长度:%d, 是否为空队列:%d
", GetLength(pque), IsEmpty(pque) );

    ///测试 EnQueue
    EnQueue( pque, &pt1 );
    if( IsEmpty(pque) != TRUE )
        printf( "入队1元素后队列当前长度:%d, 是否为空队列:%d
", GetLength(pque), IsEmpty(pque) );

    ///测试 ClearQueue
    ClearQueue( pque );
    printf( "清空队列, 当前长度:%d
", GetLength(pque) );

    ///入队5元素
    printf( "
连续入队5元素..
" );
    EnQueue( pque, &pt1 );
    EnQueue( pque, &pt2 );
    EnQueue( pque, &pt3 );
    EnQueue( pque, &pt4 );
    EnQueue( pque, &pt5 );

    ///测试 ForEachQueue
    printf( "测试 ForEachQueue:" );
    ForEachQueue( pque, display );

    ///测试 DeQueue
    ElemType *p = NULL;
    if( DeQueue(pque, &p) != -1 )
        printf( "

测试DeQueue, 出队元素为:(%d,%d), 出队后队列长度:%d
", p->x, p->y, GetLength(pque) );

    ///测试 GetHead
    if( GetHead(pque, &p) != -1 )
        printf( "
测试GetHead, Head元素为(%d,%d)
", p->x, p->y );

    ///全部出队
    printf( "
执行全部出队...
" );
    while( DeQueue(pque, &p) != -1 )
    {
        printf( "当前出队:(%d,%d), 队列剩余长度:%d, 是否为空队列%d
", p->x, p->y, GetLength(pque), IsEmpty(pque) );
    }

    ///销毁队列
    printf( "
销毁队列...
" );
    DestroyQueue( pque );

    return 0;
}

运行测试:

若代码存在 bug 或程序缺陷, 请留言反馈, 谢谢。