数据结构--队列

队列和栈相反，队列是一种 先进先出的线性表。它只允许在表的一端进行插入，而在另一端删除元素。允许插入的一端叫做 队尾，允许删除的一端叫做 对头。

单链队列

单链队列示意图

单链队列缺点：删除元素时再插入元素，不能将删除元素的存储空间再次利用起来，从而造成了内存单元的浪费

队列的链式存储结构

typedef int Status;
#define OK 1
#define ERROR 0
#define MAXQSIZE 100 //最大队列长度
typedef struct QNode
{
    QElemType data;
    struct QNode *next;
}*QueuePtr;
typedef struct
{
    QueuePtr front;//队头指针
    QueuePtr rear;//队尾指针
}LinkQueue;

队列的基本操作

构造一个空队列

Status InitQueue(LinkQueue &Q)
{
    Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
    if(!Q.front){exit(OVERFLOW);}
    Q.front->next=NULL;
    return OK；
}

插入元素为新的队尾元素

Status EnQueue(LinkQueue &Q, int e)
{
    QueuePtr p;
    p=(QueuePtr)malloc(sizeof(QNode));
    if(!p){exit(OVERFLOW);}
    else
    {
        p->data=e;
        p->next=NULL;
        Q.rear->next=p;
        Q.rear=p;
        return OK;
    }
}

删除队头元素

Status DeQueue(LinkQueue &Q, int &n)
{
    QueuePtr p;
    if(Q.front==Q.rear){return ERROR;}
    else
    {
        p=Q.front->next;
        n=p->data;
        Q.front->next=p->next;
        if(Q.rear==p){Q.rear=Q.front;}
        free(p);
        return OK;
    }
}

循环队列

将顺序队列假想成一个环状的空间，这样再插入和删除时就能将存储空间利用起来。如图。循环队列判空和判满的条件一样，不能分辨出哪个是空哪个是满，所以有两种处理方法，第一种是另设一个标志位以区别队列是空还是满，第二种是少用一个元素空间，约定以队列头指针在队列尾指针的下一位置（指环状的下一位置）上作为队列呈满状态的标志。
以下为第二种方法：
当队列为空时，Q.front==Q.rear
当队列为满时，(Q.rear+1)%MAXQSIZE==Q.front

循环队列的顺序存储结构

typedef struct
{
    QElemType *base;//初始化的动态分配存储空间
    int front;//头指针（指向位置，不是平时指向内存单元地址的指针），若队列不为空，指向队列头元素
    int rear;//尾指针，若队列不空，指向队列尾元素的下一个位置。
}SqQueue;

循环队列的基本操作

构造一个空队列

int InitQueue(SqQueue &Q)
{
    Q.base=(int*)malloc(MAXQSIZE*sizeof(int));
    if(!Q.base){exit(OVERFLOW);}
    Q.front=Q.rear=0;
    return OK；
}

返回队列长度

int QueueLength(SqQueue &Q)
{
    return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
}

插入元素进队列

int EnQueue(SqQueue &Q, int &c)
{
    if((Q.rear+1)%MAXQSIZE==Q.front){return ERROR;}//队列满
    else
    {
        Q.base[Q.rear]=c;
        Q.rear=(Q.rear+1)%MAXQSIZE;
        return OK;
    }
}

删除元素

int DeQueue(SqQueue &Q, int &b)
{
    if(Q.rear==Q.front){return ERROR;}
    else
    {
        b=Q.base[Q.front];
        Q.front=(Q.front+1)%MAXQSIZE;
        return OK;
    }
}