队列的链式存储结构

队列的链式存储结构

所谓队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已。

为了操作方便，我们将队头指针指向链队列的头结点，而队尾指针指向终点元素，注意这个时候不是尾部元素的下一个了。如图：

空队列时，头指针front和尾指针rear都指向头结点。

链队列的结构为

typedef struct QNode   //节点结构
{
    int data;
    QNode* next;
}QNode;
typedef struct QNode* QueuePtr;
typedef struct{               //队列的链表结构
    QueuePtr front,rear;
}LinkQueue;

 队列初始化操作

/*链队列初始化操作,初始化头结点*/
int InitLinkQueue(LinkQueue* Q){
    if(!Q)
        return 0;
    QueuePtr s =(QueuePtr)malloc(sizeof(QNode));
    s->next=NULL;
    Q->front=Q->rear=s; //置空
    return 0;

}

队列使用前必须初始化，申请头结点内存空间。

入队操作

/*入队操作*/
int EnQueue(LinkQueue* Q,int e){
    QueuePtr s =(QueuePtr)malloc(sizeof(QNode));  //申请新节点空间
    if(!s)
        return 0;
    s->data=e;      //赋值
    //s->next=Q->rear->next;   //并初始化,与s->next=NULL相同    
    s->next=NULL;
    Q->rear->next=s;

    Q->rear=s;
    return e;
}

入队的操作是将新节点指向rear 的next ,然后再将rear 的next指向新节点(类似单链表的插入)，最后确记要把rear移动到新节点

出队操作

/*出队操作*/
int DeQueue(LinkQueue* Q){

    int e;
    QueuePtr p;
    p=Q->front->next;    //指向第一个节点
    if(p){
        Q->front->next=p->next;    //头结点下移
        free(p);             //释放内存
        p=Q->front->next;   //p再移到头结点下
    }
    else if(p = Q->rear)          //空队列时
        Q->front = Q->rear;

    return e;
}

使用一个指针p指向头结点的下一位，然后移动头结点到p的next，再然后释放p的内存，这就释放的一个节点的空间，此时p再次移动到头结点的下一位，依次进行...

遍历队元素

/*遍历队列*/
void TraverseQueue(LinkQueue* Q){
    QueuePtr p;
    p = Q->front->next;
    while(p){
        printf("%d ",p->data);
        p=p->next;
    }    
}

遍历队元素的确记不要去移动front和rear指针的而位置，所以要再新建一个指针来遍历。

 清空队

/*清空链队列*/
int ClearLinkQueue(LinkQueue* Q){

    QueuePtr p;

    p = Q->front->next;  //p指向头结点下一个
    while(p){
        Q->front->next=p->next;   //队头移动
        if(Q->rear==p)   //删到队尾了
            Q->front = Q->rear;  //队列置空
        else if(Q->front=Q->rear)  //循环退出
            return 0;    
        free(p);   //释放内存
        p=Q->front->next;   //继续移动
    }
    return 1;
}

再清空队列的循环中确记要加上循环结束的出口，否则将陷入死循环，即当Q->real==Q->front时，队列为空 。其中指针的移动类似于出队的操作相同。

主要代码

#include <stdio.h>
#include <stdlib.h>

typedef struct QNode   //节点结构
{
    int data;
    QNode* next;
}QNode;
typedef struct QNode* QueuePtr;

typedef struct{               //队列的链表结构
    QueuePtr front,rear;
}LinkQueue;

/*链队列初始化操作,初始化头结点*/
int InitLinkQueue(LinkQueue* Q){
    if(!Q)
        return 0;
    QueuePtr s =(QueuePtr)malloc(sizeof(QNode));
    s->next=NULL;
    Q->front=Q->rear=s; //置空
    return 0;
}

/*入队操作*/
int EnQueue(LinkQueue* Q,int e){
    QueuePtr s =(QueuePtr)malloc(sizeof(QNode));
    if(!s)
        return 0;
    s->data=e;      //赋值
    //s->next=Q->rear->next;   //并初始化,与s->next=NULL相同    
    s->next=NULL;
    Q->rear->next=s;

    Q->rear=s;
    return e;
}

/*清空链队列*/
int ClearLinkQueue(LinkQueue* Q){

    QueuePtr p;

    p = Q->front->next;  //p指向头结点下一个
    while(p){
        Q->front->next=p->next;   //队头移动
        if(Q->rear==p)   //删到队尾了
            Q->front = Q->rear;  //队列置空
        else if(Q->front=Q->rear)  //循环退出
            return 0;    
        free(p);   //释放内存
        p=Q->front->next;   //继续移动
    }
    return 1;
}


/*队列是否为空*/
int ElmptyQueue(LinkQueue* Q){
    QueuePtr p;
    p=Q->front->next;
    if(p)
        return 0;
    else 
        return 1;
}

