数据结构和算法--队列

队列

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

队列的两个基本操作：

• 入队：将一个数据放到队列尾部；
• 出队：从队列的头部取出一个元素。
• 队列也是一种操作受限的线性表数据结构
• 它具有先进先出的特性，支持队尾插入元素，在队头删除元素。

我们看看如何实现队列：

• 假如用顺序存储形式实现，我们在每次插入元素时候就要将前面的元素整体移一位，这样就造成的时间复杂度是O(n)，性能也会收到影响
• 假如用循环链式存储实现，我们需要如何判定队列空和队列满的情况？
  • 当队列为空时候：front = rear
  • 首先我们通过尾插法添加元素，每加入一个元素rear指针就向前移一位：rear+1，指向队尾的下一个存储单元，为了实现循环利用取模运算：rear = (rear+1) % max;
  • 删除元素时候我们从队头开始，每删除一个front指针向后移一位：出队，front+1，指向下一个队首，实现循环：front = (front+1) % max;
  • 假如添加队列已经添加满了，就会导致front和rear指向同一块地址，这样就没法判断队列是否满了
  • 假如我们空出一个存储单元，当(Q.rear+1) % Q.max == Q.front，如果这样，就说明队列已经满了，并且，每次插入和删除不用移动队列中元素

队列的实现：

顺序存储实现：

准备：

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;
typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */

/* 循环队列的顺序存储结构 */
typedef struct
{
    QElemType data[MAXSIZE];
    int front;        /* 头指针 */
    int rear;        /* 尾指针，若队列不空，指向队列尾元素的下一个位置 */
}SqQueue;

初始化一个空队列Q

因为顺序队列在定义时候就已经创建了一个连续的内存地址，所以，这个地方只需要将front和rear全部设为0就行了

Status InitQueue(SqQueue *Q){
    Q->front = 0;
    Q->rear = 0;
    return OK;
}

将队列清空

将队列清空只需要将front和rear都置为0就行了，内存空间里面的数据在存入的时候覆盖掉就行了，没必要初始化

Status ClearQueue(SqQueue *Q){
    
    Q->front = Q->rear = 0;
    return OK;
}

判断队列是否为空

根据队列特性，队列为空时候，front和rear指向同一片内存空间就是，所以当front和rear相等时候就是队列为空，没必要两个都等于0

//6.3 若队列Q为空队列,则返回TRUR,否则返回FALSE;
Status QueueEmpty(SqQueue Q){
    //队空标记
    if (Q.front == Q.rear)
        return TRUE;
    else
        return FALSE;
}

返回队列的元素个数

//6.4 返回Q的元素个数,也就是队列的当前长度
int QueueLength(SqQueue Q){
    return (Q.rear - Q.front + MAXSIZE)%MAXSIZE;
}

得到队列的头元素

//6.5 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR;
Status GetHead(SqQueue Q,QElemType *e){
    //队列已空
    if (Q.front == Q.rear)
        return ERROR;
    
    *e = Q.data[Q.front];
    return OK;
    
}

插入元素

插入元素时候首先要判断下队列是否满了，如果没满，则只需在队尾加一个元素，然后将rear向后移动一位即可

//6.6 若队列未满,则插入元素e为新队尾元素
Status EnQueue(SqQueue *Q,QElemType e){
    
    //队列已满
    if((Q->rear+1)%MAXSIZE == Q->front)
        return ERROR;
    
    //将元素e赋值给队尾
    Q->data[Q->rear] = e;
    
    //rear指针向后移动一位,若到最后则转到数组头部;
    Q->rear = (Q->rear+1)%MAXSIZE;
    
    return OK;
}

删除队列元素

//6.7 若队列不空,则删除Q中队头的元素,用e返回值
Status DeQueue(SqQueue *Q,QElemType *e){
   
    //判断队列是否为空
    if (Q->front == Q->rear) {
        return ERROR;
    }
    
    //将队头元素赋值给e
    *e = Q->data[Q->front];
    
    //front 指针向后移动一位,若到最后则转到数组头部
    Q->front = (Q->front+1)%MAXSIZE;
    
    return OK;
}

打印队列中所有元素

因为打印时候我们不能改变front和rear，所有我们需要一个变量拿到front的初始值，然后改变这个临时变量即可，因为我们每删除一个元素就需要将front指针往后移一位，是通过公式取模：Q->front = (Q->front+1)%MAXSIZE；所以我们也通过这种方式，并且当i = rear时候意味着结束

