链队列的存储和入队出队操作

今天看图的广度优先遍历的时候，发现用到了队列，补一下链队列的知识，参考《大话数据结构》的P118~120，自己写了一个简单的测试例子便于理解。

理解起来并不难，用的是单链表结构。front指向链表的头结点（是虚结点，它的next指向第一个节点），rear指向链表的尾节点。

下面举个简单的例子，实现链队列的创建，入队和出队操作。

 

第一个程序调试了很久，编译没有问题，运行总是崩溃。是对内存分配没有考虑全面，先把错误的程序放上来思考一下。

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;
#define OVERFLOW 0

//链队列的结点结构
typedef struct QNode
{
    char data;
    struct QNode *next;//定义指向下一个结点的指针next
}QNode;

//队列的链式存储结构
typedef struct
{
    QNode *front,*rear;//定义指向队头结点和队尾结点的指针
}LinkQueue;

//入队操作，在链表尾部插入结点
LinkQueue *EnQueue(LinkQueue *Q,char e)
{
    Q=new LinkQueue;//或者Q=(LinkQueue*)malloc(sizeof(LinkQueue));
    Q->front=Q->rear=NULL;
    QNode *s;//定义一个指向结点的指针s
    s=new QNode;//或者s=(QNode *)malloc(sizeof(QNode));
    if(!s) exit(OVERFLOW);//如果分配结点内存失败，直接结束程序
    //exit函数的头文件是stdlib.h。
    //exit的声明为void exit(int value);
    //exit的作用是，退出程序，并将参数value的值返回给主调进程。
    //exit(a); 等效于在main函数中return a;

    //给s指向的新结点填内容
    s->data=e;
    s->next=NULL;
    Q->rear->next=s;//使rear指向结点的next指向新节点s
    Q->rear=s;//使rear指向新节点s
    cout<<"ok"<<" ";
    return Q;//返回指向该链队列的地址
}

//出队操作，把头结点的next指向的元素出队，返回出队的元素
char DeQueue(LinkQueue *Q)
{
    char e;
    QNode *s;//定义一个指向结点的指针s
    if(Q->front==Q->rear) return 0;//如果链队列为空，返回0，也可以定义其他char类型的标志
    s=Q->front->next;//把要删除的结点的地址暂存给p
    e=s->data;//把要删除的结点的data给e，需要返回该元素
    Q->front->next=s->next;//把要删除的结点的下一个结点的地址给头结点的next
    if(Q->rear==s)
        Q->rear=Q->front;//如果要删除的结点是队尾结点，说明删除该结点后链队列为空，rear和front同时指向头结点
    delete s;//或者frees);
    return e;//返回出队元素
}

int main()
{
    LinkQueue *p=NULL;
    p=EnQueue(p,'A');//插入A
    cout<<p->rear->data<<endl;
}

运行到第36行时候崩溃

通过思考，是因为没有让Q指向的链结构LinkQueue中的front和rear指针指向new出来的QNode。

 

修改后的程序可以正常运行，代码和解释如下（VS2012测试通过）：

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;

#define OVERFLOW 0

//链队列的结点结构
typedef struct QNode
{
    char data;
    struct QNode *next;//定义指向下一个结点的指针next
}QNode;

//队列的链式存储结构，可以看到只占8个字节（sizeof(LinkQueue)==8）
typedef struct
{
    QNode *front,*rear;//定义指向队头结点和队尾结点的指针
}LinkQueue;

//链队列的初始化，申请内存
LinkQueue *InitQueue(LinkQueue *Q)
{
    Q=new LinkQueue;//或者Q=(LinkQueue*)malloc(sizeof(LinkQueue));
    Q->front=Q->rear=new QNode;
    //初始化为空队列（front==rear表示空队列），并且同时指向头结点，如果只是置为相等，不指向new出来的QNode，程序会崩溃
    return Q;
}
//为什么new一个头结点，头结点的next指向链队列的第一个节点，可以思考一下如果没有头结点会怎样？

//入队操作，在链表尾部插入结点
void EnQueue(LinkQueue *Q,char e)
{
    QNode *s;//定义一个指向结点的指针s
    s=new QNode;//或者s=(QNode *)malloc(sizeof(QNode));
    if(!s) exit(OVERFLOW);//如果分配结点内存失败，直接结束程序
    //exit函数的头文件是stdlib.h。
    //exit的声明为void exit(int value);
    //exit的作用是，退出程序，并将参数value的值返回给主调进程。
    //exit(a); 等效于在main函数中return a;

    //给s指向的新结点填内容
    s->data=e;
    s->next=NULL;
    Q->rear->next=s;//使rear指向结点的next指向新节点s
    Q->rear=s;//使rear指向新节点s
    cout<<"ok"<<" ";
}

//出队操作，把头结点的next指向的元素出队，返回出队的元素
char DeQueue(LinkQueue *Q)
{
    char e;
    QNode *s;//定义一个指向结点的指针s
    if(Q->front==Q->rear) 
    {
        cout<<"error"<<" ";
        return 0;//如果链队列为空，返回0，也可以定义其他char类型的标志
    }
    s=Q->front->next;//把要删除的结点的地址暂存给p
    e=s->data;//把要删除的结点的data给e，需要返回该元素
    Q->front->next=s->next;//把要删除的结点的下一个结点的地址给头结点的next
    if(Q->rear==s)
    {
        Q->rear=Q->front;//如果要删除的结点是队尾结点，说明删除该结点后链队列为空，rear和front同时指向头结点
    }
    delete s;//或者free(s);
    cout<<"ok"<<" "<<e<<endl;//输出出队元素
    return e;//返回出队元素
}

int main()
{
    LinkQueue *p=NULL;
    p=InitQueue(p);//如果缺少这一步程序就崩溃，一开始没有注意到这个问题，花了一个多小时

    //入队
    cout<<"in:"<<endl;
    EnQueue(p,'A');//插入A
    cout<<p->rear->data<<endl;//输出A
    EnQueue(p,'B');//插入B
    cout<<p->rear->data<<endl;//输出B
    EnQueue(p,'C');//插入C
    cout<<p->rear->data<<endl;//输出C
    EnQueue(p,'D');//插入D
    cout<<p->rear->data<<endl;//输出D

    //出队
    cout<<"out:"<<endl;
    DeQueue(p);//输出A
    DeQueue(p);//输出B
    DeQueue(p);//输出C
    DeQueue(p);//输出D
    DeQueue(p);//没有元素了，出队失败
}

运行结果：

 

补充：比较循环队列和链队列

时间上：

基本操作入队和出队等都是常数时间，O(1)。

同样是O(1)，也有细微差异。循环队列事先申请好空间，使用期间不释放。链队列每次申请和释放节点会存在时间开销。

空间上：

循环队列必须有一个固定的长度，如果存储的元素个数比长度小很多，造成空间浪费的问题。

链队列只需要一个指针域，代码中有讲到占8个字节（rear和front两个指针变量分别占4个字节）。所以空间上链队列更灵活。

总结：

在可以确定队列长度最大值的情况下，建议用循环队列。如果无法预估队列长度，用链队列。