队列的数组实现

/*
  队列的数组实现。
  为避免出现队列“看似满了”现象，采用循环数组实现。
  当Size = 0 或 Rear = Front - 1 ，说明队列为空。
  要注意的是，插入的第一个元素的位置是Array[ 1 ]，而不是Array[ 0 ]。
*/

/*接口头文件*/
typedef int ElementType;
#ifndef _QUEUE_H
#define _QUEUE_H
#include <stdbool.h>

struct Node;
typedef struct Node * PtrToNode;
typedef PtrToNode Queue;

/*操作集*/
Queue CreateQueue( int MaxElements );
void MakeEmpty( Queue Q );
bool IsEmpty( Queue Q );
bool IsFull( Queue Q );
void Enqueue( ElementType X, Queue Q );
void Dequeue( Queue Q );
ElementType Front( Queue Q );
ElementType FrontAndDequeue( Queue Q );
void DisposeQueue( Queue Q );
void PrintfQueue( Queue Q );

#endif 


/*接口实现*/
#include <stdio.h>
#include <stdlib.h>
#include "queue.h"

/*获取下个队头或队尾，实现循环数组*/
int Succ( int Value, Queue Q );
 
/*指定队列数组的最小空间*/
#define MinQueueSize ( 5 )

/*特定结构体定义*/
struct Node
{
    int Capacity;         //队列数组空间大小
    int Size;             //队列元素个数
    int Front;            //队头
    int Rear;             //队尾
    ElementType * Array; 
};

/*创建队列*/
Queue CreateQueue( int MaxElements )
{
    Queue Q;
    
    if ( MaxElements < MinQueueSize )
    {
       printf( "Space is smallr!!!
" );
       exit( 1 );
    }
    
    Q = ( Queue )malloc( sizeof( struct Node ) );
    if ( Q == NULL )
    {
       printf( "No Space!!!
" );
       exit( 1 );
    }
    
    Q->Array = ( ElementType * )malloc( sizeof( ElementType ) * MaxElements );
    if ( Q->Array == NULL )
    {
       printf( "No Space!!!
" );
       exit( 1 );
    }
    
    Q->Capacity = MaxElements;
    MakeEmpty( Q );
    return Q;
}

/*使队列为空*/
void MakeEmpty( Queue Q )
{
    Q->Size = 0;
    Q->Front = 1;        //注意，首次插入元素插入Q->Array[ 1 ] 
    Q->Rear = 0;
}

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

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

/*入队操作*/
void Enqueue( ElementType X, Queue Q )
{
    if ( IsFull( Q ) )
    {
       printf( "Queue is full
" );
       exit( 1 );
    }
    else
    {
        Q->Size++;
        Q->Rear = Succ( Q->Rear, Q );     //获取队尾
        Q->Array[ Q->Rear ] = X;
    }   
}

void Dequeue( Queue Q )
{
    if ( IsEmpty( Q ) )
    {
       printf( "Queue is empty
" );
       exit( 1 );
    }
    else
    {
        Q->Size--;
        Q->Front = Succ( Q->Front, Q );
    }
}

ElementType Front( Queue Q )
{
    return Q->Array[ Q->Front ];
}

ElementType FrontAndDequeue( Queue Q )
{
    ElementType n;
    
    if ( IsEmpty( Q ) )
    {
       printf( "Queue is empty
" );
       exit( 1 );
    }
    else
    {
        n = Q->Array[ Q->Front ];
        Q->Size--;
        Q->Front = Succ( Q->Front, Q );
        return n;   
    }
}

void DisposeQueue( Queue Q )
{
    free( Q->Array );
    free( Q );
}

void PrintfQueue( Queue Q )
{
    while ( ! IsEmpty( Q ) )
        printf( "%3d", FrontAndDequeue( Q ) );
        
    printf( "
" );
}

int Succ( int Value, Queue Q )
{
    if ( ++Value == Q->Capacity )
       Value = 0;
       
    return Value;
}