数据结构与算法第四讲:[队列]

作者: 85ca4232089b | 来源:发表于2020-04-14 11:39 被阅读0次

数据结构与算法（队列实现篇）
排序算法
集合相关数据结构与算法
数据结构与算法学习开篇
【数据结构与算法 - Swift实现】10 - 优先队列 (Pr
数据结构与算法第四讲:[队列]
数据结构与算法分析：大纲]
数据结构：数组
链式队列的定义，ios基础知识篇！
数据结构与算法之美-09讲队列

队列

什么是队列

先进者先出，就是"队列" 我们可以想象成，排队买票，先来的先买，后来的只能在末尾，不允许插队。
队列的两个基本操作：入队将一个数据放到队列尾部；出队从队列的头部取出一个元素。队列也是一种操作受限的线性表数据结构 它具有先进先出的特性，支持队尾插入元素，在队头删除元素。
队列的概念很好理解，队列的应用也非常广泛如：循环队列、阻塞队列、并发队列、优先级队列等

顺序对列

顺序对列示意图

循环对列

队列列的表示与操作实现.png

• 当rear==front==0的时候表示对列为空
• c1 c2 c3相继入对（从rear的方向入对）front不动
• c1 c2 相继出对（从front的方向出对）rear不动
• c3 c4 c5相继入对 c3 c4 相继出对
此时如果判断rear == front的话对列就已经满了，但是实际对列是没有满的，就会造成的情况假满
所有提出循环队列就相当于一个圆环，数组可以想象成一条直线，我们吧这条直线掰成一个圆环，就是循环队列，为了更形象的表示，可以看下图所示

循环对列.jpg

如上图所示，队列的大小为size = 11，队列head指向 5 ，队尾fail指向10，当向队尾添加一个元素F，这时fail = 0，这时再向队尾添加一个元素G，这时fail = 1.队列就变为下图所示

循环对列.jpg
循环队列的难点在于如何确定队空和队满的判定条件以及head和fail的变化.
总结一下规律，fail的变化，当fail=10，如何让fail = 0呢？很显然 fail = (fail+1)%size; 那么head同理也遵循这样的变化head=(head+1)%size.

如何判定队满呢？从上面的规律来看，我们可以发现(fail+1)%size == head的时候，队列就满了，但是fail指向的位置实际上是没有数据的，这就意味这循环队列浪费了一个存储空间，以空间换取时间

循环队列列中头尾指针与元素之间关系.png

所以为了判断对满的情况空出一个位置留白不用
判断队空: Q.front == Q.rear
判断队满: (Q.rear + 1) % MAXSIZE == Q.front

循环队列的顺序存储结构

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

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

循环对列顺序存储初始化

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

循环对列顺序存储清空

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

循环对列顺序存储判空

Status QueueEmpty(SqQueue Q){
    //队空标记
    if (Q.front == Q.rear)
        return TRUE;
    else
        return FALSE;
}

循环对列顺序存储的长度

int QueueLength(SqQueue Q){
    return (Q.rear - Q.front + MAXSIZE)%MAXSIZE;
}

循环对列顺序存储的对头元素

Status GetHead(SqQueue Q,QElemType *e){
    //队列已空
    if (Q.front == Q.rear)
        return ERROR;
    
    *e = Q.data[Q.front];
    return OK;  
}

循环对列顺序存储入队元素

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;
}

循环对列顺序存储出对

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;
}

循环对列顺序存储遍历

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

链式对列

链式对列.jpg

对列链式存储结点结构

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;
}

对列链式存储销毁对列

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

对列链式存储置空

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;
}

对列链式存储判空

Status QueueEmpty(LinkQueue Q){
    if (Q.front == Q.rear)
        return TRUE;
    else
        return FALSE;
}

对列链式存储的长度

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

对列链式存储入队

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;
}

对列链式存储出对

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;
}

对列链式存储头元素

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

对列链式存储遍历

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

demo