数据结构--队列的基础知识

队列（Queue）

定义：队列是只允许在一端进行插入==（入队）==，在另一端删除（出队）==的线性表

先进先出（FIFO）

重要术语：队头、队尾、空队尾

队列的基本操作

1. InitQueue(&Q):初始化队列，构造一个空队列Q
2. DestroyQueue(&Q):销毁队列，销毁并释放队列Q所占的内存空间==（创、销）==
3. EnQueue(&Q,x):入队，若队列Q未满，将x加入。使之成为新的队尾==（增）==
4. DeQueue(&Q,&x):出队，若队列Q非空，删除队头元素，并用x返回==（删）==，删除队头
5. GetHead(Q,&x):读队头元素，若队列Q非空，则将队头元素赋值给x==(查)==，不删除队头
6. QueueEmpty(Q):判队列空，若队列Q为空返回true，否则返回false

队列的顺序实现

front：指向队头元素

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

#define MaxSize 10//定义队列中的最大值
typedef struct{
    ElemType data[MaxSize];//用静态数组（连续失误存储空间，大小MaxSize*sizeof（Elemtype）存放对列元素
    int front,rear;//队头指针和队尾指针
}SqQueue;

入队操作

//入队
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;//队尾指针加一取模
    return true;
}

%MaxSize:{0,1,2,…,MaxSize-1}将存储空间在逻辑上变成了“环状”

模运算将无限的整数域映射到有限的整数集合{0,1,2,…,b-1}上

出队操作

//出队（删）
bool DeQueue(SqQueue &Q,ElemType &s){
    if(Q.rear==Q.front)//判断队空
        return false;//队空则报错
    x=Q.data[Q.front];//把front的数据用x返回
    Q.front=(Q.front+1)%MaxSize;//指针后移
    return true;
}

//出队（查）
bool DeQueue(SqQueue &Q,ElemType &s){
    if(Q.rear==Q.front)//判断队空
        return false;//队空则报错
    x=Q.data[Q.front];//把front的数据用x返回
    
    return true;
}

判断队列已满、已空

方案一:

队满条件：队尾指针的再一个位置是队头，即(Q.rear+1)%MaxSize==Q.front

队空条件：Q.rear==Q.front

队列元素个数：(rear+MaxSize-front)%MaxSize

方案二：

#define MaxSize 10
typedef struct{
    ElemType data[MaxSize];
    int front,rear;
    int size;//队列当前长度,初始化时rear=front=0,size=0.插入成功Size++,删除成功size--
}SqQueue;

队满条件：size==MaxSize

队空条件：size==0

方案三:

#define MaxSize 10
typedef struct{
    ElemType data[MaxSize];
    int front,rear;
    int tag;//最近进行的是删除/插入，初始化rear=front=0,tag=0
}

• 每次删除操作成功时，都令tag=0；

• 每次插入操作成功时，都令tag=1；

队满条件：front==rear&&tag==1

队空条件：front==rear&&tag==0

队列链式实现（链队列）

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

typedef struct{//链式队列
    LinkNode *front,*rear;//队列的队头和队尾指针
}LinkQueue;

初始化（带头结点）

typedef struct LinkNode{
    ElemType data;
    struct LinkNode *next;
}LinkNode;

//初始化队列（带头结点）
void InitQueue(LinkQueue &Q){
    Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));//开辟一个存储空间，让front和rear都指向它
    Q.front->next=NULL;//front（头结点）的下一个节点指向NULL
}

void testLinkQueue(){
    LinkQueue Q;//声明一个队列
    InitQueue(Q);//初始化队列
}

//判断队列是否为空
bool IsEmpty(LinkQueue Q){
    if(Q.front==Q.rear)
        return true;
    else
        return false
}

初始化（不带头结点）

//初始化队列（不带头结点）
void InitQueue(LinkQueue &Q){
    //初始化是 front。rear都指向NULL
    Q.front=NULL;
    Q.rear=NULL;
}
//判断队列是否为空（不带头结点）
bool IsEmpty(LinkQueue Q){
    if(Q.front==NULL)
        return true;
    else
        return false;
}

入队（带头结点）

//新元素入队（带头结点）
void EnQueue(LinkQueue &Q,ElmeType x){
    LinkNode *s(linkNode *)malloc(sizeof(LInkNode));
    s->data=x;//把x赋到s的数据域里
    s->next=NULL;//s的指针指向NULL
    Q.rear->next=s;//头指针的next指向s
    Q.rear=s;//表尾指针指向s
}

入队（不带头结点）

//新元素入队（不带头结点）
void EnQueue(LinkQueue &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.rea->next=s;//新结点插入到rear结点之后
        Q.rear=s;//修改rear指针
    }
}

出队（带头结点）

//队头元素出队（不带头结点）
bool DeQueue(LinkQueue &Q,ElemType &x){
    if(Q.front==Q.rear)
        return false;//空队
    LinkNode *p=Q.front->next;//想要释放头结点后面的元素
    x=p->data;//把p中的数据给x。用变量x返回队头的元素
    Q.front->next=p->next;//修改头结点的next指针，头结点的next指针域指向p的下一个指针
    if(Q.rear==p)//如果是最后一个结点结队
        Q.rear=Q.front;//修改rear指针
    free(p);//释放结点空间
    return true;
}

出队（不带头结点）

//队列元素出队(不带头结点)
bool DeQueue(LinkQueue &Q,ElemType &x){
    if(Q.front==NULL)
        return false;//空队
    LInkNode *p=Q.front;
    x=p->data;
    Q.front=p->next;//front的指针指向p的下一个
    if(Q.rear==p){//若是最后一个结点出队
        Q.front=NULL;//front指向NULL
        Q.rear=NULL;//rear指向NULL
    }
    free(p);//释放结点空间
    return true;
}

队列满的条件

顺序存储–预分配的空间耗尽时队满

链式存储–一般不会队满，除非内存不足

双端队列

• 双端队列：只允许从两端插入、两端删除的线性表
  • 输入受限的双端队列：只允许从一端插入、两端删除的线性表
  • 输出受限的双端队列：只允许从两端插入、一端删除的线性表

考点：判断输出序列的合法性

栈中合法的序列，双端队列中一定合法