一、队列

      1.队列的定义

• 队列(queue)是只允许在一端进行插入操作，而在另一端进行删除操作的线性表；
• 与栈相反，队列是一种先进先出(First In First Out，FIFO)的线性表；
• 与栈相同的是，队列也是一种重要的线性结构，实现一个队列同样需要顺序表或链表作为基础。

      2.队列的链式存储结构

队列既可以用链表实现，也可以用顺序表实现，跟栈相反的是，栈一般我们用顺序表来实现，而队列我们常用链表来实现，简称为链队列。

代码实现：

typedef struct QNode{ElemType data;struct QNode *next;
}QNode, *QueuePrt;typedef struct{QueuePrt front,rear; // 队头、队尾指针
}LinkQueue;

我们将队头指针指向链队列的头结点，而队尾指针指向终端结点。(注：头结点不是必要的，但是为了方便操作，我们给它加上了。)

所以，由上图可知，当为空队列时，front和rear都指向头结点。

      3.队列的创建

• 首先在内存中创建一个头结点；
• 然后将队列中的头指针和尾指针都指向这个生成的头结点，因为此时是空队列。

代码实现：

initQueue(LinkQueue *q){q->front = q->rear = (QueuePtr)malloc(sizeof(QNode));if(!q->front){exit(0);}q->front->next = NULL;
}

      4.入队列操作

      实现过程：

代码实现：

InsertQueue(LinkQueue *q, ElemType e){QueuePtr p;p = (QueuePtr)malloc(sizeof(QNode));if(p == NUll){exit(0);}p->data = e;p->next = NULL;q->rear->next = p;q->rear = p;
}

      5.出队列操作

出队列操作是将队列中的第一个元素移出，队头指针不发生变化，改变头结点的next指针即可。

(1)出队列操作过程：

(2)如果原队列只有一个元素，那么我们就应该处理一下队尾指针

代码实现：

DeleteQueue(LinkQueue *q, ElemType *e){QueuePtr p;if(q->front == q->rear){return; // 空队列直接返回}p = q->front->next;*e = p->data;q->front->next = p->next;if(q->rear = p){q->rear = q->front;}free(p);
}

      6.销毁一个队列

由于链队列建立在内存的动态区，因此当一个队列不再有用时应当把它及时销毁掉，以免过多的占用内存空间。

代码实现：

DestoryQueue(LinkQueue *q){while(q->front){q->rear = q->front->next;free(q->front);q->front = q->rear;}
}

      7.队列的顺序存储结构

我们之前说到在队列的实现上，我们更愿意使用链式存储结构，那是为什么呢？我们先按照思路来构造队列的顺序存储结构，看看会遇到什么问题？

首先假设一个队列有n个元素，则顺序存储的队列需建立一个大于n的存储单元，并把队列的所有元素存储在数组的前n个单元，数组下标为0的一端是队头。如下图所示：

(1)入队列操作，就是在队尾追加一个元素，不需要任何移动，时间复杂度为O(1)。

(2)出队列操作，出队列则不同，因为我们已经假设下标为0的为止是队列的队头，因此每次出队列操作所有元素都要向前移动，时间复杂度为O(n)。

可以看出，这样出队列效率就很低。

如果我们不限制队头一定要在下标为0的为止，那么出队列的操作就不需要移动全体元素，就如下图，添加队头、队尾指针，出队列的时候让队头指针移动，入队列的时候移动队尾指针；

但是这样同样会出现问题，例如在如下图入队列时，可能就会出现数组下标越界的问题，可是事实上，我们数组下标0和1的位置都是空着的，这叫假溢出。

      (3)循环队列

要解决假溢出的办法就是如果后面满了，就再从头开始，也就是头尾相接的循环。

循环队列它的容量是固定的，并且它的队头和队尾指针都可以随着元素入出队列而发生改变，这样循环队列逻辑上就好像是一个环形存储空间。但是注意，在实际的内存中，是不可能有真正的环形存储区，我们只是用顺序表模拟出来的逻辑上的循环。

我们可以发现，循环队列的实现只需要灵活的改变front和rear指针即可，也就是让front和rear指针不断加1，即使超出了地址范围，也会自动从头开始。我们可以采取取模运算进行处理(因为取模运算的值永远不会大于除数，这里就是永远不会大于队列的Size)：

• (rear+1)%QueueSize
• (front+1)%QueueSize

代码实现：

定义循环队列

#define MAXSIZE 100
typedef struct{ElemType *base; // 用于存放内存分配基地址// 这里你也可以用数组存放int front;int rear;
}

初始化一个循环队列

initQueue(cycleQueue *q){q->base = (ElemType *)malloc(MAXSIZE * sizeof(ElemType));if(!q->base){exit(0);}q->front = q->rear = 0;
}

      入队列操作

InsertQueue(cycleQueue *q, ElemType){if((q->rear+1)%MAXSIZE == q->front){return; // 队列已满}q->base[q->rear] = e;q->rear = (q->rear+1)%MAXSIZE;
}

出队列操作

DeleteQueue(cycleQueue *q, ElemType *e){if(q->front = q->rear){return; // 队列为空}*e = q->base[q->front];q->front = (q->front+1)%MAXSIZE;
}

本文为原创文章，如果对你有一点点的帮助，别忘了点赞哦！比心！如需转载，请注明出处，谢谢！