[数据结构]队列

[数据结构]队列

定义： 允许在一端进行插入，而在另一端进行删除的线性表。允许进行删除运算的一端队头，允许进行插入运算的一端队尾。
逻辑结构： 与线性表相同，仍为一对一关系。
存储结构： 用顺序队列或链队列存储均可。
运算规则： “先进先出”/“后进后出”
实现方式： 关键是编写入队和出队函数，具体实现依顺序队列或链队列的不同而不同。

队的表示：

ADT Queue{
	数据对象:D={ai | ai ∈ ElemSet ,i=1,2...,n,n>=0}
	数据关系:R1={<ai-1,ai>|ai-1,ai ∈ D,i=1,2,3...,n}
	//约定a1端为队列头,an端为队尾
	基本操作:初始化,入队,出队,构造空队列,销毁队列,清空队列,判空....	
}		

基本操作：

InitQueue(&Q);//构造空队列
DestroyQueue(&Q);//销毁队列
QueueEmpty(Q);//判空,空———TRUE
QueueLength(Q);//取队列长度
ClearQueue(&Q);//清空队列
GetHead(Q,&e);//取队头元素
EnQueue(&Q,e);//入队列
DeQueue(&Q,&e);//出队列
QueueTraverse(Q,visit());//遍历

队列的顺序表示——用一维数组base[M]

#define M 100//最大队列长度
Typedef struct{
  QElemType *base;//初始化的动态分配存储空间
  int front;//头指针
  int rear;//尾指针
 }SqQueue;

空队标志:front==rear
入队:base[rear++]=x;
出队:x=base[front++];

循环队列

循环队列的表示

#define MAXQSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXQSIZE 100//最大队列长度
typedef char QElemType;
typedef char SElemType;
typedef int Status;
Typedef struct{
  QElemType *base;//初始化的动态分配存储空间
  int front;//头指针
  int rear;//尾指针
 }SqQueue;

循环队列初始化

//算法　循环队列的初始化
Status InitQueue(SqQueue &Q) {//构造一个空队列Q
Q.base = new QElemType[MAXQSIZE]; //为队列分配一个最大容量为MAXSIZE的数组空间
if (!Q.base)
exit(OVERFLOW); //存储分配失败
Q.front = Q.rear = 0; //头指针和尾指针置为零，队列为空
return OK;
}

求循环队列的长度

//算法  求循环队列的长度
int QueueLength(SqQueue Q){
  return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
}

循环队列入队

//算法  循环队列入队
Status EnQueue(SqQueue &Q, QElemType e) {//插入元素e为Q的新的队尾元素
if ((Q.rear + 1) % MAXQSIZE == Q.front) //尾指针在循环意义上加1后等于头指针，表明队满
return ERROR;
Q.base[Q.rear] = e; //新元素插入队尾
Q.rear = (Q.rear + 1) % MAXQSIZE; //队尾指针加1
return OK;
}

循环队列出队

//算法  循环队列出队
Status DeQueue(SqQueue &Q,QElemType &e)
{
	if(Q.front==Q.rear)
	return ERROR;
	e=Q.base[Q.front];
	Q.front=(Q.front+1)%MAXQSIZE;
	return OK;
}

完整代码

#include<iostream>
#include<fstream>
using namespace std;

#define MAXQSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef char QElemType;
typedef char SElemType;
typedef int Status;

typedef struct {
QElemType *base;//初始化时动态分配存储空间
int front;//头指针
int rear;//尾指针
} SqQueue;
Status EnQueue(SqQueue &Q, QElemType e);
Status DeQueue(SqQueue &Q, QElemType &e);

//算法　循环队列的初始化
Status InitQueue(SqQueue &Q) {//构造一个空队列Q
Q.base = new QElemType[MAXQSIZE]; //为队列分配一个最大容量为MAXSIZE的数组空间
if (!Q.base)
exit(OVERFLOW); //存储分配失败
Q.front = Q.rear = 0; //头指针和尾指针置为零，队列为空
return OK;
}

//算法  求循环队列的长度
int QueueLength(SqQueue Q){
  return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
}

//算法  循环队列入队
Status EnQueue(SqQueue &Q, QElemType e) {//插入元素e为Q的新的队尾元素
if ((Q.rear + 1) % MAXQSIZE == Q.front) //尾指针在循环意义上加1后等于头指针，表明队满
return ERROR;
Q.base[Q.rear] = e; //新元素插入队尾
Q.rear = (Q.rear + 1) % MAXQSIZE; //队尾指针加1
return OK;
}

