少一个存储位置的

队列为空时：rear= =front

队列满时：（rear+1）%maxSize= =front
不少一个存储位置时：加一个标志flag或者计数的count

入队时flag=true

出队时flag=false

队满：rear= =front&flag

队空：rear= =front&!flag

开始时count=0

入队时：count++

出队是：count–

队满：rear ==front &&count=maxsize

队空：rear ==front&&count=0；

第一种方法是设置一个标志量flag,当front==rear且flag=0时为空，当front==rear且flag=1时队列为满；

第二种方法是我们修改条件，保留一个元素空间，也就是说，数组中还有一个空闲单元时，我们就认为这个队列已经满了。

接下来我们重点讨论第二种方法，由于rear可能比front大，也可能是比front小，所以尽管他们只相差一个位置时候就是满的情况，但是也可能说是相差整整一圈。所以若队列最大尺寸为QueueSize，那么队列满的条件就是(rear+1）%QueueSize==front(这里取模“%”目的就是为了整合rear与front大小为一个问题）。比如图一所示，QueueSize=5,front=0,rear=4，根据公式（4+1）%5=0，所以此时队列满。 


图一

通用计算队列长度公式： 
（rear-front+QueueSize）%QueueSize

/*循环队列求长度代码,返回Q元素个数*/
 int QueueLength()
 {
    return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
 } 



/*循环队列求长度代码,返回Q元素个数*/
int QueueLength()
 {
    return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
 } 

 /*循环队列的入队列操作,若队列未满则插入元素e为Q新的队尾元素*/
Status EnQueue(SqQueue *Q,QElemType e)
  {
    if((Q->rear+1)%MAXSIZE==Q->front)/*队列满判断*/
        return ERROR;
    Q-date[Q->rear]=e;              /*将元素e赋值给队尾*/ 
    Q-rear=(Q->rear+1)%MAXSIZE;     
            /*rear指针向后移一位置，若到最后则转到数组头部*/

    return OK;   
  }

  /*循环队列的出队列操作,若队列不空，则删除Q中队头元素，用e返回其值*/
Status DeQueue(SqQueue *Q,QElemType e)
{
    if(Q->front==Q->rear)           /*队列空判断*/
        return ERROR;
    *e=Q->data[Q->front];           /*将队头元素赋值给e*/ 
    Q->front=(Q->front+1)%MAXSIZE;  
           /*front指针向后移一位置，若到最后则转到数组头部*/
    return OK
} 

 
一.少用一个存储位置
 

第一种情况：



当队列为空时条件：rear == front
当队列满时条件为：rear+1 == front

  

  上述方式对于上述图是适用的，但如果出现了有下标标识，上述判断条件就不适用了。比如下图有下标了，当队列满时，显然条件就不能判断了，就要用到另一种判断。

 

第二种情况：

当队列为空时条件：rear == front
当队列满时条件为：（rear+1）% maxsize == front

 

 

 
二.设置一个标记位
 

设置初始标记： boolean flag=false
当入队列时，让rear往后移动，让flag=true

当出队列时，让front往后移动，让flag=false
当队列为空时：  rear == front  &&  flag==false

当队列为满时：  rear == front  &&  flag == true
 

 
三.计数count——队列中有效元素个数
 

队列为空时，count == 0
当有元素入队时，count++，当count和队列的maxsize相等时，代表队列已满

问题描述：循环队列为空条件是 rear=front 。如果进队元素的速度快于出队元素的速度，队尾指针很快就赶上了队首指针，此时可以看出循环队列的队满条件也为 rear=front。怎样区分这两者之间的差别呢？

解决方案：

方法一：把数组的前端和后端连接起来，形成一个循环的顺序表，即把存储队列元素的表从逻辑上看成一个环。循环队列的队头指针和队尾指针初始化时都置0，队满条件：（rear+1）%MaxSize=front，队空条件：rear=front。

方法二：用一个标志tag标识队列可能空（0）或可能满（1），加上front==rear作为队满或队空的条件。Tag初始值置为0，每当入队成功，tag=1，每当出队成功，tag=0。当front=rear&&tag=1时，表示在入队操作后front=rear，此时队满，同理，front=rear&&tag=0时则表示队空。

代码实现：

namespace ConsoleApplication

{

class sqQueueClass

{

const int MaxSize = 100;

public string[] data;

public int front, rear;

public int tag = 0;

public sqQueueClass()

{

data = new string[MaxSize];

front = rear = -1;

}

public bool QueueEmpty()

{

return (front == rear && tag == 0);

}

public bool enQueue(string e)

{

if (front == rear && tag == 1)

return false;

rear = (rear + 1) % MaxSize;

data[rear] = e;

tag = 1;

return true;

}

public bool deQueue(ref string e)

{

if (front == rear && tag == 0)

return false;

front = (front + 1) % MaxSize;

e = data[front];

tag = 0;

return true;

}

}

}

namespace ConsoleApplication

{

class Program

{

static void Main(string[] args)

{

sqQueueClass L1 = new sqQueueClass();

bool pandan = false;

pandan = L1.enQueue(“3”);

Console.WriteLine(pandan);

pandan = L1.enQueue(“5”);

Console.WriteLine(pandan);

pandan = L1.enQueue(“8”);

Console.WriteLine(pandan);

pandan = L1.enQueue(“4”);

Console.WriteLine(pandan);

pandan = L1.enQueue(“0”);

Console.WriteLine(pandan);

string e = “”;

pandan = L1.deQueue(ref e);

Console.WriteLine(pandan);

Console.WriteLine(e);

Console.ReadKey();

}

}

}

运行结果如图示：
比较：方法一判断条件较为简单，但浪费了一个存储空间；方法二能够充分利用存储空间，但在进行出队入队操作时，每次都需要对tag进行重新定义且判断条件较为复杂。

总结：循环队列在实现入队出队操作时，应注意算法实现顺序，入队时先判断是不是队满，出队时先判断是不是队空，然后再进行相应的入队出队操作。