/*获取队列长度*/
int QueueLength(LinkQueue* Q){
    int count=0;
    QueuePtr p;
    p=Q->front->next;
    while(p){
        count++;
        p=p->next;
    }        
    return count;
}

/*出队操作*/
int DeQueue(LinkQueue* Q){

    int e;
    QueuePtr p;
    p=Q->front->next;    //指向第一个节点
    if(p){
        Q->front->next=p->next;    //头结点后移
        free(p);             //释放内存
        p=Q->front->next;   //p再移到头结点下
    }
    else if(p = Q->rear)          //空队列时
        Q->front = Q->rear;

    return e;
}

/*遍历队列*/
void TraverseQueue(LinkQueue* Q){
    QueuePtr p;
    p = Q->front->next;
    while(p){
        printf("%d ",p->data);
        p=p->next;
    }    
}

int main(){

    LinkQueue s;
    InitLinkQueue(&s);
    printf("入队10个元素 ：
");
    for(int i=0;i<10;i++)
    printf("%d ",EnQueue(&s,i));
    printf("
");

    printf("遍历队列
");
    TraverseQueue(&s);
    printf("
");

    printf("队元素个数");
    printf("个数：%d
",QueueLength(&s));
    printf("出队一个元素
");
    DeQueue(&s);
    printf("队元素个数");
    printf("个数：%d
",QueueLength(&s));
    
    printf("是否队列为空(1:0):%d
 ",ElmptyQueue(&s));

    printf("清空队列...");
    ClearLinkQueue(&s);
    printf("个数：%d
",QueueLength(&s));
    return 0;
}

 

 链式存储结构比顺序结构难操作，特别要注意指针的指向和指向内存的有效性。

比较循环队列和链队列的差异性：

从时间上：两者操作都是O(1)，即常数时间，不过循环队列是事先申请好空间，使用期间不能释放，而对于链队列，每次申请和释放节点也会产生一些时间上的开销

如果入队和出队频繁的话，还是存在细微差异性的，

从空间：循环队列必须有一个固定的长度，所以就有了存储元素个数和空间浪费的问题了，而链队列不存在此问题，所以在空间上，链队列更加灵活。

 附上Java代码 

package linkqueue;

public class LinkQueue {

    QNode front, rear;

    /**
     * 初始化队列
     */
    public void initLinkQueue(LinkQueue Q) {
        QNode node = new QNode();
        node.next = null;
        Q.front = Q.rear = node;
    }

    /**
     * 入队
     */
    public void enLinkQueue(LinkQueue Q, int e) {
        QNode node = new QNode();
        node.data = e;
        node.next = Q.rear.next;
        Q.rear.next = node;
        Q.rear = node;
    }

    /**
     * 出队
     */
    public int deLinkQueue(LinkQueue Q) {
        int e;
        QNode node;
        node = Q.front.next;

        if (node != null) {
            e = node.data;
            Q.front.next = node.next;
            node = Q.front.next;
            return e;
        } else if (node == Q.rear) {
            Q.rear = Q.front;
        }
        return 0;
    }

    /**
     * 清空队
     */
    public void clearLinkQueue(LinkQueue Q) {
        QNode node;
        node = Q.front.next;
        if (node == Q.rear)
            Q.rear = Q.front = null;
        while (node != null) {
            Q.front.next = node.next;
            node = Q.front.next;
        }

    }

    /**
     * 返回队列长度
     */
    public int gtLinkQueue(LinkQueue Q) {
        int count = 0;
        QNode node;
        node = Q.front.next;
        while (node != null) {
            count++;
            node = node.next;
        }
        return count;
    }

    /**
     * 遍历队元素
     */
    public void traverseList(LinkQueue Q) {
        QNode node;
        node = Q.front.next;
        while (node != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }
    }

}

package linkqueue;

public class QNode {
    int data;
    QNode next;
}

package linkqueue;

public class Test {

    public static void main(String[] args) {
        LinkQueue queue = new LinkQueue();
        System.out.println("初始化队列...");
        queue.initLinkQueue(queue);
        System.out.println("入队10个元素...");
        for (int i = 0; i < 10; i++)
            queue.enLinkQueue(queue, i);
        System.out.println("遍历队列元素...");
        queue.traverseList(queue);
        System.out.println("");

        System.out.println("出队一个元素..." + queue.deLinkQueue(queue));
        System.out.println("再出队一个元素..." + queue.deLinkQueue(queue));

        System.out.println("元素个数..." + queue.gtLinkQueue(queue));

        System.out.println("清空队列");
        queue.clearLinkQueue(queue);
        System.out.println("元素个数..." + queue.gtLinkQueue(queue));

    }

}

 完毕 -  。-