数据结构-队列

1.队列的基本概念
2. 队列的顺序实现
3. 队列的链式实现
4. 双端队列

1:
1.1:只允许一端插入，另一端删除的线性表。
1.2：特点：先进先出（FIFO）
1.3:基本操作
【创销】
1.3.1:InitQueue（&Q）:初始化队列，构造一个空队列。
1.3.2:DestroyQueue（&Q):销毁队列，释放所占用的内存空间
【增删】
1.3.3:EnQueue（&Q，x）：入队，若队列未满，将x加入，使之成为新的队尾。
1.3.4DeQueue（&Q，&x）：出队，若队列Q非空，删除队头元素，并用x返回。
【查】
1.3.5:GetHead（Q，&x）：读队头元素，若队列Q非空，则将队头元素赋值给x。
【其他常用操作】
1.3.6:QueueEmpty（Q）：判断队列空，若为空返回true，非空返回false。
1.3.7:GetHead（Q，&X）：读队头元素，若队头Q非空，则将队头元素赋值给x
【栈和队列是操作受限的线性表，因此不是任何对线性表的操作都可以作为栈和队列的操作，比如不可以随便读取栈或队列中间的某个数据】

2:队列的顺序实现
【定义】
【初始化】
【判空】Q.frontQ.rear=0
【进队】队不满时，先送值到队尾元素，再将队尾+1==【这里和栈的操作正好相反，栈中是先+1再将元素送入】
【出队】队不空时，先取队头元素值，再将队头指针+1
因为是从尾进从头出

#define	MaxSize 10
typedef struct{
ELemType data[MaxSize];
int front,rear;//队头队尾指针
}SqQueue;
//一般队头指向第一个有意义的元素，队尾指向最后一个有意义的元素的下一个。
//下标从0开始，front指向0，该队列中含有4个元素，那么分别占有下标【0】，【1】，【2】，【3】，此时3为最后一个有意义的元素，那么rear指向下标4.
//初始化操作
void InitQueue(SqQueue &Q){
//初始，队头队尾全部指向0，数据进入后，队尾元素指向下一个下标【不含元素的位置】
Q.rear=Q.front=0;//初始化队头队尾指针
}
//判空操作：看队头和队尾是否相等
bool QueueEmpty(SqQueue Q){
if(Q.rear==Q.front)//队空条件
return true;
else
return false;

void testQueue(){
//声明一个队列（顺序存储）
SqQueue Q；
InitQueue(Q);
}

2-1【入队操作】【增】

#define	MaxSize 10
typedef struct{
ELemType data[MaxSize];
int front,rear;//队头队尾指针
}SqQueue;
//入队
bool EnQueue（SqQueue &Q,ElemType x){
if(队列已满）//条件：(Q.rear+1)%MaxSize==Q.front
return false；
Q.data[Q.rear]=x;//将x放入队尾元素，因为原先队尾指向的就是没有任何元素的位置
Q.rear=Q.rear+1;//队尾后移
//Q.rear=(Q.rear+1)%MAxsize;表示逻辑上变成一个环状
return true;

在这里对队列已满的条件进行分析，如果rear==MaxSize的话，是不能判断队列是否已满的，因为当队尾已maxsize时，队头释放元素，空间也被释放，此时的空间是不满的。
因此，引入一个取余的操作就能判断是否已满。
(Q.rear+1)%MAxsize【其中maxsize表示全部数的个数，而Q.rear+1代表下标】
得到如果此时队列里有十个数的话，最后一个的下标应该为9，那么9+1对10取模余数为0，此时rear指向0下标的位置。

而通过取余运算，是将无限的整数域映射到了有限的整数集合上，将一个链状的结构转变为一个环状的循环了起来。

【循环队列】
初始：Q.front=Q.rear=0
队首指针进1:Q.front=(Q.front+1)%Maxsize
队尾指针进1:Q.rear=(Q.rear+1)%MaxSize
队列长度：（Q.rear+MaxSIze-Q.front)%MaxSize
出队入队时，都按顺时针方向进1

而在这种结构中，队列剩余最后一个存储空间时就表明该队列已满。
【剩余一个存储空间】的原因是为了和判断队空的条件分别开，如果没有保留最后一个存储空间，就会造成判空判满条件相同，无法区别到底是满还是空。
【代价就是牺牲了一个存储单元】
所以，队列已满的条件就是队尾指针的再下一个位置是队头，即（Q.rear+1)%maxsize==Q.front

