队列（Queue）基本概念

• 定义

  队列（Queue）时只允许在一端进行插入，在另一端删除的线性表。

  特点：先进入队列的元素先出队

  先进先出 First In First Out(FIFO)

  • 重要术语

    队头、队尾、空队列

 

• 基本操作

  • 创、销

    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

队列的顺序实现

• 用顺序存储实现队列

#define MaxSize 10       //定义队列中元素的最大个数
typedef struct{//静态数组：连续的存储空间，大小MaxSize*sizeof(ElemType)ElemType data[MaxSize]; //静态数组存放队列中元素int front,rear;               //队头指针和队尾指针
}SqQueue;                void testQueue(){SqQueue Q;  //声明一个队列（顺序存储）//……后续操作……
}

 

• 基本操作

  • 创（初始化）

    #define MaxSize 10       //定义队列中元素的最大个数
    typedef struct{ElemType data[MaxSize] //静态数组存放队列中元素int front,rear;               //队头指针和队尾指针
    }SqQueue;                //初始化队列
    void InitQueue(SqQueue &Q){//初始时 队头、队尾指针指向0Q.rear = Q.front = 0;
    }void testQueue(){    //声明一个队列（顺序存储）SqQueue Q;  InitQueue(Q);//……后续操作……
    }//判断队列是否为空
    bool QueueEmpty(SqQueue Q){if(Q.rear==Q.front)  //对空条件return true;elsereturn false;
    }
    

  • 增（入队）只能从队尾入队

    #define MaxSize 10       //定义队列中元素的最大个数
    typedef struct{ElemType data[MaxSize] //静态数组存放队列中元素int front,rear;               //队头指针和队尾指针
    }SqQueue;                //判断队列是否为空
    bool QueueEmpty(SqQueue Q){if(Q.rear==Q.front)  //对空条件return true;elsereturn false;
    }//入队
    bool EnEmpty(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;
    }
    

    ---

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

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

  • 

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

  • ---

    ❔ 不浪费一个存储单元 → 增设一个size数据成员

    #define MaxSize 10       //定义队列中元素的最大个数
    typedef struct{ElemType data[MaxSize] //静态数组存放队列中元素int front,rear;               //队头指针和队尾指针int size;            //队列当前长度
    }SqQueue;   
    

    ❔ 不浪费一个存储单元 → 增设一个tag数据成员

    #define MaxSize 10       //定义队列中元素的最大个数
    typedef struct{ElemType data[MaxSize] //静态数组存放队列中元素int front,rear;               //队头指针和队尾指针int tag;            //最近进行的是删除/插入//每次删除操作成功时，都令tag=0;//每次插入操作成功时，都令tag=1;
    }SqQueue;   
    

  • 删（出队）只能从对头元素出队

    //出队
    bool DeQueue(SqQueue &Q,ElemType &x){if(Q.rear+1==Q.front)  return false;  //队满则报错x = Q.data[Q.front];Q.front = (Q.front + 1)%MaxSize;//队头指针后移return true;
    }
    

  • 查（获取队头元素）

    //获得对头元素的值，用x返回
    bool GetHead(SqQueue Q,ElemType &x){if(Q.rear==Q.front)  return false;  //队空则报错x = Q.data[Q.front];return true;
    }

• 其他出题方式

  🐻‍❄️ 队尾指针rear指向队尾元素

  入队操作：

Q.rear = (Q.rear + 1)%MaxSize;
Q.data[Q.rear] = x;

 初始化：

        让front指向0的位置；让rear指向n-1的位置

判空：

        (Q.rear+1)%MaxSize=Q.front

判满：

        (Q.rear+1)%MaxSize=Q.front ❌

        方案一：牺牲一个存储单元（头指针再尾指针后两个位置）

        方案二：增加辅助变量（size/tag）

总结：

 

队列链式实现

• 定义

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

---

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

• 带头结点

 

 初始化

typedef struct LinkNode{     ElemType data;struct LinkNode *next;               
}LinkNode;                typedef struct{  LinkNode *front,*rear;  
}LinkQueue;//初始化队列
void InitQueue(LinkQueue &Q){//初始时 front rear都指向头结点Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));Q.front->next=NULL;
}void testLinkQueue(){LinkQueue Q;  //声明一个队列InitQueue(Q);  //初始化队列//……后续操作……
}//判断队列是否为空
bool IsEmpty(LinkQueue Q){if(Q.front == Q.rear)return true;elsereturn false;
}

 

 

 入队

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

 出队

//新元素出队
void DeQueue(LinkQueue &Q,ElemType &x){if(Q.front == Q.rear)return false;    //空队LinkNode *p=Q.front->next;x=p->data;        //用变量x返回队头元素Q.front->next=p->next;//修改头结点的next指针if(Q.rear==p)      //此次时最后一个结点出队Q.rear=Q.front;  //修改rear指针free(p);   //释放结点空间return true;
}

 不带头结点

 初始化

//初始化队列
void InitQueue(LinkQueue &Q){//初始时 front rear都指向NULLQ.front=NULL;Q.rear=NULL;
}//判断队列是否为空
bool IsEmpty(LinkQueue Q){if(Q.front == NULL)return true;elsereturn false;
}

 入队

//新元素入队
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.rear->next=s; //新结点插入到rear之后Q.rear=s;  //修改rear指针}
}

 出队

//新元素出队
void DeQueue(LinkQueue &Q,ElemType &x){if(Q.front ==NULL)return false;    //空队LinkNode *p=Q.front;  //p指向此次出队的结点x=p->data;        //用变量x返回队头元素Q.front=p->next;//修改front指针if(Q.rear==p)      //此次时最后一个结点出队Q.front=NULL;  //front指向NULLQ.rear=NULL;   //rear指向NULLfree(p);   //释放结点空间return true;
}

 🙌 链式存储——一般不对队满，除非内存不足

双端队列

栈：只允许从一端插入和删除的线性表

队列：只允许从一端插入，另一端删除的线性表

双端队列：允许从两端插入、两端删除的线性表

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

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

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

  若数据元素输入序列为1/2/3/4，则哪些输出序列是合法的？哪些是非法的？

  

  • 合法

    • 栈

      1/2/3/4；1/2/4/3；1/3/2/4；1/3/4/2；1/4/3/2；

      2/1/3/4；2/1/4/3；2/3/1/4；2/3/4/1；2/4/3/1；

      3/2/1/4；3/2/4/1；3/4/2/1

      4/3/2/1；

      14种合法出栈序列 

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

      在栈中非法在该方法下合法：

      1/4/2/3；2/4/1/3；3/1/2/4；3/1/4/2；3/4/1/2；4/1/2/3；4/1/3/2；4/3/1/2

    • 输出受限的双端队列（栈中合法的序列，双端队列中一定也合法）

      • 在栈中非法在该方法下合法：

        1/4/2/3；2/4/1/3；3/1/2/4；3/1/4/2；3/4/1/2；4/1/2/3；4/2/1/3；4/3/1/2