【嵌入式学习历程10】数据结构之队列

前面 我们讲了栈，知道栈有顺序存储和链式存储两种方式，今天的主角--队列也是一样的。

我们先来理清队列的概念：

1、队列是特殊的线性表；

队列仅在线性表两端进行操作；

队头（Front）：取出数据的一端；

队尾（Rear）：放入数据的一端；

2、性质：先进先出（FIFO）

3、顺序队列（一般采用循环队列）

规定front指针指向队头元素，rear指针指向队尾元素的下一个位置，这样当front等于rear的时候，就表示该队列为空队列。
下面，我们上图



我们可以举个栗子，比如食堂打饭，下课之前，食堂空无一人，也就是空队列。下课后，大家陆陆续续来到食堂开始排队，但是由于空间限制，当这个队伍到一定的长度时，后面有一堵墙挡住了，就相当于队列有一个最大容量MAXSIZE，我们就假设是8,。但是我们看这个rear是如何规定的---rear指针指向队尾元素的下一个位置，所以，这个队伍实际上只能容纳7人，即对于一个容量为MAXSIZE的队列，最多只能存放MAXSIZE-1个元素。那么有人要问了，为啥不直接让rear指向最后一个元素呢，这样不就万事大吉了。然实则非也，之所以这样规定是有它的道理的。如果rear直接指向最后一个元素，那么当这个队列只有一个元素时，那么这个元素既是第一个也是最后一个，那么，front和rear就同时指向这个元素，当队列为空的时候也是front等于rear。那我们怎么区分0和1呢？

看到这里，我们就发现了顺序队列有个缺点，如果再来一个元素插进来，那么rear将何去何从呢，这时候会出现假溢出的现象，为了解决这个问题，我们一般采用循环队列。

循环队列，说白了就是头尾相接的队列，那么这种情况下，rear也会出现在front的前面。比如，上面图中的1号出队了，这时候又来个8号，这时候8号就排在了7号之后，但是rear就指向了1号出队后的空缺，那么front去哪了呢。我们为什么要取名为front呢，因为它是队头呀，那么当原本的队头1号出队了，front还有必要指向它吗？所以，当1号出队时，front已经指向了2号。我们说队列是先进先出的，那么当队列变成循环的了，应该先出那个呢？没错，这就是front的作用了，当然是先出front所指向的队头啦。

那么我们怎么知道队列的长度以及是否满了呢？

1.判断队列是否满：

（rear + 1） % MAXSIZE  = = front;

2.求取队列的长度：

（rear - front + MAXSIZE） % MAXSIZE;

注意：这里的rear和front都是数组的下标。

typedef  struct {

    int data[MAXSIZE];

    int front;

    int rear;

   }SqQueue;

初始化一个空队列Q：
   int InitQueue(SqQueue *Q)
   {
    Q->front = 0;
    Q->rear  = 0;
    return OK; 
   }

循环队列的入队列：
   int EnQueue(SqQueue *Q, int e)
   {
    if((Q->rear+1)%MAXSIZE ==Q->front)
    return ERROR;
    Q->data[Q->rear] = e;
    Q->rear=(Q->rear+1)%MAXSIZE;
      return OK;
   }

循环队列的出队列：
   int DeQueue(SqQueue *Q, int *e)
   {
    if(Q->rear==Q->front)
    return ERROR;
    *e=Q->data[Q->front];
    Q->front=(Q->front+1)%MAXSIZE;
    return OK;
   }

4、链队

队列的链式存储结构，其实就是线性表的单链表，只是它只能够从尾进队、从头出队。一般，我们将队头指针指向链队列的头结点，而将队尾指针指向尾结点。

下面我们来实现链队的基本功能

头文件：

#ifndef _LINKQUEUE_H_
#define _LINKQUEUE_H_

#define FAILURE 10000
#define SUCCESS 10001

typedef int ElemType;

typedef struct node
{
ElemType data;
struct node *next;
}Node;

typedef Node *LinkNode;

typedef struct queue
{
LinkNode front;
LinkNode rear;
}Queue;

typedef Queue *LinkQueue;

#endif


接口函数实现：
#include <stdio.h>
#include <stdlib.h>
#include "LinkQueue.h"

/* 初始化队列 */
int InitQueue(LinkQueue *Q)
{
(*Q)->front = (LinkNode)malloc(sizeof(Node));
if ((*Q) == NULL)
{
return FAILURE;
}
(*Q)->rear = (*Q)->front;
(*Q)->front->next = NULL;
return SUCCESS;
}

/* 进队 */
int EnQueue(LinkQueue *Q, ElemType x)
{
LinkNode p = (LinkNode)malloc(sizeof(Node));

if(NULL == p)
{
return FAILURE;
}
p->data = x;
p->next = NULL;
(*Q)->rear->next = p;
(*Q)->rear = p;
return SUCCESS;
}

/* 求队列长度 */
int QueueLength(LinkQueue Q)
{
int length = 0;
LinkNode q = Q->front;
while(q->next)
{
length++;
q = q->next;
}
return length;
}

/* 出队 */
int DelQueue(LinkQueue *Q)
{
ElemType x;
LinkNode p = (*Q)->front->next;

if (NULL == p)
{
return FAILURE;
}

x = p->data;
(*Q)->front->next = p->next;
free(p);

if (NULL == p->next)
{
(*Q)->rear = (*Q)->front;
}

return x;
}

/* 获取队头 */
int GetFront(LinkQueue *Q)
{
LinkNode p = (*Q)->front->next;

if (NULL == p)
{
return FAILURE;
}
return p->data;
}

/* 清空队列 */
int ClearQueue(LinkQueue *Q)
{
LinkNode p = (*Q)->front->next;

if(NULL == p)
{
return FAILURE;
}

while(p)
{
(*Q)->front->next = p->next;
free(p);
p = (*Q)->front->next;
}

if(NULL == p)
{
(*Q)->rear = (*Q)->front;
}
return SUCCESS;
}

/* 销毁队列 */
int DestroyQueue(LinkQueue *Q)
{
if(NULL == (*Q))
{
return FAILURE;
}

free((*Q)->front);
(*Q)->front = NULL;
(*Q)->rear = NULL;
return SUCCESS;
}

主函数：
#include <stdio.h>
#include "LinkQueue.h"

int main()
{
int ret, i;
LinkQueue q;
ElemType e;

ret = InitQueue(&q);
if (FAILURE == ret)
{
printf("Init Failure!\n");
}
else
{
printf("Init Success!\n");
}

for(i = 0; i < 10; i++)
{
e = i;
ret = EnQueue(&q, e);

if (FAILURE == ret)
{
printf("Enter Element Failure!\n");
}
else
{
printf("Enter %d Success!\n",e);
}

}

printf("Length is %d\n", QueueLength(q));

for(i = 0; i < 7; i++)
{
ret = DelQueue(&q);

if (FAILURE == ret)
{
printf("Delete Element Failure!\n");
}
else
{
printf("Delete %d Success!\n",ret);
}
}

printf("Length is %d\n", QueueLength(q));

printf("Front is %d\n", GetFront(&q));

ret = ClearQueue(&q);

if (FAILURE == ret)
{
printf("Clear Failure!\n");
}
else
{
printf("Clear Success!\n");
}
printf("Length is %d\n", QueueLength(q));

ret = DestroyQueue(&q);

if (FAILURE == ret)
{
printf("Destroy Failure!\n");
}
else
{
printf("Destroy Success!\n");
}

return 0;
}