2-2【出队操作】【删】

bool DeQueue（SqQueue &Q，ElemType &X）{
if(Q.rear==Q.front)
return false;//队空报错
X=Q.data[Q.front]//从队头出，将队头元素给x【先取值，再将队头指针+1】
Q.front=(Q.front+1)%Maxsize//循环成环，指针后移//队首指针进1
return true；

【入队操作】加

bool EnQueue(SqQueue &Q,Elemtype x){
if((Q.rear+1)%MaxSize==Q.front)
return false;//队满报错
Q.data[Q.rear]=x;//先送值到队尾
Q.rear=(Q.rear+1)%maxsize;//再加1
return true;

2-3【查】

//获得队头元素，用x返回
bool GetHead(SqQueue Q,ElemType &x)
if(Q.rear==Q.front)
return false;//队空报错
X=Q.data[Q.front];//只取值
return true;
}//相比出队只要不让往后移动就可以

2-4【其他】
队列元素个数：（rear+maxsize-front）%Maxsize

2-5【不牺牲存储空间判断队满队空】
那么就是队满队空条件是一样的情况下，引入新的条件，设置一个新的指标size，表示队列当前长度，只要插入成功就要size++，删除就要size–，最后队满：sizemaxsize，队空size0；

2-6【tag指标】

每次删除成功，都令tag=0，添加成功就tag=1
只有删除才能导致队空，加入导致队满
因此，队满：frontrear&&tag1
队空：frontrear&&tag0

2-7【其他出题方式】
起初给定的rear指向的是最后一个有效数据的下一个位置，现在将rear指向最后一个有效数据。
从而引起了入队操作的改变
改为：

Q.rear=(Q.rear+1)%maxsize;//先移动队尾位置
Q.data[Q.rear]=x;//放入数据

引起初始操作改变

Q.rear=(Q.rear+1)%maxsize;
Q.data[Q.rear]=x;
//将队头指向0，队尾指向n-1
//判空：（Q.rear+1)%maxsize==Q.front
//判满：操作同之前的判空判满条件一致的解决策略
//1：牺牲一个存储单元
//2:增加辅助变量，标记是哪个操作

3:链式存储实现队列
【带头结点】和【不带头结点】
【增（入队）】
【删（出队）】
【查（获取队头元素）】
【创（初始化）】
【判空判满，进行增删查之前的必要判断】

typedef struct LinkNode{//链式队列结点
ElemType data;
Struct LinkNode *next;
}LinkNode;
typedef Struct{//链式队列
LinkNode *front,*rear;//指针
}LinkQueue;

如果只有一个指针时间复杂度高
【初始化】带头结点
申请头结点的空间，此时的头结点（空队列）是头尾指针都指向头结点的。
头结点—>next=null

【初始化】不带头结点

【入队】带头结点

因为队列是受限制的线性表，所以入队插入操作要在队尾进行，因此是队列中最后一个元素。

【入队】不带头结点
【出队】带头结点

【出队】不带头结点

【队列满的情况】
对于链式存储，一般不会队满，除非内存不足。

4:双端队列
只允许从两端插入，两端删除的线性表

考点：判断输出序列的合法性
题目：输入序列为1，2，3，4求出以下条件的输出序列
（1）可以由输入受限的双端队列得到，但是不能由输出受限的双端队列得到
（2）可以由输出受限的双端队列得到，但是不能由输入受限的双端队列得到
（3）两者都不能

可以进可以出的那一端，出相当于栈的出栈
这里提到一个原先的内容，在栈中有一个数学性质，n个不同元素进栈，出栈元素不同排列的个数为1/（n+1）c【上n下2n】被称为卡特兰数
【1】卡特兰数证明有14个可以输出的情况，而总数为432*1，做差得10。
表示仅通过end1端（输入输出那一头）得不到的有10个，即输出受限得不到的有10个
【2】两者混合输出又可以输出10个中的8个
【3】剩下两个是不能通过输入受限的双端队列输出的（4231和4213）

答案：
【1】输入可得到输出得不到：4132
【2】输出可得到输入得不到：4213
【3】二者都不可以：4231