优点：
相对于直线队列来讲，直线队列在元素出队后，头指针向后移动，导致删除元素后的空间无法在利用，即使元素个数小于空间大小，依然无法再进行插入，即所谓的“假上溢”。当变成循环队列之后，删除元素后的空间仍然可以利用，最大限度的利用空间。
判断方式：
1、采用计数器来判断，空时，计数器为0，满时，计数器为maxsize。

2、另设一个布尔变量以匹别队列的空和满。

3、少用一个元素的空间，约定入队前，测试尾指针+1后是否等于头指针，若相等则认为队满。（注意：rear所指的单元始终为空，如果用尾指针=头指针来判断的话，是不知道是空还是满的，因为空和满尾指针都等于头指针）；

设立一个标志位,比如说是flag
最开始时队列为空,设flag=0
当入队的时候让flag=1
出队的时候flag=0
然后再加上判断队头队尾指针是否重合
重合,且flag=0,则为空
重合且flag=1,则为满

    
循环队列是指, 队尾指针走到末尾后, 还可以继续从头开始走.
front指针仍然是指向第一个元素的前一个元素, rear指针指向最后一个元素.

下面我们重点讨论一下循环队列如何判断空和满的问题?

我下面判断队列空和满是直接根据q->length属性来判断, 当q->length为0,

表示队列为空, 当q->length = maxSize - 1时, 队列为满. 由于遍历上的原因,

队列的最大长度只能是数组最大长度-1.
#include <stdio.h>
#include <stdlib.h>

struct queue {
    int* data;
    int front;
    int rear;
    int maxSize;
    int length;
};
typedef struct queue node;
typedef struct queue* link;

// 函数声明
link createQueue (int maxSize);
void printQueue (link q);
int add (link q, int x);
int del (link q);

int main () {
    int i;
    int maxSize = 10; // 队列的最大长度
    link qhead = createQueue(maxSize);

    // 初始队列信息
    printQueue(qhead);

    // 基本入队测试
    for (i=1; i<=10; i++) {
        add(qhead, i * 2);
    }
    printQueue(qhead);

    // 基本出队测试
    del(qhead);
    del(qhead);
    del(qhead);
    del(qhead);
    printQueue(qhead);

    // 循环入队测试
    add(qhead, 100);
    add(qhead, 200);
    add(qhead, 300);
    add(qhead, 400);
    add(qhead, 500);

    printQueue(qhead);
    return 0;
}

// 创建空队列
link createQueue (int maxSize) {
    link q;
    q = (node*)malloc(sizeof(node));
    q->data = (int*)malloc(sizeof(int) * maxSize);
    q->front = -1;
    q->rear = -1;
    q->length = 0;
    q->maxSize = maxSize;
    return q;
}

// 打印
void printQueue (link q) {
    int i;
    printf("当前队列的信息如下: \n");
    printf("front = %d\n", q->front);
    printf("rear = %d\n", q->rear);
    printf("length = %d\n", q->length);
    printf("maxSize = %d\n", q->maxSize);

    // 打印队列中的数据
    if (q->length == 0) {
        printf("当前队列中没有数据\n");
    } else {
        printf("队列中的数据如下: \n");
        i = q->front;
        while (i != q->rear) {
            i = (i + 1) % q->maxSize;
            printf("%d %d\n", i, q->data[i]);
        }
    }
    printf("\n");
}

// 入队
int add (link q, int x) {
    if (q->length == q->maxSize -1 ) {
        printf("队列已满, 不能入队\n");
        return 0;
    }
    q->rear = (q->rear + 1) % q->maxSize;
    q->data[q->rear] = x;
    q->length++;
    return 1;
}

// 出队
// 错误返回0, 正确返回被出队元素的值
int del (link q) {
    if (q->length == 0) {
        printf("队列为空, 不能出队\n");
        return 0;
    }

    q->front = (q->front + 1) % q->maxSize;
    q->length--;
    return q->data[q->front];
}

循环队列如何判断队列已满或者空？
使用一个length变量记录实际元素个数，就不用每次去计算head指针和rear指针之间的关系来判断队列的状态。
package demo;

import java.util.Arrays;

@SuppressWarnings("unchecked")
public class CircleArrayQueue<T> {
    public int head = 0;//头指针
    public int rear = 0;//尾指针
    private Object[] data;//存放数据
    private int maxSize;//队列长度
    private int length = 0;//实际元素个数

    //默认初始化
    public CircleArrayQueue(){
        data = new Object[10];
        maxSize = 10;
    }

    //自定义初始化
    public CircleArrayQueue(int initSize){
        if(initSize <= 0){
            throw new RuntimeException("初始化长度必须大于0");
        }
        data = new Object[initSize];
        maxSize = initSize;
    }

    //判断循环队列是否已满
    public boolean isFull(){
        return length == maxSize;
    }

    //判断是否为空
    public boolean isEmpty(){
        return length == 0;
    }

    //入队
    public void add(T t){
        if(isFull()){
            throw new RuntimeException("队列已满，无法入队!");
        }else{
            data[rear%maxSize] = t;
            length++;
        }
    }

    //出队
    public T get(){
        if(isEmpty()){
            throw new RuntimeException("队列为空，没有元素");
        }
        length--;
        return (T)data[++head%maxSize];
    }

	//查看队首元素
    public T peek(){
        if(isEmpty()){
            throw new RuntimeException("队列为空，没有元素");
        }
        return (T)data[(head+1)%maxSize];
    }

}