队列的数组实现 C

参考：数据结构与算法分析 --C语言描述
队列的实现有很多种，但是只要我们保证函数调用的效果相同那么怎么实现都无所谓。

front和rear指针指向的问题

队列有两个指针，头指针front和尾指针rear。

使用数组实现队列的时候

1. 可以让front指向队列的第一个元素，rear指向队列的最后一个元素的下一个位置；
2. 也可以让front指向第一个位置的前一个位置，rear指向最后一个位置；
3. 也可以让front指向第一个位置，rear指向最后一个位置

使用前两种方法可以使用front == rear确定队列是否为空，第三种可以使用rear + 1 = front 的来确定队列为空

使用循环队列

从上面的图可以看到，出队时front向后移动，那么前面空出的数组空间就无法得到利用，所以我们要使rear指针可以回到数组的开始位置。

如何判断队列的空，满

我使用的front和rear指向是第三种。那么当队列为空时有front == （rear+1）%Maxsize，队列为满时这个条件同时成立，怎么判断队列的空，满呢？
有三种方法：

1. 添加变量size标识队列的大小
2. 使用tag标签，当入队时tag设置为1，出队时设为0，所以队满时tag总是为1
3. 在数组中预留一个空间，如果使用front指向第一个位置，rear指向最后一个位置，那么队空：front == （rear+1）%Maxsize， 队满时front ==（rear+2）%Maxsize。

针对第三种情况，当front指向第一个位置，rear指向最后一个位置的下一个位置时，盗用网上的一张图来理解：

代码

本次使用循环队列，front指向第一个位置，rear指向最后一个位置，通过size来判断队列的空满。

queue.h

#ifndef QUEUE_H_INCLUDED
#define QUEUE_H_INCLUDED

typedef int ElementType;

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(Queue Q,ElementType X);
void Dequeue(Queue Q);
ElementType Front(Queue Q);		//返回队列的队首元素
ElementType FrontAndDequeue(Queue Q);	//返回队首元素并出队

#endif // QUEUE_H_INCLUDED

queue.c

#include"..\fatal.h"
#include"queue.h"
#include
#include

#define MinQueueSize (5)


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

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

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

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!!");

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

    Q->Capacity = MaxElements;
    MakeEmpty(Q);

    return Q;
}

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

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

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

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

ElementType Front(Queue Q){
    if(IsEmpty(Q))
        Error("Empty queue");
    else
        return Q->Array[Q->Front];
}

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

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

int main(){

    Queue Q;

    Q = CreateQueue(10);
    Enqueue(Q, 1);
    Enqueue(Q, 2);
    Dequeue(Q);
    printf("%d\n",Front(Q));
    printf("%d\n",FrontAndDequeue(Q));
    printf("%d",IsEmpty(Q));
    DisposeQueue(Q);

    return 0;

}