数据结构队列及其用法（C语言实现）

一、对列的定义

队列是一种特殊的线性表，它的特殊之处在于它只允许在表的前端进行删除操作，在表的后端进行插入操作，

像栈一样，队列也是一种操作受限的线性表。进行插入操作端称为队尾，进行删除操作端称为队首。在一个队列中插入一个队列元素称为入队，在队列中产出一个队列元素称为出队。

二、队列的特点

队列只允许在一段插入，在另一端删除，所以只有最早进入对列的才能最先从队列中删除，故队列又称先进先

出，即first in first out，简称FIFO。

对列有顺序队列和循环队列两种。顺序队列是指为其静态分配或者动态申请一段连续的存储空间。并设置两个

指针进行管理，一个是队头指针front，它指向队头元素；另一个是队尾指针rear，它指向下一个入队元素的存储位置，它的存储及操作结构如下：

循环队列是为了为充分利用向量空间，克服"假溢出"现象的方法是：将向量空间想象为一个首尾相接的圆环，

并称这种向量为循环向量。存储在其中的队列称为循环队列。它的存储及操作结构如下：

三、对列的基本操作

首先我们先来看下链式队列的操作：

#include<iostream>
#include<cstdio>
#include<malloc.h>
using namespace std;
typedef struct NODE
{
    int data;
    struct NODE *next;
}node;
typedef struct
{
    struct NODE *front;
    struct NODE *rear;
    int size;
}Queue;
Queue *initqueue()      //构造一个空队列
{
    Queue *p;
    p = (Queue *)malloc(sizeof(Queue));
    if(p == NULL)
        exit(0);
    p->front = NULL;
    p->rear = NULL;
    p->size = 0;
    return p;
}
void destroyqueue(Queue *p)     //销毁队列
{
    while(p->front)
    {
        p->rear = p->front->next;
        free(p->front);
        p->front = p->rear;
    }
}
void clearqueue(Queue *p)       //清空一个队列
{
    p->front = p->rear;
    p->front->next = NULL;
    p->size = 0;
}
int emptyqueue(Queue *p)       //判断队列是否为空
{
    if(p->front == NULL && p->rear == NULL)
        return 1;
    return 0;
}
int getlength(Queue *p)           //返回对列的长度
{
    return p->size;
}
int getfront(Queue *p)            //返回队首元素
{
    int a;
    if(p->front->next == NULL)
        return 0;
    a = p->front->data;
    return a;
}
void pushqueue(Queue *p, int data)          // 将一个新元素入队
{
    node *que = (node *)malloc(sizeof(node));
    que->data = data;
    que->next = NULL;
    if(emptyqueue(p))
        p->front = p->rear = que;
    else
    {
        p->rear->next = que;
        p->rear = que;
    }
    p->size++;
}
void popqueue(Queue *p)          // 将队首元素出队
{
    if(p->front->next == NULL)
        return;
    node *que;
    que = p->front;
    p->front = que->next;
    if(p->rear == que)
        p->rear = NULL;
    p->size--;
    free(que);
}
int main()
{
    Queue *p;
    p = initqueue();
    for(int i=0;i<10;i++)
        pushqueue(p, i);
    int n = getlength(p);
    printf("%d\n", n);
    clearqueue(p);
    for(int i=0;i<10;i++)
    {
        int a = getfront(p);
        printf("%d  ", a);
        popqueue(p);
    }
    printf("\n");
    int n1 = getlength(p);
    printf("%d\n", n1);
    destroyqueue(p);

    return 0;
}

我们在无法估计队列长度时就要用到上述的链式队列。

但是如果我们队列长度的最大值是确定的，那么我们可以使用下面的循环队列：

#include<stdio.h>
#include<malloc.h>
#define MAXSIZE 20  //队列的最大长度
typedef struct
{
    int data[MAXSIZE]; //队列
    int front; //队头的游标
    int rear;  //队尾的游标
} Queue;
void InitQueue(Queue *q) //初始化队列
{
    q->front = q->rear = 0;
}
void EnQueue(Queue *q,int e) //让元素e进队
{
    if((q->rear + 1) % MAXSIZE == q->front) //队列已满
        return;
    q->data[q->rear] = e; //元素e进队
    q->rear = (q->rear + 1) % MAXSIZE; //游标rear上前进一位,如果已达最后,就移到前面
}
void DeQueue(Queue *q,int *e) //队头的元素出队存入*e
{
    if(q->rear == q->front) //如果队列为空返回
        return;
    *e = q->data[q->front]; //返回队头的元素
    q->front = (q->front + 1) % MAXSIZE; //游标front向前移一位,如果是队列的末尾移动到最前面
}
int IsEmpty(Queue *q) //判断队列是否为空
{
    if(q->front == q->rear)
        return 1;
    return 0;
}
int GetQueueLength(Queue *q) //返回队列的长度
{
    return (q->rear - q->front + MAXSIZE) % MAXSIZE;
}
void Clear(Queue *q) //清空队列
{
    q->front = q->rear = 0;
}
void Print(Queue *q) //打印队列
{
    if(q->front == q->rear)
        return;
    else if(q->rear < q->front)
    {
        for(int i = q->front; i < MAXSIZE; ++i)
            printf("%d ",q->data[i]);
        for(int i = 0; i < q->rear; ++i)
            printf("%d ",q->data[i]);
        printf("\n");
    }
    else
    {
        for(int i = q->front; i < q->rear; ++i)
            printf("%d ",q->data[i]);
        printf("\n");
    }
}
int main()
{
    Queue q;
    InitQueue(&q);
    for(int i = 1; i < 20; ++i)
        EnQueue(&q,i);
    Print(&q);
    int k;
    DeQueue(&q,&k);
    EnQueue(&q,30);
    Print(&q);
    return 0;
}