队列（循环队列和链队）

顺序队列一般实现为循环队列，因为普通的队列可能产生“假溢出”。

struct SqQueue{
    int data[maxSize];
    int front;
    int rear;
};

循环队列的两个状态：

1.队空

qu.rear == qu.front

2.队满  (注意，循环队列必须损失一个存储空间，用来区分队空和堆满，如果队列中的所有空间对被占满，那么队空和队满的状态都是qu.front == qu.rear，导致无法区分)

(qu.rear+1)%maxSize == qu.front

循环队列的两个操作：

1.进队

qu.rear = (qu.rear+1)%maxSize     //  先移动指针，再存储元素
qu.data[qu.rear] = x;

2.出队

x = qu.data[qu.front];              //  先取元素，再移动指针
qu.front = (qu.front+1)%maxSize;

相关操作：

void InitQueue(SqQueue &qu)
{
    qu.front = qu.rear = 0;
}

int QueueEmpty(SqQueue qu)
{
    if(qu.front==qu.rear)
        return 1;
    else
        return 0;
}

int enQueue(SqQueue &qu,int x)
{
    if((qu.rear+1)%maxSize == qu.front)  // 若队满，就不可再添加了
        return 0;
    qu.rear = (qu.rear+1)%maxSize;   // 先移动指针，在存入元素
    qu.data[qu.rear]=x;
    return 1;
}

int deQueue(SqQueue &qu,int &x)
{
    if(qu.front == qu.rear)    // 若队空，就不可以删除了
        return 0;
    x = qu.data[qu.front];            // 先取出元素，再移动指针
    qu.front = (qu.front+1)%maxSize;
    return 1;
}

还有一个计算循环队列中实际元素个数的式子：

 n = (qu.rear - qu.front + maxSize) % maxSize;

链队

两个状态：

1.队空

lqu->rear == NULL 或 lqu->front == NULL

2.队满

不存在队满的情况。

两个操作：

1.进队 (假设p指向进队元素)

lqu->rear->next = p;
lqu->rear = p;

2.出队 (假设p指向出队元素，也就是队首元素)

p = lqu->front;
lqu->front = p->next;
x = p->data;
free(p);

相关操作：

//先定义结点
struct QNode{
    int data;
    QNode *next;
};
// 定义链队
struct LQueue
{
    QNode *front;
    QNode *rear;
};

void Init(LQueue *&lqu)
{
    lqu = new LQueue;
    lqu->front = lqu->rear = NULL;
}

int QueueEmpty(LQueue *lqu)
{
    if(lqu->front == NULL||lqu->rear == NULL)
        return 1;
    else 
        return 0;
}

void enQueue(LQueue *&lqu,int x)
{
    QNode *p = new QNode;
    p->data = x;
    p->next = NULL;
    if(lqu->rear == NULL)
        lqu->front = lqu->rear = p;
    else{
        lqu->rear->next = p;
        lqu->rear = p
    }
}

int deQueue(LQueue *&lqu,int &x)
{
    QNode *p;
    if(lqu->rear == NULL)
        return 0;
    else
        p=lqu->front;

    if(lqu->front == lqu->rear)      // 当链队中只有一个结点时，特殊处理
        lqu->front=lqu->rear=NULL;
    else
        lqu->front = lqu->front->next;
    x=p->data;
    free(p);
    return 1;
}