队列的动态数组实现

#include "Queue.h"
#include <stdlib.h>

/* Queue implementation is a dynamically allocated array */
/* 用一个动态数组来实现队列 */

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

Queue CreatQueue(int MaxElements)
{
    Queue queue = malloc(sizeof(struct QueueRecord));
    queue->Array = malloc(sizeof(ElementType)*MaxElements);
    if(queue == NULL || queue->Array == NULL)
        FatalError("Something Error");
    queue->Capacity = MaxElements;
    MakeEmpty(queue);
}

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

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

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

void Dequeue(Queue Q)
{
    if(IsEmpty(Q))
        FatalError("Empty queue");
    else
    {
        Q->Size--;
        Q->Front = Succ(Q->Front,Q);
    }
}

ElementType FrontAndDequeue(Queue Q)
{
    ElementType Tmp;
    if(IsEmpty(Q))
        Error("Empty queue");
    else
    {
        Q->Size--;
        Tmp = Q->Array[Q->Front];
        Q->Front = Succ(Q->Front,Q);
        return Tmp;
    }
}

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

void Error(char * error)
{
    printf("%s",error);
}

void FatalError(char * fatalerror)
{
    printf("%s",fatalerror);
    return 0;
}
int main()
{
    Queue q = CreatQueue(200);
    int i;
    for(i = 1; i <= 110; i++)
        Enqueue(i,q);
    for(i = 1;i <=100; i++)
       printf("%lf\n",FrontAndDequeue(q));
    return 0;
}