C语言 队列 顺序结构 实现

一个能够自动扩容的顺序结构的队列 ArrQueue (GCC编译)。

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

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

#define TRUE 1
#define FALSE 0

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

typedef struct
{
    ElemType **rear;    //队尾
    ElemType *front;    //队头
    int len;            //队列长度
    int size;           //队列总容量
}ArrQueue;      //队列结构

//声明队列方法

ArrQueue *CreateQueue( int nLen );          //创建初始长度为 nLen 队列
void DestroyQueue( ArrQueue *pQueue );      //销毁队列pQueue
void ClearQueue( ArrQueue *pQueue );        //清空队列内元素
int GetLength( ArrQueue *pQueue );          //获取队列长度
int GetSize( ArrQueue *pQueue );            //获取队列总容量
int IsEmpty( ArrQueue *pQueue );            //检测队列是否为空
int GetHead( ArrQueue *pQueue, ElemType **pe );      //获取队头元素
int EnQueue( ArrQueue *pQueue, ElemType *pe );       //将元素插入到队尾
int DeQueue( ArrQueue *pQueue, ElemType **pe );      //将队头元素出队
void ForEachQueue( ArrQueue *pQueue, void (*func)(ElemType *pe) );      //从对尾到队头依次执行 func

//队列方法实现

/**
* @brief 创建初始长度为 nLen 的队列
*
* @param nLen 队列的初始长度
*
* @return 返回指向新创建的队列的指针
*/
ArrQueue *CreateQueue( int nLen )
{
    ArrQueue *pQueue = (ArrQueue *)malloc( sizeof(ArrQueue) );
    pQueue->rear = (ElemType **)calloc( nLen, sizeof(ElemType **) );
    pQueue->front = pQueue->rear[0];
    pQueue->len = 0;
    pQueue->size = nLen;

    return pQueue;
}

/**
* @brief 销毁队列
*
* @param pQueue 指向待销毁的队列的指针
*/
void DestroyQueue( ArrQueue *pQueue )
{
    free( pQueue->rear );
    free( pQueue );

    pQueue = NULL;
}

/**
* @brief 清空队列内元素
*/
void ClearQueue( ArrQueue *pQueue )
{
    pQueue->front = pQueue->rear[0];

    pQueue->len = 0;
}

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

/**
* @brief 获取队列总容量
*
* @param pQueue 指向待获取容量的队列
*
* @return 返回队列当前总容量
*/
int GetSize( ArrQueue *pQueue )
{
    return pQueue->size;
}

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

/**
* @brief 获取队头元素
*
* @param pQueue 指向待获取队头元素的队列
*
* @param pe 指向接收元素的指针的指针
*
* @return 返回队头在队列中的位置(位置由 0 计起)
*/
int GetHead( ArrQueue *pQueue, ElemType **pe )
{
    if( pQueue->len == 0 )
    {
        *pe = NULL;
        return -1;
    }

    *pe = pQueue->rear[pQueue->len-1];

    return pQueue->len-1;
}

/**
* @brief 将元素 pe 插入到队尾
*
* @param pQueue 指向待插入元素的队列
* @param pe 指向待插入的元素
*
* @return 返回成功插入后队列的长度
*/
int EnQueue( ArrQueue *pQueue, ElemType *pe )
{
    ///检测是否需要扩容
    if( pQueue->len == pQueue->size )
    {   //需要扩容
        pQueue->rear = realloc( pQueue->rear, 2 * pQueue->size * sizeof(ElemType *) );
        pQueue->size = 2 * pQueue->size;
    }

    int i = 0;
    for( i = pQueue->len; i > 0; --i )
    {
        pQueue->rear[i] = pQueue->rear[i-1];
    }
    pQueue->rear[0] = pe;
    pQueue->front = pQueue->rear[pQueue->len];

    return ++pQueue->len;
}

/**
* @brief 将队头元素出队
*
* @param pQueue 指向待出队的队列
* @param pe 指向接收元素的指针的指针
*
* @return 成功出队则返回出队后队列的长度, 否则返回 -1
*/
int DeQueue( ArrQueue *pQueue, ElemType **pe )
{
    if( pQueue->len == 0 )
    {
        *pe = NULL;
        return -1;
    }
    *pe = pQueue->front;
    --pQueue->len;
    pQueue->front = pQueue->rear[pQueue->len-1];

    return pQueue->len;
}

/**
* @brief 从队尾到队头每个元素一次执行 func
*
* @param pQueue 指向待处理的队列
* @param  func 回调函数指针
*/
void ForEachQueue( ArrQueue *pQueue, void (*func)(ElemType *pe) )
{
    int i = 0;
    for( i = 0; i < pQueue->len; ++i )
    {
        func( pQueue->rear[i] );
    }
}

//测试
void display( ElemType *pe )
{
    printf( "(%d,%d) ", pe->x, pe->y );
}

int main()
{
    ElemType t1 = {10, 20};
    ElemType t2 = {30, 40};
    ElemType t3 = {50, 60};
    ElemType t4 = {70, 80};
    ElemType t5 = {99, 99};

    ///测试 CreateQueue
    ArrQueue *pque = CreateQueue( 3 );

    ///测试入队
    EnQueue( pque, &t1 );
    EnQueue( pque, &t2 );
    EnQueue( pque, &t3 );
    EnQueue( pque, &t4 );
    EnQueue( pque, &t5 );

    ///测试 ForEachQueue
    ForEachQueue( pque, display );

    ///测试 IsEmpty、GetSize、GetLength
    if( IsEmpty( pque ) != TRUE )
        printf( "
队列总容量:%d, 当前长度:%d
", GetSize(pque), GetLength(pque) );

    ///测试全部出队
    printf( "
测试全部出队:
" );
    ElemType *p;
    while( DeQueue( pque, &p ) != -1 )
    {
        printf( "当前出队:(%d,%d), 剩余队列长为:%d
", p->x, p->y, GetLength(pque) );
    }

    ///测试 ClearQueue
    printf( "
再次入队2元素..
" );
    EnQueue( pque, &t1 );
    EnQueue( pque, &t2 );
    ForEachQueue( pque, display );
    printf( "
清空队列..
" );
    ClearQueue( pque );
    printf( "队列总容量:%d, 当前长度:%d
", GetSize(pque), GetLength(pque) );

    ///测试 GetHead
    printf( "
再次入队2元素..
" );
    EnQueue( pque, &t1 );
    EnQueue( pque, &t2 );
    ForEachQueue( pque, display );
    GetHead( pque, &p );
    printf( "
获取队头元素:(%d,%d)
", p->x, p->y );
    printf( "队列总容量:%d, 当前长度:%d
", GetSize(pque), GetLength(pque) );

    ///销毁队列
    DestroyQueue( pque );

    return 0;
}

测试运行:

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