【数据结构&队列】

数据结构-队列的复习

---

一、队列的定义

栈是只允许在一端进行插入或删除操作的线性表；（入栈、出栈）
队列是只允许在一端进行插入，而在另一端进行删除的线性表。（入队，出队）
重要术语：
队头：允许删除的一端
队尾：允许插入的一端
空队列
队列的特点：先进先出（FIFO)

二、队列的顺序实现

1.初始化操作

#define MaxSize 10 //定义队列中元素的最大个数
typedef struct {
ElemType data[MaxSize];//用静态数组存放队列元素
int front,rear;//队头指针和队尾指针
}SqQueue;
//初始化队列：
void InitQueue(SqQueue &Q){
Q.rear =Q.front =0;
}
//声明一个队列
void testQueue()
{//声明一个队列，顺序存储
SqQueue Q;
InitQueue(Q);
//后续操作...
}
//判断队列是否为空
bool QueueEmpty(SqQueue Q)
{
if (Q.front ==Q.rear)//队空条件
  return true;
else
  return false;
}

front指向队头元素
rear指向队尾元素后面的一个位置（下一个应该插入的位置）

2.队列的增删改查：

入队操作：

bool EnQueue (SqQueue &Q,ElemType x){
/*
if(队列已满）
return false;
*/
Q.data[Q.rear]=x; //将x插入队尾
Q.rear = Q.rear +1;//队尾指针后移
return true;

能不能认为当队尾指针的值等于MaxSize的时候，这个队列就满了呢？
不然。
如果接下来依次让几个队头元素出队的话，那么我们的队头指针会依次后移，同时，该静态数组前面的数据元素就空闲了，所以如果接下来还有新元素要入队，那我们可以把它们插入到前面的这些位置。
此时需要进行以下操作：

Q.data[Q.rear]=x; //将x插入队尾
Q.rear =(Q.rear+1)%MaxSize;//队尾指针加一并取模

这里，用模运算将存储空间在逻辑上变成了“环状”
则此时就可以得出队列已满的条件是：
队尾指针的在下一个元素是队头，即：

(Q.rear+1)%MaxSize == Q.front

为什么不是(Q.rear)%MaxSize == Q.front呢？
因为：前面判断队空的条件是(Q.front ==Q.rear)；为了避免混淆，这样的代价是牺牲了一个存储单元
所以入队的完整代码如下

bool EnQueue (SqQueue &Q,ElemType x){

if((Q.rear+1)%MaxSize == Q.front）
return false;
else{
Q.data[Q.rear]=x; //将x插入队尾
Q.rear =(Q.rear+1)%MaxSize;//队尾指针加一并取模
return true;
}

出队操作：

bool DeQueue (SqQueue &Q,ElemType &x){

if(Q.rear == Q.front）
return false;//队空，则报错
else{
x = Q.data[Q.front]; 
Q.front =(Q.front+1)%MaxSize;//队头指针后移
return true;
}

读取队头元素：

bool GetHead (SqQueue Q,ElemType &x){

if(Q.rear == Q.front）
return false;//队空，则报错
else{
x = Q.data[Q.front]; 
return true;
}

求队列元素个数的方法：（这个要记住，很常考）

num =(rear+MaxSize-front)%MaxSize

假如出题老师不允许浪费区域：
定义一个Size
插入成功
Size ++;
删除成功：
Size–;
初始化时：rear =front =0;
size =0;
则此时：
队满条件：size =MaxSize;
以下是第二种方法）
新增一个tag
每次删除成功时，都令tag =0;
每次新增成功时，都令tag =1；
只有删除操作才能导致队空；
只有插入操作才能导致队满。
所以此时队空的判断条件为：

front ==rear &&tag ==0

此时队满的判断条件为：

rear == front &&tag ==1

队尾指针指向队尾元素时的情况。

队列的链式实现：

带头结点：

总结：