手把手教你实现书上的队列，进来试试？

一.队列的基本概念

1. 队列的定义

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。

队头（Front）：允许删除的一端，又称队首。

队尾（Rear）：允许插入的一端。

空队列：不包含任何元素的空表。

2.队列的常见基本操作

// 初始化队列 
void QueueInit(Queue* q); 
// 队尾入队列 
void QueuePush(Queue* q, QDataType data); 
// 队头出队列 
void QueuePop(Queue* q); 
// 获取队列头部元素 
QDataType QueueFront(Queue* q); 
// 获取队列队尾元素 
QDataType QueueBack(Queue* q); 
// 获取队列中有效元素个数 
int QueueSize(Queue* q); 
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q); 
// 销毁队列 
void QueueDestroy(Queue* q);

一.队列设计

1.队列的顺序存储类型

#define MAXSIZE 50    //定义队列中元素的最大个数
typedef struct{
    dataType a[MAXSIZE];    //存放队列元素
    int front,rear;
}SeqQueue;

初始状态（队空条件）：Q->front == Q->rear == 0。

进队操作：队不满时，先送值到队尾元素，再将队尾指针加1。

出队操作：队不空时，先取队头元素值，再将队头指针加1。

设计一个链式的队列

2.队列的链式存储类型

typedef int QDataType;
typedef struct QueueNode
{
    QDataType data;
    struct QueueNode* next;
}QNode;

typedef struct Queue
{
    QNode* head;
    QNode* tail;
    int size;
}Queue;

queue.h

#pragma once
#include 
#include 
#include 
#include 

typedef int QDataType;
typedef struct QueueNode
{
    QDataType data;
    struct QueueNode* next;
}QNode;

typedef struct Queue
{
    QNode* head;
    QNode* tail;
    int size;
}Queue;

void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq); 

queue.c

初始化队列

void QueueInit(Queue* pq)
{
    assert(pq);

    pq->head = NULL;
    pq->tail = NULL;
    pq->size = 0;
}

判断是否栈空

bool QueueEmpty(Queue* pq)
{
    assert(pq);

    return pq->head == NULL && pq->tail == NULL;
}

入栈

void QueuePush(Queue* pq, QDataType x)
{
    assert(pq);

    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }

    newnode->data = x;
    newnode->next = NULL;

    if (pq->tail == NULL)
    {
        pq->head = pq->tail = newnode;
    }
    else
    {
        pq->tail->next = newnode;
        pq->tail = newnode;
    }

    pq->size++;
}

出栈

void QueuePop(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));

    if (pq->head->next == NULL)
    {
        free(pq->head);
        pq->head = pq->tail = NULL;
    }
    else
    {
        QNode* del = pq->head;
        pq->head = pq->head->next;

        free(del);
    }

    pq->size--;
}

获取队首元素/获取队尾元素

QDataType QueueFront(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));

    return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));

    return pq->tail->data;
}

获取队列中元素的个数

int QueueSize(Queue* pq)
{
    assert(pq);
    return pq->size;
}

销毁队列

void QueueDestroy(Queue* pq)
{
    assert(pq);

    QNode* cur = pq->head;
    while (cur)
    {
        QNode* del = cur;
        cur = cur->next;

        free(del);
        //del = NULL;
    }

    pq->head = pq->tail = NULL;
    pq->size = 0;
}

二.循环队列

解决假溢出的方法就是后面满了，就再从头开始，也就是头尾相接的循环。我们把队列的这种头尾相接的顺序存储结构称为循环队列。

当队首指针Q->front = MAXSIZE-1后，再前进一个位置就自动到0，这可以利用除法取余运算（%）来实现。

初始时：Q->front = Q->rear=0。

队首指针进1：Q->front = (Q->front + 1) % MAXSIZE。

队尾指针进1：Q->rear = (Q->rear + 1) % MAXSIZE。

队列长度：(Q->rear - Q->front + MAXSIZE) % MAXSIZE。

但是这种把循环队列存满数据的方式，会让我们不能通过Q->front == Q->rear来具体判断是否是队满还是队空，如图：

（1）牺牲一个单元来区分队空和队满，入队时少用一个队列单元，这是种较为普遍的做法，约定以“队头指针在队尾指针的下一位置作为队满的标志”，如图

队满条件： (Q->rear + 1)%Maxsize == Q->front

队空条件仍： Q->front == Q->rear

队列中元素的个数： (Q->rear - Q ->front + Maxsize)% Maxsize

（2）类型中增设表示元素个数的数据成员。这样，队空的条件为 Q->size == O ；队满的条件为 Q->size == Maxsize 。这两种情况都有 Q->front == Q->rear

（3）类型中增设tag 数据成员，以区分是队满还是队空。tag 等于0时，若因删除导致 Q->front == Q->rear ，则为队空；tag 等于 1 时，若因插入导致 Q ->front == Q->rear ，则为队满。

下面针对第一种方法来设计一个循环顺序队列

#define dataType int 

typedef struct {
    dataType* arr;
    int front;
    int rear;
    int size;
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* ret = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if (ret == NULL){
        perror("malloc::fail");
    }
    ret->arr = (dataType*)malloc(sizeof(dataType)*(k + 1));
    ret->front = ret->rear = 0;
    ret->size =k+1;
    return ret;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (((obj->rear + 1) %obj->size) == obj->front){//判断循环队列是否为满,%不是
    
        return false;
    }
    obj->arr[obj->rear] = value;
    obj->rear=(obj->rear+1)%obj->size;//不需要加MaxSize
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (obj->rear == obj->front){
        return false;
    }
    obj->front= (obj->front +1) % obj->size;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if (obj->rear == obj->front){
        return -1;
    }
    return obj->arr[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj){
    if (obj->rear==obj->front){
        return -1;
    }
    //因为是先存数据在加加，所以rear实际上是指向队尾的下一个元素
    //故最好在此处进行分类讨论
    if(obj->rear==0){
        return obj->arr[obj->size-1];
    }
    else{
        return obj->arr[obj->rear-1];
    }
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front == obj->rear;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    if (obj->front == (obj->rear + 1 + obj->size) % obj->size){
        return true;
    }
    return false;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->arr);//双层释放
    free(obj);
}

三.双端队列

1、定义

双端队列是指允许两端都可以进行入队和出队操作的队列，如下图所示。其元素的逻辑结构仍是线性结构。将队列的两端分别称为前端和后端，两端都可以入队和出队。

在双端队列进队时，前端进的元素排列在队列中后端进的元素的前面，后端进的元素排列在队列中前端进的元素的后面。在双端队列出队时，无论是前端还是后端出队，先出的元素排列在后出的元素的前面。

2、特殊的双端队列

在实际使用中，根据使用场景的不同，存在某些特殊的双端队列。

输出受限的双端队列：允许在一端进行插入和删除， 但在另一端只允许插入的双端队列称为输出受限的双端队列，如下图所示。

输入受限的双端队列：允许在一端进行插入和删除，但在另一端只允许删除的双端队列称为输入受限的双端队列，如下图所示。若限定双端队列从某个端点插入的元素只能从该端点删除，则该双端队列就蜕变为两个栈底相邻接的栈。