队列ADT

队列的数组实现

/* 队列的类型声明 */ 


#ifndef _Queue_h

struct QueueRecord;
typedef struct QueueRecord *Queue;

int         IsEmpty( Queue Q );
int         IsFull( Queue Q );
Queue       CreateQueue( int MaxElements );
void        DisposeQueue( Queue Q );
void        MakeEmpty( Queue Q );
void        Enqueue( ElementType X, Queue Q );
ElementType Front( Queue Q );
void        Dequeue( Queue Q );
ElementType FrontAndDequeue( Queue Q );

#endif    /* _Queue_h */


/* Place in implementation file */
/* Queue implementation is a dynamically allocated array */
#define MinQueueSize    ( 5 )

struct QueueRecord
{
    int Capacity;
    int Front;
    int Rear;
    int Size;
    ElementType *Array;
};

/* 测试队列是否为空 */

int 
IsEmpty( Queue Q )
{
    return Q->Size == 0;
}

/* 构造空队列 */

void
MakeEmpty( Queue Q )
{
    Q->Size = 0;
    Q->Front = 1;
    Q->Rear = 0;
}

/* 给出Q->Front、Q->Rear自增1后的数组下标值 */
static int
Succ( int Value, Queue Q )
{
    if( ++Value == Q->Capacity )
        Value = 0;
    return Value;
}

/* 入队 */
void 
Enqueue( ElementType X, Queue Q )
{
    if( IsFull( Q ) )
        Error( "Full queue" );
    else
    {
        Q->Size++;
        Q->Rear = Succ( Q->Rear, Q );
        Q->Array[ Q->Rear ] = X;
    }
}

/* 出队 */
void
Dequeue( Queue Q )
{
    if( IsEmpty( Q ) )
        Error( "Empty queue" );
    else
    {
        Q->Size--;
        Q->Front = Succ( Q->Front, Q );
    }
}

/* 返回队头元素，但不出队 */
ElementType 
Front( Queue Q )
{
    if( IsEmpty( Q ) )
        Error( "Empty queue" );
    else
        return Q->Array[ Q->Front ];
}

/* 返回队头元素，并且出队 */
ElementType
FrontAndDequeue( Queue Q )
{
    ElementType Tmp;
    
    if( IsEmpty( Q ) )
        Error( "Empyt queue" );
    else
    {
        Tmp = Q->Array[ Q->Front ] ;
        Q->Size--;
        Q->Front = Succ( Q->Front, Q );
        
        return Tmp;
    }
}

/* 创建队列 */

Queue
CreateQueue( int MaxElements )
{
    Queue Q;
    
    if( MaxElements < MinQueueSize )
        Error( "Queue size is too small" );

    Q = malloc( sizeof( struct QueueRecord ) );
    if( Q == NULL )
        FatalError( "Out of space!\n" );

    Q->Array = malloc( sizeof( ElementType ) * MaxElements );
    if( Q->Array == NULL )
        FatalError( "Out of space!\n" );
    Q->Capacity = MaxElements;
    MakeEmpty( Q );

    return Q;
}

/* 测试队列是否已满 */

int
IsFull( Queue Q )
{
    return Q->Size == Q->Capacity;
}

/* 释放队列 */

void
DisposeQueue( Queue Q )
{
    if( Q != NULL )
    {
        free( Q->Array );
        free( Q );
    }
}