队列—队列的存储实现及运算实现

1、顺序队
顺序存储的队称为顺序队。因为队的队头和队尾都是活动的，因此，除了队列的数据区外还有队头、队尾两个指针。顺序队的类型定义如下：
define MAXSIZE 1024 /*队列的最大容量*/
typedef struct
{datatype data[MAXSIZE]; /*队员的存储空间*/
int rear,front; /*队头队尾指针*/
}SeQueue;

定义一个指向队的指针变量：

SeQueue *sq;

申请一个顺序队的存储空间：

sq=malloc(sizeof(SeQueue));

队列的数据区为：

sq->data[0]---sq->data[MAXSIZE -1]

队头指针：sq->front
队尾指针：sq->rear

设队头指针指向队头元素前面一个位置，队尾指针指向队尾元素（这样的设置是为了某些运算的方便，并不是唯一的方法）。

置空队则为：sq->front=sq->rear=-1;

在不考虑溢出的情况下，入队操作队尾指针加1，指向新位置后，元素入队。操作如下：
sq->rear++;
sq->data[sq->rear]=x; /*原队头元素送x 中*/

在不考虑队空的情况下，出队操作队头指针加1，表明队头元素出队。操作如下：
sq->front++;
x=sq->data[sq->front];

队中元素的个数：m=(sq->rear)-(q->front);
队满时：m= MAXSIZE； 队空时：m=0。

按照上述思想建立的空队及入队出队示意图如图3.12 所示，设MAXSIZE=10。从图中可以看到，随着入队出队的进行，会使整个队列整体向后移动，这样就出现了图3.12(d)中的现象：队尾指针已经移到了最后,再有元素入队就会出现溢出，而事实上此时队中并未真的“满员”，这种现象为“假溢出”，这是由于“队尾入队头出”这种受限制

的操作所造成。解决假溢出的方法之一是将队列的数据区data[0..MAXSIZE-1]看成头尾相接的循环结构，头尾指针的关系不变，将其称为“循环队”，“循环队”的示意图如图3.13所示。

因为是头尾相接的循环结构，入队时的队尾指针加1 操作修改为：

sq->rear=(sq->rear+1) % MAXSIZE;

出队时的队头指针加1 操作修改为：

sq->front=(sq->front+1) % MAXSIZE;

设MAXSIZE=10，图3.14 是循环队列操作示意图。

从图3.14 所示的循环队可以看出，(a)中具有a5 、a6 、a7 、a8 四个元素，此时front=4,rear=8；随着a9~a14 相继入队，队中具有了10 个元素---队满，此时front=4,rear=4,如（b）所示，可见在队满情况下有：front==rear。若在（a）情况下，a5~a8 相继出队，此时队空， front=4，rear=4，如（c）所示，即在队空情况下也有：front==rear。就是说“队满”和“队空”的条件是相同的了。这显然是必须要解决的一个问题。

方法之一是附设一个存储队中元素个数的变量如num，当num==0 时队空，当num==MAXSIZE 时为队满。

另一种方法是少用一个元素空间，把图（d）所示的情况就视为队满，此时的状态是队尾指针加1 就会从后面赶上队头指针，这种情况下队满的条件是： (rear+1) %MAXSIZE==front，也能和空队区别开。

下面的循环队列及操作按第一种方法实现。循环队列的类型定义及基本运算如下：
typedef struct {
datatype data[MAXSIZE]; /*数据的存储区*/
int front,rear; /*队头队尾指针*/
int num; /*队中元素的个数*/
}c_SeQueue; /*循环队*/

⑴ 置空队
c_SeQueue* Init_SeQueue()
{ q=malloc(sizeof(c_SeQueue));
q->front=q->rear=MAXSIZE-1;
q->num=0;
return q;
}

⑵ 入队
int In_SeQueue ( c_SeQueue *q , datatype x)
{ if (num==MAXSIZE)
{ printf(＂队满＂);
return –1; /*队满不能入队*/
}
else
{ q->rear=(q->rear+1) % MAXSIZE;
q->data[q->rear]=x;
num++;
return 1; /*入队完成*/
}
}

⑶ 出队
int Out_SeQueue (c_SeQueue *q , datatype *x)
{ if (num==0)
{ printf(＂队空＂)；
return –1; /*队空不能出队*/
}
else
{ q->front=(q->front+1) % MAXSIZE;
*x=q->data[q->front]; /*读出队头元素*/
num--;
return 1; /*出队完成*/
}
}

⑷ 判队空
int Empty_SeQueue(c_SeQueue *q)
{ if (num==0) return 1;
else return 0;
}

2． 链队

链式存储的队称为链队。和链栈类似，用单链表来实现链队，根据队的FIFO 原则，为了操作上的方便，我们分别需要一个头指针和尾指针，如图3.15 所示。

图3.15 中头指针front 和尾指针rear 是两个独立的指针变量，从结构性上考虑，通常将二者封装在一个结构中。链队的描述如下：
typedef struct node
{ datatype data;
struct node *next;
} QNode; /*链队结点的类型*/
typedef struct
{ QNnode *front,*rear;
}LQueue; /*将头尾指针封装在一起的链队*/

定义一个指向链队的指针：

LQueue *q;

按这种思想建立的带头结点的链队如图3.16 所示。

链队的基本运算如下：

(1) 创建一个带头结点的空队：
LQueue *Init_LQueue()
{ LQueue *q,*p;
q=malloc(sizeof(LQueue)); /*申请头尾指针结点*/
p=malloc(sizeof(QNode)); /*申请链队头结点*/
p->next=NULL; q->front=q->rear=p;
return q;
}

(2) 入队
void In_LQueue(LQueue *q , datatype x)
{ QNode *p;
p=malloc(sizeof(QNnode)); /*申请新结点*/
p->data=x; p->next=NULL;
q->rear->next=p;
q->rear=p;
}

(3) 判队空
int Empty_LQueue( LQueue *q)
{ if (q->front==q->rear) return 0;
else return 1;
}

(4) 出队
int Out_LQueue(LQueue *q , datatype *x)
{ QNnode *p;
if (Empty_LQueue(q) )
{ printf (＂队空＂)； return 0;
} /*队空，出队失败*/
else
{ p=q->front->neat;
q->front->next=p->next;
*x=p->data;/*队头元素放x 中*/
free(p);
if (q->front->next==NULL)
q->rear=q->front;
/*只有一个元素时，出队后队空，此时还要要修改队尾指针参考图3.16(c)*/
return 1;
}
}