Status QueueTraverse(SqQueue Q){
    int i;
    i = Q.front;
    while ((i+Q.front) != Q.rear) {
        printf("%d   ",Q.data[i]);
        i = (i+1)%MAXSIZE;
    }
    printf("\n");
    return OK;
}

链式存储实现：

准备

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;

typedef int QElemType; /* QElemType类型根据实际情况而定，这里假设为int */

typedef struct QNode    /* 结点结构 */
{
    QElemType data;
    struct QNode *next;
}QNode,*QueuePtr;

typedef struct            /* 队列的链表结构 */
{
    QueuePtr front,rear; /* 队头、队尾指针 */
}LinkQueue;

初始化队列

创建一个首节点

Status InitQueue(LinkQueue *Q){

    //1. 头/尾指针都指向新生成的结点
    Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));
    //2.判断是否创建新结点成功与否
    if (!Q->front) {
        return ERROR;
    }
    //3.头结点的指针域置空
    Q->front->next = NULL;
    return OK;
}

销毁队列Q

尾结点的标识就是next是空

Status DestoryQueue(LinkQueue *Q){
    
    //遍历整个队列,销毁队列的每个结点
    while (Q->front) {
        Q->rear = Q->front->next;
        free(Q->front);
        Q->front = Q->rear;
    }
    return OK;
    
}

将队列Q置空

将队列置空，和将队列销毁的区别就是置空会留一个空节点，而销毁是将所有节点全部free

/*6.3 将队列Q置空*/
Status ClearQueue(LinkQueue *Q){
    
    QueuePtr p,q;
    Q->rear = Q->front;
    p = Q->front->next;
    Q->front->next = NULL;
    
    while (p) {
        q = p;
        p = p->next;
        free(q);
    }
    return OK;
}

判断队列Q是否为空

/*6.4 判断队列Q是否为空*/
Status QueueEmpty(LinkQueue Q){
    if (Q.front == Q.rear)
        return TRUE;
    else
        return FALSE;
}

获取队列长度

也就是遍历一下队列的元素，我们也可以给队列顶一个length元素

int QueueLength(LinkQueue Q){
    int i= 0;
    QueuePtr p;
    p = Q.front;
    while (Q.rear != p) {
        i++;
        p = p->next;
    }
    return i;
}

插入元素

插入也就是在尾部加一个元素，然后将rear指针修改一下，指向新的队尾元素

/*6.6 插入元素e为队列Q的新元素*/
Status EnQueue(LinkQueue *Q,QElemType e){
    
    //为入队元素分配结点空间,用指针s指向;
    QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
    
    //判断是否分配成功
    if (!s) {
         return ERROR;
    }
    
    //将新结点s指定数据域.
    s->data = e;
    s->next = NULL;
    
    //将新结点插入到队尾
    Q->rear->next = s;
    
    //修改队尾指针
    Q->rear = s;
    
    return OK;
}

出队列一个元素

因为front指向的永远都是刚开始创建的首节点，所以front指向的节点永远不变，变的只是front->next，出队列其实就是将首节点的next移除链表

/*6.7 出队列*/
Status DeQueue(LinkQueue *Q,QElemType *e){
    
    QueuePtr p;
    
    //判断队列是否为空;
    if (Q->front == Q->rear) {
        return ERROR;
    }
    
    //将要删除的队头结点暂时存储在p
    p = Q->front->next;
    
    //将要删除的队头结点的值赋值给e
    *e = p->data;
    
    //将原队列头结点的后继p->next 赋值给头结点后继
    Q->front->next = p ->next;
    
    //若队头就是队尾,则删除后将rear指向头结点.
    if(Q->rear == p) Q->rear = Q->front;
    
    free(p);
    
    return OK;
}

获取队头元素

/*6.8 获取队头元素*/
Status GetHead(LinkQueue Q,QElemType *e){
   
    //队列非空
    if (Q.front != Q.rear) {
        //返回队头元素的值,队头指针不变
        *e =  Q.front->next->data;
        return TRUE;
    }
    
    return  FALSE;
    
}

遍历队列

/*6.9 遍历队列*/
Status QueueTraverse(LinkQueue Q){
    
    QueuePtr p;
    p = Q.front->next;
    while (p) {
        printf("%d ",p->data);
        p = p->next;
    }
    printf("\n");
    return OK;
}