3.2.3 队列的链式存储结构

辛苦手码不易, 如若有帮助烦请不吝收藏点赞 😃

可以看到, 针对队列这种数据结构, 其只需要在队尾删除结点和在队头增加结点, 故容易想到, 不妨设置两个指针, 头指针指向头/首结点, 尾指针指向尾结点, 其增删操作时间复杂度均为O(1)

链式定义&&初始化操作(带头结点)&&判空(带头)

typedef struct LinkNode{//链式队列结点
    ElemType data;
    struct LinkNode *next;
}LinkNode;
typedef struct{//链式队列
    LinkNode *front,*rear;//队头/队尾指针
}LinkQueue;

//初始化队列(带头结点)
void InitQueue(LinkQueue &Q){
    //初始化时, front rear都指向头节点
    Q.front=Q.rear=(LinkNode*)malloc(sizeof(Linknode));
    Q.front->next=NULL;
}

void testLinkQueue(){
    LinkQueue Q;//队列声明
    InitQueue(Q);//队列初始化
    //.....后续操作
}

//判空(带头)
bool IsEmpty(LinkQueue Q){
    if(Q.front==Q.rear)//或判断Q.front->next==NULL -->空
        return true;
    else
        return false;
}

初始化操作(不带头结点)&&判空(不带头)

//初始化(不带头)
void InitQueue(LinkQueue &Q){
    //队头,队尾指针都指向NULL
    Q.front=NULL;
    Q.rear=NULL;
}
//判空(不带头)
bool IsEmpty(LinkQueue Q){
    if(Q.front==NULL)
        return true;
    else
        return false;
}

入队(带头)&&(不带头)

//入队(带头)
void EnQueue(LinkQueue &Q,ElemType x){
    LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    Q.rear->next=s;//新节点插入到rear之后
    Q.rear=s;//修改表尾指针
}

//入队(不带头)
void Enqueue(LinkQueue &Q,ElemType x){
    LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
    s->data=x;
    s->next=NULL;
    if (Q.front==NULL){//在空队列中插入第一个元素
        Q.front=s;//修改队头/队尾指针
        Q.rear=s;
    }else{
        Q.rear->next=s;//新节点插入到rear结点之后
        Q.rear=s;//修改rear指针
    }
}

出队(带头)&&(不带头)

重点在于Q.front指向的是头节点还是首结点, 其次是最后一个节点的出队操作不同

带头: LinkNode*p=Q.front->next|Q.front->next=p->next

不带头: LinkNode*p=Q.front|Q.front=p->next

//队头元素出队(带头)
bool DeQueue(LinkQueue &Q,ElemType &x){
    if(Q.front==Q.rear)//空
        return false;
    LinkNode*p=Q.front->next;
    x=p->data;//用变量x返回队头元素
    Q.front->next=p->next;//修改头节点的next指针
    if(Q.rear==p)//若此次是最后一个节点出队
        Q.rear=Q.front;//修改rear指针
    free(p);//释放节点空间
    return true;
}

//队头元素出队(不带头)
bool DeQueue(LinkQueue &Q,ElemType &x){
    if(Q.front==NULL)//空
        return false;
    LinkNode*p=Q.front;//p指向此次出队的结点
    x=p->data;//用变量x返回队头元素
    Q.front=p->next;//修改头节点的next指针
    if(Q.rear==p)//若此次是最后一个节点出队
        Q.rear=NULL//rear指针置空
        Q.front=NULL;//front指针置空
    free(p);//释放节点空间
    return true;
}

对于队列的判满:

顺序存储: 预分配的空间耗尽时队满(循环队列圈满了)

链式存储: 不存在队满, 可以一直插入, 除非内存空间不足(不存在循环圈)

考虑一下在链式存储结构中, 统计队列元素个数的方法:

1. 从头开始, 逐个遍历(单链表): 时间复杂度O(n)
2. 在结构体定义时增添计数变量: 时间复杂度O(1)

typedef struct LinkNode{//链式队列结点
    ElemType data;
    struct LinkNode *next;
}LinkNode;
typedef struct{//链式队列
    LinkNode *front,*rear;//队头/队尾指针
    int length;//计数变量 初始化为0, 入队++ 出队--
}LinkQueue;