顺序队列(C语言)

#define Queue_MAX_SIZE 20
#define OK 1
#define ERROR 0
#include <stdio.h>
#include <stdlib.h>
typedef int QueueType; //队列元素类型
typedef struct
{
    QueueType *pBase;    //队列指针
    QueueType front;     //队头索引
    QueueType rear;      //队尾索引
    int maxSize;         //当前分配最大容量
}Queue;
//队列的初始化
int InitQueue(Queue *p)
{
    p->pBase = (QueueType *)malloc(Queue_MAX_SIZE * sizeof(QueueType));
    if (p->pBase == NULL) return ERROR; //内存分配失败
    p->front = 0;
    p->rear = 0;     //初始化 队头队尾索引均为0
    p->maxSize = Queue_MAX_SIZE;
    return 0;
}
//销毁队列
void destroyQueue(Queue *p)
{
    free(p);
    p = NULL;

}
//清空队列
void clearQueue(Queue *p)
{
    p->front = 0;
    p->rear = 0;
}
//判断队列是否为空
int isEmpityQueue(Queue *p)
{
    if (p->front == p->rear)
        return OK;
    return ERROR;

}
/*
 *在循环队列中,“队满”和“队空”的条件有可能是相同的，都是front==rear，
 *这种情况下，无法区别是“队满”还是“队空”。
 *针对这个问题，有3种可能的处理方法：
 *（1）另设一个标志以区别是“队满”还是“队空”。（即入队/出队前检查是否“队满”/“队空”）
 *（2）设一个计数器，此时甚至还可以省去一个指针。
 *（3）少用一个元素空间，即约定队头指针在队尾指针的下一位置时就作为“队满”的标志，
 *即“队满”条件为：(PQueue->rear+1)%MAX_SIZE == PQueue->front。
 *  【这里采用了第3种处理方法】
 */
//判断队列是否满
int isFullQueue(Queue *p)
{
    if ((p->rear + 1) % p->maxSize == p->front)
        return OK;
    return ERROR;

}
//获得队列长度
int getQueueLen(Queue *p)
{
    return  (p->rear - p->front + p->maxSize) % p->maxSize;
}
//新元素入队
int enQueue(Queue *p, QueueType e)
{
    if (isFullQueue(p) == OK)
    {
        printf("队列已满\n");
        return ERROR;
    }
    p->pBase[p->rear] = e;
    p->rear = (p->rear + 1) % p->maxSize;
    return OK;
}
//队头元素出列
int deQueue(Queue *p, QueueType *pe)
{
    //如果队列为空 则返回ERROR
    if (isEmpityQueue(p) == OK)
    {
        printf("队列为空，出队失败\n");
        return ERROR;

    }
    *pe = p->pBase[p->front];
    p->front = (p->front + 1) % p->maxSize;

    return OK;
}
//遍历队列
void queueTraverse(Queue *p)
{
    int i = p->front;
    printf("遍历队列\n");
    while (i != p->rear)
    {
        printf("%d ", p->pBase[i]);
        i = (i + 1) % p->maxSize;
    }
    printf("\n");

}

int main()
{
    QueueType *pe;
    pe = (QueueType*)malloc(sizeof(QueueType));
    Queue *PQueue = (Queue *)malloc(sizeof(Queue));
    if (!PQueue->pBase)
    {
        printf("给队列对象分配内存失败\n");
        return -1;
    }

    //调用初始化队列的函数
    InitQueue(PQueue);
    //调用出队函数
    enQueue(PQueue, 1);
    enQueue(PQueue, 2);
    enQueue(PQueue, 3);
    enQueue(PQueue, 4);
    enQueue(PQueue, 5);
    enQueue(PQueue, 6);
    enQueue(PQueue, 7);
    enQueue(PQueue, 8);
    //调用遍历队列的函数
    queueTraverse(PQueue);
    //调用出队函数
    if (deQueue(PQueue, pe))
    {
        printf("出队一次，元素为：%d\n", *pe);
    }
    queueTraverse(PQueue);
    if (deQueue(PQueue, pe))
    {
        printf("出队一次，元素为：%d\n", *pe);
    }
    queueTraverse(PQueue);

    destroyQueue(PQueue);


    return 0;



}