//算法  循环队列出队
Status DeQueue(SqQueue &Q,QElemType &e)
{
	if(Q.front==Q.rear)
	return ERROR;
	e=Q.base[Q.front];
	Q.front=(Q.front+1)%MAXQSIZE;
	return OK;
}

int main() {
   **对函数进行调用**
}

链队列

链队列的表示

typedef struct QNode {
QElemType data;
struct QNode *next;
} QNode, *QueuePtr;
typedef struct {
QueuePtr front; //队头指针
QueuePtr rear; //队尾指针
} LinkQueue;

链队列的初始化

//算法　链队的初始化
Status InitQueue(LinkQueue &Q) {//构造一个空队列Q
Q.front = Q.rear = new QNode; //生成新结点作为头结点，队头和队尾指针指向此结点
Q.front->next = NULL; //头结点的指针域置空
return OK;
}

销毁链队列

//算法  销毁链队列
Status DestroyQueue(LinkQueue &Q){
  while(Q.front){
    Q.rear=Q.front->next;
    free(Q.front);
    Q.front=Q.rear;}
  return OK;
}

判断链队列是否为空

//算法  判断链队列是否为空
Status QueueEmpty(LinkQueue Q){
   return(Q.front==Q.rear);
}

求链队列的队头元素

//算法  求链队列的队头元素
Status GetHead(LinkQueue Q,QElemType &e){
 if(Q.front==Q.rear)
 return ERROR;
 e=Q.front->next->data;
 return OK;
}

链队列入队

//算法　链队的入队
Status EnQueue(LinkQueue &Q, QElemType e) {//插入元素e为Q的新的队尾元素
QueuePtr p;
p = new QNode; //为入队元素分配结点空间，用指针p指向
p->data = e; //将新结点数据域置为e
p->next = NULL;
Q.rear->next = p; //将新结点插入到队尾
Q.rear = p; //修改队尾指针
return OK;
}

链队列出队

//算法　链队的出队
Status DeQueue(LinkQueue &Q, QElemType &e) {
QueuePtr p;
if(Q.front==Q.rear)
return ERROR;
p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if(Q.rear==p)
Q.rear=Q.front;
delete p;
return OK;
}

完整代码

#include<iostream>
#include<fstream>
#include<bits/stdc++.h>
using namespace std;

#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef char QElemType;
typedef int Status;
typedef char SElemType;

//- - - - - 队列的链式存储结构- - - - - 
typedef struct QNode {
QElemType data;
struct QNode *next;
} QNode, *QueuePtr;
typedef struct {
QueuePtr front; //队头指针
QueuePtr rear; //队尾指针
} LinkQueue;
Status EnQueue(LinkQueue &Q, QElemType e); 
Status DeQueue(LinkQueue &Q, QElemType &e);

//算法　链队的初始化
Status InitQueue(LinkQueue &Q) {//构造一个空队列Q
Q.front = Q.rear = new QNode; //生成新结点作为头结点，队头和队尾指针指向此结点
Q.front->next = NULL; //头结点的指针域置空
return OK;
}
//算法  求链队列的队头元素
Status GetHead(LinkQueue Q,QElemType &e){
 if(Q.front==Q.rear)
 return ERROR;
 e=Q.front->next->data;
 return OK;
}
//算法  判断链队列是否为空
Status QueueEmpty(LinkQueue Q){
   return(Q.front==Q.rear);}
//算法  销毁链队列
Status DestroyQueue(LinkQueue &Q){
  while(Q.front){
    Q.rear=Q.front->next;
    free(Q.front);
    Q.front=Q.rear;}
  return OK;
}
//算法　链队的入队
Status EnQueue(LinkQueue &Q, QElemType e) {//插入元素e为Q的新的队尾元素
QueuePtr p;
p = new QNode; //为入队元素分配结点空间，用指针p指向
p->data = e; //将新结点数据域置为e
p->next = NULL;
Q.rear->next = p; //将新结点插入到队尾
Q.rear = p; //修改队尾指针
return OK;
}
//算法  链队的出队
Status DeQueue(LinkQueue &Q, QElemType &e) {//插入元素e为Q的新的队尾元素
QueuePtr p;
if(Q.front==Q.rear)
return ERROR;
p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if(Q.rear==p)
Q.rear=Q.front;
delete p;
return OK;
}

int main() {
  **对函数进行调用**
}

注意： 当队列中的元素个数变化较大时，应该采用链队列；反之，应该采取循环队列。此外，如果确定不会发生溢出，也可以采用顺序队列。

例题

● 最短路径问题
● 迷宫问题