数据结构——队列

队列：一种操作受限的线性表，只允许在表的一端进行插入，另一端进行删除；
入队——插入
出队——删除
特点：先进先出（First In First Out——FIFO）
队头（front）：只允许插入
队尾（rear）：只允许删除
队列的基本操作：
InitQueue(&Q):初始化队列，申请空间——创
QueueEmpty(Q)：判断队列是否为空
EnQueue(&Q,x)：入队，在队尾插入x（未满）——增
DeQueue(&Q,&x):出队，删除队头元素（非空），并用x带回——删
GetQueue(&Q,&x):读取队头元素值，并用x带回，不删除队头元素——查
一、顺序存储
1、队列实现
#define MaxSize 50 //定义队列中元素的最大个数
tupedef struct{
ElemType data[MaxSize];
int front,rear; //定义对头指针，队尾指针
}SqQueue;

2、判断队列是否为空
bool QueueEmpty(SqQueue Q){
if(Q,rear==Q.front)
return true;
else
return false;
}

3、入队操作——增
bool EnQunue(SqQueue &Q,ElemType x){
if((Q.rear+1)%MaxSize==Q.rear)
return false; //队满，报错
Q.data[Q.rear]=x; //新元素插入队尾
Q.rear=(Q.rear+1)%MaxSie;
//用“模运算”将存储空间在逻辑上变成“环状”
return true;
}

4、出队操作——删
bool DeQueue(SqQueue &Q,ElemType &x){
if(Q,rear==Q.front)
return false; //队空，报错
x=Q.data[Q.front];
Q.front=(Q.front+1)%MaxSize; //对头指针后移
return true;
}

5、获得对头元素值，并用x带回——查
bool GetQueue(SqQueue &Q,ElemType &x){
if(Q.rear==Q.front)
return false; //队空，报错
x=Q.data[Q.front];
return true;
}

6、区分队空对满的三种方法
（1）、浪费一个存储空间——空出一个队列节点
队空：Q.rearQ.front ; 队空；(Q.rear+1)%MaxSizeQ.front
队列元素个数(rear指向队尾元素的下一个元素)：(rear+MaxSize-front)%MaxSize

（2）、不浪费存储空间，即不单独留出一个队列结点；定义一个size变量，记录队列元素
队满条件：size==MaxSize; (rear指向队尾元素的后一个元素)
#define MaxSize 10
typedef struct{
ElemType data[MaxSize];
int rear,front;
int size; //记录队列元素个数，入队：size++;出队：size–；
}SqQueue;

（3）、
#defin MaxSize 10
typedef struct{
ElemType data[MaxSize]
int rear,front;
int tag; //最近进行的删除/插入
}SqQueue;
只有删除才能导致队空：frontrear && tag0
只有插入才能导致队满：frontrear && tag0 （rear指向队尾元素的后一个元素）

//以上操作入队时：
Q.data[Q.rear]=x;
Q.rear=(Q.rear+1)%MaxSize;

//若题目要求：rear指向队尾元素（不浪费空间）
Q.rear=(Q.rear+1)%Maxsize;
Q.data[Q.rear]=x;

判空
(Q.rear+1)%MaxSize;
判满有两种情况：1、牺牲一个结点的判空；2、size判空

二、链式存储

//队列的链式实现

typedef struct LinkNode{ //链式队列结点
ElemType data;
struct LinkNode *next;
}LinkNode;

typedef struct{
LinkNode *front ，*rear; //队列的对头和队尾指针
}LinkQueue;

//初始化
bool InitQueue(LinkQueue &Q){
Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));
Q,front->next=NULL;
}

void testLinkNode(){
LinkQueue Q; //声明
IintQueue (Q); //初始化
//…后续代码
}

//判空
bool IsEmpty(LinkQueue Q){
if(Q.rear==Q.front)
return true;
else
return false;
}

//初始化不到头结点的链式队列
bool InitQueue(LinkQueue &Q){
//初始化时front、rear都指向NULL
Q.rear=NULL;
Q.front=NULL;
}

//判空
bool IsEmpty(LinkQueue Q){
if(Q.front==NULL)
return true;
else false;
}

//带头结点的入队
void EnQueue(LinkQueue &Q,ElemType x){
LinkNode s=(LinkNode)malloc(sizeof(LinkNode));
s->data=x;
s->nezt=NULL;
Q.rear->nezt=s; //新结点插入到rear之后
Q,rear=s; //修改表尾指针
}

//不带头结点入队
void EnQueue(LinkNode &Q,ElemType x){
LinkNode s=(LinkNode)malloc(sizeof(LinkNode));
s->data=x;
s->next=NULL;
if(Q.front==NULL){
Q.front=s;
Q.rear=s
}else{
Q.rear->next=s; //新结点插入到队尾后面
Q.rear=s; //修改队尾指针
}
}

//出队（带头结点）
bool DeQueue(LinkQueue &Q,ElemType &x){
if(Q.rearQ.front)
return false; //队列空，报错
LinkNode *p=Q.front->next;
x=p->data; //用x返回值
Q.front->next=p->next; //修改头结点的next指针
if(Q.rearp)
Q.front=Q.rear; //修改rear指针
free§;
return true;
}

//出队（不带头结点）
bool DeQueue(LinkQueue &Q,ElemType &x){
if(Q.rearQ.front)
return false; //队空，报错
LinkNode p=(LinkNode)malloc(sizeof(LinkNode));
p->data=Q.front;
x=p->data;
Q.front->next=p->next; //修改front指针
if(Q.rearp){ //p为队尾元素
Q.front=NULL;
Q.rear=NULL;
}
free§;
return true;
}