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 = ;

     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 = ;
 }

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

     ///得到队头元素
     *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 -;
     }

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

     return pQueue->len - ;
 }

 /**
 * @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 = { ,  };
     ElemType pt2 = { ,  };
     ElemType pt3 = { ,  };
     ElemType pt4 = { ,  };
     ElemType pt5 = { ,  };

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

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

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

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

     ///入队5元素
     printf( "\n连续入队5元素..\n" );
     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) != - )
         printf( "\n\n测试DeQueue, 出队元素为:(%d,%d), 出队后队列长度:%d\n", p->x, p->y, GetLength(pque) );

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

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

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

     return ;
 }

运行测试:

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