循环队列

/*
循环队列
2016年4月3日10:57:04
*/
#include<malloc.h>
#include<stdio.h>
#define MAXQSIZE 10
typedef int Status;
#define OK 1
#define ERROR 0
typedef int QElemType;
//-----------------------
typedef struct
{
   QElemType *base; // 初始化的动态分配存储空间
   int front; // 若队列不空,指向队列头元素
   int rear; // 若队列不空,指向队列尾元素的下一个位置
 }SqQueue; //空队列时,front和rear同时为0;

Status InitQueue(SqQueue &Q)
{
// 构造一个空队列Q，该队列预定义大小为MAXQSIZE
   Q.base=(QElemType *) malloc(  MAXQSIZE *sizeof(QElemType));
   if (!Q.base) return ERROR;
   Q.front=Q.rear=0;
   return OK;
}

Status EnQueue(SqQueue &Q,QElemType e)
{
// 插入元素e为Q的新的队尾元素
    if ( (Q.rear+1) % MAXQSIZE == Q.front )  return ERROR;
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1)%MAXQSIZE;
    return OK;
}

Status DeQueue(SqQueue &Q, QElemType &e)
{
// 若队列不空, 则删除Q的队头元素, 用e返回其值, 并返回OK; 否则返回ERROR
       if (Q.rear == Q.front)  return ERROR;
       e=Q.base[Q.front];
       Q.front=(Q.front+1)%MAXQSIZE;
       return OK;
}

Status GetHead(SqQueue Q, QElemType &e)
{
// 若队列不空，则用e返回队头元素，并返回OK，否则返回ERROR
    if (Q.rear==Q.front)  return ERROR;
    e=Q.base[Q.front];
    return OK;
 }

/*
int QueueLength(SqQueue Q)
{
// 返回Q的元素个数
        int p,count=0;
        p=Q.front;
        if (Q.rear==Q.front) return 0;
        while (p!=Q.rear){
                count++;
                p=(p+1)%MAXQSIZE;
        }
        return count;
}
*/

 int QueueLength(SqQueue Q){
         //返回Q的元素个数
 return (Q.rear-Q.front+MAXQSIZE) %  MAXQSIZE;

}

Status QueueTraverse(SqQueue Q)
{
// 若队列不空，则从队头到队尾依次输出各个队列元素，并返回OK；否则返回ERROR.
    int i;
    i=Q.front;
    if(Q.front == Q.rear)printf("空队列!");
    else{
        printf("队列: ");
        while(i != Q.rear )
        {
            printf("%d ",Q.base[i]);
            i = (i+1)%MAXQSIZE;
        }
    }
    printf("\n");
    return OK;
}

int main()
{
    int a;
  SqQueue S;
    QElemType x, e;
  if( InitQueue(S))    // 判断顺序表是否创建成功
    {
        printf("一个队列成功创建.\n");
    }
    while(1)
    {
    printf("1:入队 \n2:出队 \n3:显示队头元素 \n4:显示队长\n5:显示队伍\n0:退出\n请选择:\n");
        scanf("%d",&a);
        switch(a)
        {
            case 1: printf("输入入队的元素\n");
                    scanf("%d", &x);
                  if(!EnQueue(S,x)) printf("入队错误!\n"); // 判断入队是否合法
                  else printf(" [%d] 成功入队\n", x);
                  break;
            case 2: if( !DeQueue(S, e)) printf("出队错误!\n"); // 判断出队是否合法
                  else printf("   [%d] 成功出队\n", e);
                  break;
            case 3: if(!GetHead(S,e))printf("获取head错误!\n"); // 判断Get Head是否合法
                  else printf(" 当前队列头是  [%d] \n", e);
                  break;
            case 4: printf("队列长度是%d!\n", QueueLength(S));
                  break;
            case 5: QueueTraverse(S);
                  break;
            case 0: return 1;
        }
    }
}

**注意内容:
1为了克服队列假溢出的现象，想象存储空间为一个圆环空间，即循环队列。
2 因为无法循环队列无法通过判断Q.front==Q.rear队列是否为满，所以少用了一个元素空间，约定的以队列头指针在队列尾指针的下一位置（指环状的下一位置）上，作为队列为满的判断标志。
3 几个式子：
1）：
(Q.rear+1) % MAXQSIZE == Q.front
判断队满
Q.rear == Q.front
判读队空（仅当rear=front=0队列为空）
3）：
(Q.rear-Q.front+MAXQSIZE) % MAXQSIZE
返回队列的长度（最大长度为MAXQSIZE-1）
4）：
出队 Q.front=(Q.front+1)%MAXQSIZE
入队 Q.rear=(Q.rear+1)%MAXQSIZE　
**