顺序队列(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 = ;
     p->rear = ;     //初始化 队头队尾索引均为0
     p->maxSize = Queue_MAX_SIZE;
     return ;
 }
 //销毁队列
 void destroyQueue(Queue *p)
 {
     free(p);
     p = NULL;

 }
 //清空队列
 void clearQueue(Queue *p)
 {
     p->front = ;
     p->rear = ;
 }
 //判断队列是否为空
 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 + ) % 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 + ) % 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 + ) % 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 + ) % 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 -;
     }

     //调用初始化队列的函数
     InitQueue(PQueue);
     //调用出队函数
     enQueue(PQueue, );
     enQueue(PQueue, );
     enQueue(PQueue, );
     enQueue(PQueue, );
     enQueue(PQueue, );
     enQueue(PQueue, );
     enQueue(PQueue, );
     enQueue(PQueue, );
     //调用遍历队列的函数
     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 ;

 }