队列及其实现

　　和栈相反，队列是一种先进先出的特殊线性表，它只允许在表的一段进行插入，而在另一端删除元素，这里需要注意，队列不允许在中间部位进行操作，队列通常有两种实现方式：顺序结构实现、链式结构实现。

队列有下面几个操作：

• InitQueue（）　　 ——初始化队列
• EnQueue（）        ——进队列
• DeQueue（）        ——出队列
• IsQueueEmpty（）——判断队列是否为空
• IsQueueFull（）    ——判断队列是否已满

　　顺序结构实现如下：

 

 

　　对于顺序队列，入队的新元素是在线性表的最后，时间复杂度O(1)，出队时需要将后续的所有元素向前移动，时间复杂度时O(n)，那么如何使它的时间复杂度降低到O(1)呢？

　　定义front使其始终代表头的下标

出队时将对头元素返回，且front++

　　定义rear使其始终代表队尾下一个元素的下标

入队时将新元素插入，且rear++

　　顺序队列的关键状态

初始状态：length == 0 ， front == 0 ， rear == 0；

空队列状态：length == 0 ， front == rear；

满队列状态：length == capacity ， front == rear；

　　循环使用队列中的空间

入列：rear = (rear + 1）%capacity；

出列：front = (front + 1)%capacity；

小结：优化的顺序队列利用顺序空间提高出列操作的效率。

 

　　链式结构如下：

 

对于链式队列，入队的新元素是在线性表的最后，时间复杂度O(n)，出队时需要将后续的所有元素向前移动，时间复杂度时O(1)，那么如何使它的时间复杂度降低到O(1)呢？

　　定义rear指针始终向链表中的最后一个元素

入队时将新元素通过rear插入队尾，且将rear指向新元素

　　链式队列的关键状态

空队列状态：front == NULL ， rear == NULL；

　　关键操作

入队：

　rear -> next = node；

　rear =  node；

　node -> next = NULL；

出列：

　front = front -> next；

小结：优化的链式队列定义rear指针向队尾元素提高出列操作的效率。

　　但是这样的话，空间利用率不高，所以最后再介绍一种队列：循环队列。为充分利用向量空间，克服"假溢出"现象的方法是：将向量空间想象为一个首尾相接的圆环，如下图：

　　

　　这里需要注意的是，循环队列中，由于入队时尾指针向前追赶头指针；出队时头指针向前追赶尾指针，造成队空和队满时头尾指针均相等。因此，无法通过条件front==rear来判别队列是"空"还是"满"。在C语言中不能够用动态分配的一位数组来实现循环队列，如果用户的应用程序中设有循环队列的话，则必须为它设定一个最长队列长度；若用户无法预估所用队里的最大长度，则应该采用链式队列。具体实现代码如下：

#include<stdio.h>

#include<stdlib.h>

#define MAXSIZE 50                                    //队列是最大长度

typedef struct                                        //点实体结构
{

    char name[10];

    char id[8];

    float x,y,z;

}Point;

typedef struct                                        //循环列表结构
{

    Point *base;

    int front;

    int rear;

}SqQueue;

int initQueue(SqQueue *Q);

int isEmpty(SqQueue *Q);

int isFull(SqQueue *Q);

int enQueue(SqQueue *Q,Point e);

int deQueue(SqQueue *Q,Point *e);

int main(void)
{

    char choice;

    Point temp;

    SqQueue *Q = (SqQueue *)malloc(sizeof(SqQueue));    //声明队列

    initQueue(Q);                                        //构造队列

    printf("请选择操作：
"

        "a:入队    b:出队    q:退出
");

    while(scanf("%c", &choice) == 1)
    {
        //元素入队

        if(choice == 'a')
        {

            printf("请输入点名:
");

            scanf("%s", &temp.name);

            printf("请输入点号:
");

            scanf("%s", &temp.id);

            printf("请输入x坐标:
");

            scanf("%f", &temp.x);

            printf("请输入y坐标:
");

            scanf("%f", &temp.y);

            printf("请输入z坐标:
");

            scanf("%f", &temp.z);

            enQueue(Q, temp);                                //插入元素到队尾

            fflush(stdin);                                    //清空输入缓存

            printf("请选择操作：
"        

                "a:入队    b:出队    q:退出
");
        }

        //元素出队
        else if(choice == 'b')
        {
            //删除失败的情况

            if(deQueue(Q, &temp) == -1)

            {

                fflush(stdin);                                    //清空输入缓存

                printf("请选择操作：
"

                    "a:入队    b:出队    q:退出
");

                continue;

            }

            printf("删除的节点的信息为：
"

                "点名：%s
"

                "点号：%s
"

                "x坐标：%.2f
"

                "y坐标：%.2f
"

                "z坐标：%.2f
",

                temp.name, temp.id, temp.x, temp.y, temp.z);

            fflush(stdin);                                    //清空输入缓存

            printf("请选择操作：
"

                "a:入队    b:出队    q:退出
");

        }

        //退出

        else if(choice == 'q')

            break;

        //输入错误

        else

        {

            fflush(stdin);                                    //清空输入缓存

            printf("输入错误，输入应该为‘a’或‘b’或‘q’!
"

                "请选择操作：
"

                "a:入队    b:出队    q:退出
");

        }

    }

    free(Q->base);

    free(Q);

    printf("Done!
");

    return 0;

}

//构造一个空队列

int initQueue(SqQueue *Q)

{

    Q->base=(Point *)malloc(MAXSIZE * sizeof(Point));

    if(!Q->base)

    {

        printf("分配空间错误，初始化失败!
");

        return -1;

    }

    Q->front = Q->rear = 0;

    printf("队列初始化成功!
");

    return 0;

}

//判断队列是否为空

int isEmpty(SqQueue *Q)

{

    if(Q->front == Q->rear)

        return 1;

    else 

        return 0;

}

//判断队列是否为满

int isFull(SqQueue *Q)

{

    if(Q->front == (Q->rear + 1) % MAXSIZE)

        return 1;

    else 

        return 0;

}

//插入元素e为Q的新队尾元素

int enQueue(SqQueue *Q,Point e)
{

    if(isFull(Q))

    {

        printf("队列已满，插入失败!
");

        return -1;

    }



    Q->base[Q->rear] = e;

    Q->rear = (Q->rear + 1) % MAXSIZE;

    printf("插入成功!
");

    return 0 ;

}

//删除Q的队头元素，用e返回其值

int deQueue(SqQueue *Q,Point *e)

{

    if(isEmpty(Q)) 

    {

        printf("队列为空，删除失败!
");

        return -1;

    }
    *e = Q->base[Q->front];

    Q->front = (Q->front + 1) % MAXSIZE;

    printf("删除成功!
");

    return 0;

}       

我用Dev-C++的环境编译之后的结果如下，这里我任意输入了几个例子，以供大家体会：