数据结构学习：队列

数据结构学习：队列
栈（Stack）是只允许在一端进行插入或删除操作的线性表
队列（Queue）是只允许在一端进行插入，在另一端删除的线性表

队列的特点：先进先出

InitQueue(&Q)：初始化队列，构造一个空队列Q。

DestroyQueue(&Q)：销毁队列。销毁并释放队列Q所占用的内存空间。

EnQueue(&Q,x)：入队，若队列Q未满，将x加入，使之成为新的队尾。

DeQueue(&Q,&x)：出队，若队列Q非空，删除队头元素，并用x返回。

GetHead(Q,&x)：读队头元素，若队列Q非空，则将队头元素赋值给x。

其他常用操作：
QueueEmpty(Q)：判队列空，若队列Q为空返回true，否则返回false。

typedef struct
{
ElemType data[MaxSize]; //静态数组存放队列中的元素
int front,rear; //队列头指针和尾指针
}SqQueue //sequence Queue 顺序队列

//队列初始化
void InitQuene(SqQueue &Q)
{
Q.rear = Q.front = 0;//初始化，将队头队尾指针指向0
}
//判断队列是否为空
bool EmptyQuene(SqQueue Q)
{
if(Q.rear == Q.front)
return true;
else
return false;
}
//入队
bool EnQuene(SqQueue &Q,ElemType e)
{
if(Q.rear + 1 = MaxSize)//队列已满
return false;
Q.data[Q.rear] = e;
Q.rear = Q.rear +1;//指针后移
return true;
}
//如果是循环队列的话
//第一种判断队列是否为空与顺序队列一样
bool EmptyQuene(SqQueue Q)
{
if(Q.rear == Q.front)
return true;
else
return false;
}
//入队
bool EnQuene(SqQueue &Q,ElemType e)
{
if((Q.rear + 1)%MaxSize == Q.front)//判断队列已满
return false;
Q.data[Q.rear] = e;
Q.rear = (Q.rear + 1)%MaxSize;//队尾指针+1取模
return true;
}
//出队，并用e返回
bool DeQuene(SqQueue &Q,ElemType &e)
{
if(Q.rear == Q.front)//判断队列已空
return false;
e = Q.data[Q.front];
Q.front = (Q.front + 1)%MaxSize;//队头指针+1取模后移
return true;
}
//获取队头元素值，并用e返回
bool GetHead(SqQueue &Q,ElemType &e)
{
if(Q.rear == Q.front)//判断队列已空
return false;
e = Q.data[Q.front];
return true;
}
//队列元素个数：(rear+MaxSize-front)%MaxSize
第二种判断队列是否满/空的方法
在定义节点是添加一个用于统计的元素size来记录队列中元素的个数
当size == MaxSize -1 时，队列满，当size == 0 时，队列为空

第三种判断队列是否为满/空的方法
在定义节点是添加一个标记操作的元素tag;
每次删除操作成功时，都令tag=0 ;
每次插入操作成功时，都令tag=1 ;
队空条件：frontrear && tag == 0
队满条件：frontrear && tag == 1

链队列——链式存储实现的队列

链队列
typedef struct LinkNode //链式队列的结点实现
{
ElemType data; //结点的数据域
struct LinkNode *next;//结点的指针域，指向下一个几点
}LinkNode;
typedef struct
{
LinkNode *front,*rear;//定义队列的队头指针和队尾指针
}LinkQuene

//队列的初始化(带头结点)
void InitQuene(LinkQuene &Q)
{
Q.front = Q.rear = (LinkNode *)malloc(sizeof(LinkNode));
Q.front->next = NULL;
}
//判断队列是否为空(带头结点)
bool IsEmpty(LinkQuene &Q)
{
if(Q.front == Q.rear)
return true;
else
return false;
}

//队列的初始化(不带头结点)
void InitQuene(LinkQuene &Q)
{

Q.front = NULL;
Q.rear = NULL;

}
//判断队列是否为空(不带头结点)
bool IsEmpty(LinkQuene &Q)
{
if(Q.front == NULL)
return true;
else
return false;
}

//新元素入队列(带头结点)
void EnQuene(LinkQuene &Q, ElemType x)
{
LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));//定义一个新的结点
s->data = x;
s->next = NULL;
Q->rear->next = s; //把新结点插入到队尾的后面
Q->rear = s; //修改队尾到s

//新元素入队列(不带头结点)
void EnQuene(LinkQuene &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; //修改队尾到s
}
}

//队头元素出队(带头结点)
bool DeQuene(LinkQuene &Q,ElemType &x)
{
if(Q.front == Q.rear)//队列为空
return false;
LinkNode *p = Q.front->next;//Q.front指向头结点
x = p->data;
Q.front->next = p->next;
if(Q.rear == p)//出队的是队列中的最后一个元素，则修改队尾指针
Q.rear = Q.front;
free§;
return true;
}

//队头元素出队(不带头结点)
bool DeQuene(LinkQuene &Q,ElemType &x)
{
if(Q.front == NULL) //队列为空
return false;
LinkNode *p = Q.front; //定义一个指针p指向队头指针
x = p->data;
Q.front = p->next; //头指针后移
if(Q.rear == p) //出队的是队列中的最后一个元素，则修改队尾指针
Q.rear = Q.front = NULL;
free§;
return true;
}

双端队列

栈中的合法序列：
卡特兰数：

输入受限的双端队列：
栈中合法的序列，双端队列中一定也合法